From 2cc33a721c3b38fe75aefb8c13b739274e30f01a Mon Sep 17 00:00:00 2001 From: Justin Visser Date: Mon, 10 Aug 2026 21:38:14 +0200 Subject: [PATCH 1/7] fix(frontend): refine streamed presentation and resolve stream edge cases --- docs/logboek.md | 45 +++++ frontend/package-lock.json | 27 +++ frontend/package.json | 3 + frontend/src/components/AppHeader.vue | 31 +++- frontend/src/components/AssistantMessage.vue | 4 +- frontend/src/components/ChatView.vue | 1 + frontend/src/components/MessageList.vue | 8 +- frontend/src/components/ResultSet.vue | 35 +++- frontend/src/components/SuggestionChips.vue | 71 ++++--- frontend/src/components/TrackCard.vue | 1 + frontend/src/composables/useChatStream.ts | 6 +- frontend/src/lib/messages.ts | 7 +- frontend/src/lib/recommendationStream.ts | 1 + frontend/src/main.ts | 4 + frontend/src/style.css | 7 + frontend/tests/recommendationStream.test.ts | 15 ++ frontend/tests/resultPresentation.test.ts | 186 +++++++++++++++++++ frontend/tests/useChatStream.test.ts | 44 ++++- 18 files changed, 450 insertions(+), 46 deletions(-) create mode 100644 frontend/tests/resultPresentation.test.ts diff --git a/docs/logboek.md b/docs/logboek.md index 139966d..e0782b2 100644 --- a/docs/logboek.md +++ b/docs/logboek.md @@ -273,3 +273,48 @@ Waarom: - Machine-geconverteerde UI-code krijgt dezelfde behandeling als de backend: een review-pass met concrete findings en een test-suite die de contractkritische randen vastzet, voordat het richting main gaat. + +## Dag 3 - avond +### Live eval run + +Wat ik deed: + +- Alle 8 scenario's in 1 run live gedraaid, plus de baseline arm (bare + search) voor de comparison table. +- Het Spotify-dagquotum was eerder al een keer vol; daarom vooraf + maatregelen genomen: scenario's sequentieel, geen retries, de server-boot + zelf als quota-check, en live meegekeken op 429's (niet gehit). +- Uitkomst: 4 scenario's pass, 3 vallen alleen op een te strenge + synonym-check in de eval zelf (gefixt), en discover-new faalt echt: + call 1 verzint bij familiarity=new titels die niet bestaan, dus er + overleeft niets de grounding. Fix volgt in de intent prompt. +- De refinement turn deed live 0 Spotify calls: pool reuse werkt. + +Waarom: + +- De comparison table in de README wil ik op echte metingen baseren, en het + quotum maakt herhalen duur. + +Wat ik heb laten vallen of uitgesteld: + +- discover-new opnieuw opnemen wacht op de prompt fix. + +### Frontend: presentatie + +Wat ik deed: + +- Cards komen rustig gestaggerd binnen (met reduced-motion pad), results + en chips scrollen in eigen panelen zodat de summary zichtbaar blijft, + klik op het logo start een nieuwe chat, fonts self-hosted. +- Een error die voor de metadata binnenkomt is nu een echte foutmelding + in de chat, geen transport failure. Playlist-namen hadden een dubbele + prefix; de frontend stuurt nu de kale query. 10 nieuwe tests. + +Waarom: + +- Dit is wat de reviewer als eerste ziet; rustige presentatie en eerlijke + foutmeldingen gaan voor extra features. + +Wat ik heb laten vallen of uitgesteld: + +- Verdere styling; de tijd gaat naar eval, demo mode en de README. diff --git a/frontend/package-lock.json b/frontend/package-lock.json index 8052233..b8de0b4 100644 --- a/frontend/package-lock.json +++ b/frontend/package-lock.json @@ -8,6 +8,9 @@ "name": "frontend", "version": "0.0.0", "dependencies": { + "@fontsource/bricolage-grotesque": "^5.3.0", + "@fontsource/jetbrains-mono": "^5.3.0", + "@fontsource/public-sans": "^5.3.0", "vue": "^3.5.40" }, "devDependencies": { @@ -156,6 +159,30 @@ "node": "^20.19.0 || ^22.13.0 || >=24" } }, + "node_modules/@fontsource/bricolage-grotesque": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/@fontsource/bricolage-grotesque/-/bricolage-grotesque-5.3.0.tgz", + "integrity": "sha512-MdOVb/5in11IfN/IQJOExMuu6AroCIQbirl0yX7NUvKk+h0HYIKfGaVAXRS/gCPil4aFxWhjZnOw28tUwv7tFw==", + "funding": { + "url": "https://github.com/sponsors/ayuhito" + } + }, + "node_modules/@fontsource/jetbrains-mono": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/@fontsource/jetbrains-mono/-/jetbrains-mono-5.3.0.tgz", + "integrity": "sha512-fqDfB5I9f1p1TV486aUgB9t8zP84P0O1FtQR5Ol9vjwPy+S+EIGlVYm1cvj2W5shcZMTg2nZFdVMoH5wFu8a1A==", + "funding": { + "url": "https://github.com/sponsors/ayuhito" + } + }, + "node_modules/@fontsource/public-sans": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/@fontsource/public-sans/-/public-sans-5.3.0.tgz", + "integrity": "sha512-kjODI0S3zdv0mBYCIQ8TbBayaiqszpc2UbhJiO3bjIqVVXzcWfHSt2o3WBCLOY3juaGaQoy4MoWCcgmfI5hCuA==", + "funding": { + "url": "https://github.com/sponsors/ayuhito" + } + }, "node_modules/@humanfs/core": { "version": "0.19.2", "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz", diff --git a/frontend/package.json b/frontend/package.json index a47d400..a4e68a3 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -13,6 +13,9 @@ "typecheck": "vue-tsc --noEmit -p tsconfig.app.json" }, "dependencies": { + "@fontsource/bricolage-grotesque": "^5.3.0", + "@fontsource/jetbrains-mono": "^5.3.0", + "@fontsource/public-sans": "^5.3.0", "vue": "^3.5.40" }, "devDependencies": { diff --git a/frontend/src/components/AppHeader.vue b/frontend/src/components/AppHeader.vue index 5e6d62f..786f1ff 100644 --- a/frontend/src/components/AppHeader.vue +++ b/frontend/src/components/AppHeader.vue @@ -9,7 +9,7 @@ const props = defineProps<{ mode: AppMode | null healthFailed: boolean }>() -const emit = defineEmits<{ logout: []; toggleDev: [opener: HTMLElement] }>() +const emit = defineEmits<{ logout: []; reset: []; toggleDev: [opener: HTMLElement] }>() function openDevPanel(event: MouseEvent): void { if (event.currentTarget instanceof HTMLElement) { @@ -29,11 +29,18 @@ const modeLabel = computed(() => {
- {{ messages.appHeaderBrandPrefix - }}{{ messages.appHeaderBrandAccent }}{{ messages.appHeaderBrandSuffix }} + {{ messages.appHeaderBrandPrefix + }}{{ messages.appHeaderBrandAccent }}{{ messages.appHeaderBrandSuffix }} + {{ messages.appHeaderKicker }}
@@ -78,6 +85,20 @@ const modeLabel = computed(() => { min-width: 0; } +.brand-control { + padding: 0; + color: inherit; + cursor: pointer; + background: transparent; + border: 0; + border-radius: var(--r-sm); +} + +.brand-control:focus-visible { + outline: 2px solid var(--c-accent); + outline-offset: 4px; +} + .wordmark { font-family: var(--f-display); font-size: var(--t-brand); diff --git a/frontend/src/components/AssistantMessage.vue b/frontend/src/components/AssistantMessage.vue index 85c3d02..b974c8b 100644 --- a/frontend/src/components/AssistantMessage.vue +++ b/frontend/src/components/AssistantMessage.vue @@ -42,8 +42,6 @@ const isEmptyResult = computed(

{{ turn.intentSummary }}

- - + +
diff --git a/frontend/src/components/ChatView.vue b/frontend/src/components/ChatView.vue index fb1f585..fa7a697 100644 --- a/frontend/src/components/ChatView.vue +++ b/frontend/src/components/ChatView.vue @@ -112,6 +112,7 @@ onUnmounted(() => window.removeEventListener('keydown', onShortcut)) :mode="mode" :health-failed="health.status === 'failed'" @logout="logout" + @reset="reset" @toggle-dev="openDevPanel" /> diff --git a/frontend/src/components/MessageList.vue b/frontend/src/components/MessageList.vue index d6676b3..50fc7e0 100644 --- a/frontend/src/components/MessageList.vue +++ b/frontend/src/components/MessageList.vue @@ -69,7 +69,13 @@ async function scrollToLatest(): Promise { if (!pinned.value) return await nextTick() requestAnimationFrame(() => { - if (list.value) list.value.scrollTop = list.value.scrollHeight + const element = list.value + if (!element) return + if (latestAssistant.value?.status === 'done') { + element.querySelector('.turn:last-child')?.scrollIntoView({ block: 'start' }) + return + } + element.scrollTop = element.scrollHeight }) } diff --git a/frontend/src/components/ResultSet.vue b/frontend/src/components/ResultSet.vue index 7e46790..8030cf9 100644 --- a/frontend/src/components/ResultSet.vue +++ b/frontend/src/components/ResultSet.vue @@ -1,14 +1,28 @@ @@ -17,5 +31,18 @@ defineProps<{ tracks: TrackEvent[] }>() display: flex; flex-direction: column; gap: var(--s-2); + max-height: min(42dvh, 480px); + padding: var(--s-2) var(--s-3) var(--s-2) 0; + overflow-y: auto; + overscroll-behavior-y: contain; + border-block: 1px solid var(--c-line); + scrollbar-color: var(--c-line-strong) transparent; + scrollbar-width: thin; +} + +@media (max-width: 560px) { + .set { + max-height: min(34dvh, 360px); + } } diff --git a/frontend/src/components/SuggestionChips.vue b/frontend/src/components/SuggestionChips.vue index 3252a6b..8f0dfdd 100644 --- a/frontend/src/components/SuggestionChips.vue +++ b/frontend/src/components/SuggestionChips.vue @@ -1,27 +1,60 @@ diff --git a/frontend/src/components/TrackCard.vue b/frontend/src/components/TrackCard.vue index 8244a9f..af8b3e3 100644 --- a/frontend/src/components/TrackCard.vue +++ b/frontend/src/components/TrackCard.vue @@ -53,6 +53,7 @@ const artworkAlt = computed(() => border-color var(--dur-fast) ease, background var(--dur-fast) ease; animation: card-in var(--dur-card) var(--ease) both; + animation-delay: calc(var(--card-order, 0) * var(--dur-card-stagger)); } .card:hover { diff --git a/frontend/src/composables/useChatStream.ts b/frontend/src/composables/useChatStream.ts index 1e9b2b1..71ac7cd 100644 --- a/frontend/src/composables/useChatStream.ts +++ b/frontend/src/composables/useChatStream.ts @@ -7,7 +7,7 @@ import { PRIOR_RECOMMENDATIONS_MAX_TRACKS, QUERY_MAX_LENGTH, } from '../lib/constants' -import { formatMessage, messages } from '../lib/messages' +import { messages } from '../lib/messages' import type { AssistantTurn, ChatTurn, EventLogEntry, TransportFailure } from '../lib/models' import { EMPTY_PLAYLIST_STATE } from '../lib/models' import { @@ -101,9 +101,7 @@ function reduceEvent(turn: AssistantTurn, event: StreamEvent): AssistantTurn { } function playlistName(query: string): string { - return formatMessage('useChatStreamPlaylistName', { query }) - .slice(0, PLAYLIST_NAME_MAX_LENGTH) - .trim() + return query.slice(0, PLAYLIST_NAME_MAX_LENGTH).trim() } function createTurnId(): string { diff --git a/frontend/src/lib/messages.ts b/frontend/src/lib/messages.ts index 11508c1..4add1fe 100644 --- a/frontend/src/lib/messages.ts +++ b/frontend/src/lib/messages.ts @@ -2,6 +2,7 @@ export const messages = { appHeaderBrandPrefix: 'discovery', + appHeaderBrandResetLabel: 'discovery-by-llm: start a new chat', appHeaderBrandAccent: '-by-', appHeaderBrandSuffix: 'llm', appHeaderKicker: 'proof of concept', @@ -90,10 +91,13 @@ export const messages = { resultActionsConnectSpotify: 'Connect Spotify to save', resultActionsSummary: '{count} verified tracks ready for a private playlist', - resultSetRecommendedTracksLabel: 'Recommended tracks', + resultSetRecommendedTrackLabel: '{count} recommended track', + resultSetRecommendedTracksLabel: '{count} recommended tracks', streamErrorRetry: 'Edit and retry', + suggestionChipsRegionLabel: 'Listening suggestions', + trackCardArtworkAlt: '{album} album artwork', trackCardOpenSpotify: 'Open in Spotify', @@ -110,7 +114,6 @@ export const messages = { useApiPlaylistCreationFailed: 'Playlist creation returned {status}.', useChatStreamTrackCountMismatch: 'The final track count did not match the streamed results.', - useChatStreamPlaylistName: '[discovery-by-llm] {query}', useChatStreamRequestReplaced: 'This request was replaced by a newer request.', useChatStreamUnexpectedFailure: 'The recommendation request failed unexpectedly.', useChatStreamTransportEvent: 'transport', diff --git a/frontend/src/lib/recommendationStream.ts b/frontend/src/lib/recommendationStream.ts index f8580d3..6c89a64 100644 --- a/frontend/src/lib/recommendationStream.ts +++ b/frontend/src/lib/recommendationStream.ts @@ -36,6 +36,7 @@ function parseLine(line: string): StreamEvent { function advancePhase(phase: StreamPhase, event: StreamEvent): StreamPhase { if (phase === 'metadata') { if (event.type === 'metadata') return 'events' + if (event.type === 'error') return 'terminal' throw new StreamTransportError('protocol', messages.recommendationStreamMissingMetadata) } if (phase === 'events') { diff --git a/frontend/src/main.ts b/frontend/src/main.ts index 2425c0f..37bbb42 100644 --- a/frontend/src/main.ts +++ b/frontend/src/main.ts @@ -1,4 +1,8 @@ import { createApp } from 'vue' +import '@fontsource/bricolage-grotesque/600.css' +import '@fontsource/jetbrains-mono/400.css' +import '@fontsource/public-sans/400.css' +import '@fontsource/public-sans/500.css' import './style.css' import App from './App.vue' diff --git a/frontend/src/style.css b/frontend/src/style.css index fb429cb..a43b9a6 100644 --- a/frontend/src/style.css +++ b/frontend/src/style.css @@ -74,6 +74,11 @@ --shadow-drawer: -24px 0 60px rgba(0, 0, 0, 0.45); --ease: cubic-bezier(0.2, 0.8, 0.3, 1); + --dur-fast: 0.16s; + --dur-card: 0.4s; + --dur-card-stagger: 0.08s; + --dur-reduced-motion: 0.001s; + color-scheme: dark; color: var(--c-text); background: var(--c-bg); @@ -151,7 +156,9 @@ a:hover { *::before, *::after { scroll-behavior: auto !important; + animation-delay: var(--dur-reduced-motion) !important; animation-duration: var(--dur-reduced-motion) !important; + transition-delay: var(--dur-reduced-motion) !important; transition-duration: var(--dur-reduced-motion) !important; } } diff --git a/frontend/tests/recommendationStream.test.ts b/frontend/tests/recommendationStream.test.ts index f9bb7b4..436fe4b 100644 --- a/frontend/tests/recommendationStream.test.ts +++ b/frontend/tests/recommendationStream.test.ts @@ -128,8 +128,23 @@ describe('streamRecommendations', () => { expect(wasCancelled).toBe(true) }) + it('accepts a terminal error as the only event', async () => { + const error = { type: 'error', code: 'first_stage_failed', message: 'Planning failed.' } + stubResponse(streamResponse([encoder.encode(`${JSON.stringify(error)}\n`)])) + const events: StreamEvent[] = [] + + await streamRecommendations( + { schema_version: 1, query: 'focus', history: [], prior_recommendations: [] }, + new AbortController().signal, + (event) => events.push(event), + ) + + expect(events).toEqual([error]) + }) + it.each([ ['an event before metadata', [{ type: 'warning', code: 'early', message: 'No metadata.' }]], + ['done before metadata', [{ type: 'done', track_count: 0, total_ms: 4 }]], [ 'duplicate metadata', [ diff --git a/frontend/tests/resultPresentation.test.ts b/frontend/tests/resultPresentation.test.ts new file mode 100644 index 0000000..d46ca31 --- /dev/null +++ b/frontend/tests/resultPresentation.test.ts @@ -0,0 +1,186 @@ +import { createApp, defineComponent, h, nextTick, ref } from 'vue' +import type { Component } from 'vue' +import { afterEach, describe, expect, it, vi } from 'vitest' +import AppHeader from '../src/components/AppHeader.vue' +import AssistantMessage from '../src/components/AssistantMessage.vue' +import MessageList from '../src/components/MessageList.vue' +import SuggestionChips from '../src/components/SuggestionChips.vue' +import type { AssistantTurn, ChatTurn } from '../src/lib/models' +import type { TrackEvent } from '../src/lib/types' + +const unmountCallbacks: Array<() => void> = [] + +function track(rank: number): TrackEvent { + return { + type: 'track', + rank, + track: { + id: `track-${rank}`, + uri: `spotify:track:${rank}`, + title: `Track ${rank}`, + artists: ['Artist'], + album_name: 'Album', + album_art_url: null, + external_url: null, + }, + justification: 'It fits.', + } +} + +function doneTurn(): AssistantTurn { + return { + id: 'assistant-1', + role: 'assistant', + query: 'Focused listening', + status: 'done', + requestId: 'request-1', + intentSummary: 'Calm music for focused work.', + candidateCount: 20, + tracks: [track(1), track(2)], + warnings: [{ type: 'warning', code: 'limited_pool', message: 'The pool was limited.' }], + error: null, + transportFailure: null, + completion: { type: 'done', track_count: 2, total_ms: 12 }, + playlist: { status: 'idle', name: null, url: null, message: null }, + } +} + +function mountComponent(component: Component, props: Record): HTMLElement { + const root = document.createElement('div') + document.body.append(root) + const app = createApp( + defineComponent({ + render: () => h(component, props), + }), + ) + app.mount(root) + unmountCallbacks.push(() => { + app.unmount() + root.remove() + }) + return root +} + +afterEach(() => { + while (unmountCallbacks.length) unmountCallbacks.pop()?.() + vi.restoreAllMocks() +}) + +describe('result presentation', () => { + it('uses the app title as a fresh-chat control', () => { + const onReset = vi.fn() + const root = mountComponent(AppHeader, { + auth: { status: 'anonymous', user: null, message: null }, + mode: 'demo', + healthFailed: false, + onReset, + }) + const button = root.querySelector( + 'button[aria-label="discovery-by-llm: start a new chat"]', + ) + + expect(button?.type).toBe('button') + expect(button?.textContent).toContain('discovery-by-llm') + button?.click() + expect(onReset).toHaveBeenCalledOnce() + }) + + it('keeps completion context outside the focusable track region', () => { + const root = mountComponent(AssistantMessage, { turn: doneTurn(), canSave: true }) + const region = root.querySelector( + '[role="region"][aria-label="2 recommended tracks"]', + ) + const summary = root.querySelector('.intent') + const warning = root.querySelector('[data-warning-code="limited_pool"]') + const action = root.querySelector('button') + + expect(region?.tabIndex).toBe(0) + expect(region?.querySelectorAll('article')).toHaveLength(2) + expect(summary?.textContent).toContain('Calm music') + expect(warning?.textContent).toContain('pool was limited') + expect(action?.textContent).toContain('Save as playlist') + expect(region?.contains(summary ?? null)).toBe(false) + expect(region?.contains(warning ?? null)).toBe(false) + expect(region?.contains(action ?? null)).toBe(false) + }) + + it('assigns a deliberate stagger order to arriving cards', () => { + const root = mountComponent(AssistantMessage, { turn: doneTurn(), canSave: true }) + const cards = root.querySelectorAll('article') + + expect(cards[0]?.style.getPropertyValue('--card-order')).toBe('0') + expect(cards[1]?.style.getPropertyValue('--card-order')).toBe('1') + }) + + it('anchors a completed response at the top of the conversation viewport', async () => { + const scrollIntoView = vi + .spyOn(Element.prototype, 'scrollIntoView') + .mockImplementation(() => undefined) + vi.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => { + callback(0) + return 1 + }) + const complete = doneTurn() + const turns = ref([ + { id: 'user-1', role: 'user', text: 'Focused listening' }, + { ...complete, status: 'streaming', completion: null }, + ]) + const root = document.createElement('div') + document.body.append(root) + const app = createApp( + defineComponent({ + render: () => + h(MessageList, { + turns: turns.value, + suggestions: [], + canSave: true, + }), + }), + ) + app.mount(root) + unmountCallbacks.push(() => { + app.unmount() + root.remove() + }) + + turns.value = [turns.value[0] as ChatTurn, complete] + await nextTick() + await nextTick() + + expect(scrollIntoView).toHaveBeenCalledWith({ block: 'start' }) + }) + + it('keeps suggestions in a labeled focusable row', () => { + const onPick = vi.fn() + const suggestions = ['Focus', 'Energy', 'Surprise'] + const root = mountComponent(SuggestionChips, { suggestions, onPick }) + const region = root.querySelector('[aria-label="Listening suggestions"]') + const buttons = root.querySelectorAll('button') + + expect(region?.tabIndex).toBe(0) + expect(buttons).toHaveLength(suggestions.length) + expect([...buttons].map((button) => button.textContent?.trim())).toEqual(suggestions) + + buttons[0]?.click() + expect(onPick).toHaveBeenCalledWith('Focus') + }) + + it('renders a first-stage stream error with its code and message', () => { + const turn: AssistantTurn = { + ...doneTurn(), + status: 'error', + requestId: null, + intentSummary: '', + tracks: [], + warnings: [], + error: { type: 'error', code: 'first_stage_failed', message: 'Planning failed.' }, + transportFailure: null, + completion: null, + } + const root = mountComponent(AssistantMessage, { turn, canSave: false }) + const alert = root.querySelector('[role="alert"]') + + expect(alert?.dataset.errorCode).toBe('first_stage_failed') + expect(alert?.textContent).toContain('Planning failed.') + }) +}) diff --git a/frontend/tests/useChatStream.test.ts b/frontend/tests/useChatStream.test.ts index 1a8fbf9..5adaf8d 100644 --- a/frontend/tests/useChatStream.test.ts +++ b/frontend/tests/useChatStream.test.ts @@ -13,14 +13,16 @@ vi.mock('../src/lib/recommendationStream', async (importOriginal) => { const streamMock = vi.mocked(streamRecommendations) const unmountCallbacks: Array<() => void> = [] -function mountChat() { +function mountChat( + createPlaylist: Parameters[0] = vi.fn(async () => ({ url: null })), +) { let chat: ReturnType | undefined const root = document.createElement('div') document.body.append(root) const app = createApp( defineComponent({ setup() { - chat = useChatStream(vi.fn(async () => ({ url: null }))) + chat = useChatStream(createPlaylist) return () => h('div') }, }), @@ -106,6 +108,22 @@ describe('useChatStream', () => { expect(turn?.transportFailure).toBeNull() }) + it('stores a metadata-free terminal error as a normal stream error', async () => { + streamMock.mockImplementation(async (_request, _signal, onEvent) => { + onEvent({ type: 'error', code: 'first_stage_failed', message: 'Planning failed.' }) + }) + const chat = mountChat() + + await chat.send('error') + + expect(assistantTurns(chat)[0]).toMatchObject({ + status: 'error', + requestId: null, + error: { code: 'first_stage_failed', message: 'Planning failed.' }, + transportFailure: null, + }) + }) + it('stores an incomplete stream as a transport failure', async () => { streamMock.mockRejectedValue( new StreamTransportError('unexpected_eof', 'The stream ended early.'), @@ -239,4 +257,26 @@ describe('useChatStream', () => { expect(receivedQuery).toHaveLength(1000) }) + + it('uses the bare query as the capped playlist name', async () => { + const createPlaylist = vi.fn(async () => ({ url: null })) + streamMock.mockImplementation(async (_request, _signal, onEvent) => { + onEvent(metadata('playlist')) + onEvent(track(1)) + onEvent({ type: 'done', track_count: 1, total_ms: 5 }) + }) + const chat = mountChat(createPlaylist) + const query = `Late-night instrumental focus ${'x'.repeat(100)}` + + await chat.send(query) + const turn = assistantTurns(chat)[0] + if (!turn) throw new Error('Assistant turn was not created.') + await chat.savePlaylist(turn.id) + + expect(createPlaylist).toHaveBeenCalledWith({ + schema_version: 1, + name: query.slice(0, 100), + track_uris: ['spotify:track:1'], + }) + }) }) From 3555256a025fa4fa70b9e093896c860a9dcf40f5 Mon Sep 17 00:00:00 2001 From: Justin Visser Date: Mon, 10 Aug 2026 21:50:48 +0200 Subject: [PATCH 2/7] fix: harden request handling, pipeline containment, and startup boundaries --- backend/app/adapters/anthropic/llm.py | 3 +- backend/app/adapters/spotify/client.py | 103 +++++++++------ backend/app/adapters/spotify/errors.py | 6 +- backend/app/adapters/spotify/session.py | 11 +- backend/app/api/recommendations.py | 20 ++- backend/app/config.py | 2 + backend/app/main.py | 21 ++- backend/app/pipeline/grounding.py | 33 +++-- backend/app/pipeline/orchestrator.py | 86 ++++++++---- backend/tests/test_anthropic_llm.py | 13 ++ backend/tests/test_auth_routes.py | 23 ++++ backend/tests/test_grounding.py | 160 ++++++++++++++++++++++- backend/tests/test_health.py | 17 +++ backend/tests/test_orchestrator.py | 112 +++++++++++++++- backend/tests/test_recommendation_api.py | 35 ++++- backend/tests/test_spotify_auth.py | 17 +++ backend/tests/test_spotify_client.py | 75 +++++++++-- docs/logboek.md | 26 ++++ 18 files changed, 656 insertions(+), 107 deletions(-) create mode 100644 backend/tests/test_anthropic_llm.py diff --git a/backend/app/adapters/anthropic/llm.py b/backend/app/adapters/anthropic/llm.py index 6225e03..b4558eb 100644 --- a/backend/app/adapters/anthropic/llm.py +++ b/backend/app/adapters/anthropic/llm.py @@ -221,7 +221,8 @@ class _RecommendationObjectParser: return None def _finish_object(self) -> RerankSelectionOutput: - assert self._object_start is not None + if self._object_start is None: + raise RecommenderOutputError("Rerank parser lost the object start position") object_text = self.complete_text[self._object_start : self._scan_index + 1] self._object_start = None try: diff --git a/backend/app/adapters/spotify/client.py b/backend/app/adapters/spotify/client.py index 5aee722..9791540 100644 --- a/backend/app/adapters/spotify/client.py +++ b/backend/app/adapters/spotify/client.py @@ -7,6 +7,7 @@ import httpx2 from app.adapters.spotify.auth import refresh_access_token from app.adapters.spotify.errors import ( SpotifyAuthenticationError, + SpotifyQuotaExhaustedError, SpotifyRateLimitedError, SpotifyRequestError, SpotifyUnavailableError, @@ -119,7 +120,7 @@ class SpotifyClient: params: dict[str, str | int] | None = None, json: dict[str, object] | None = None, ) -> httpx2.Response: - access_token = await self._access_token() + access_token, refresh_generation = await self._access_token() response = await self._send( method, path, @@ -127,18 +128,27 @@ class SpotifyClient: params=params, json=json, ) - response = await self._retry_once_if_unauthorized( + response, refresh_generation = await self._retry_once_if_unauthorized( response, method, path, - access_token, + refresh_generation, params=params, json=json, ) - response = await self._retry_once_if_rate_limited( + response, refresh_generation = await self._retry_once_if_rate_limited( response, method, path, + refresh_generation, + params=params, + json=json, + ) + response, _ = await self._retry_once_if_unauthorized( + response, + method, + path, + refresh_generation, params=params, json=json, ) @@ -154,34 +164,41 @@ class SpotifyClient: json: dict[str, object] | None, ) -> httpx2.Response: increment_spotify_calls() - return await self.http.request( - method, - f"{self.settings.spotify_api_base_url.rstrip('/')}{path}", - params=params, - json=json, - headers={"Authorization": f"Bearer {access_token}"}, - ) + try: + return await self.http.request( + method, + f"{self.settings.spotify_api_base_url.rstrip('/')}{path}", + params=params, + json=json, + headers={"Authorization": f"Bearer {access_token}"}, + ) + except httpx2.HTTPError as error: + raise SpotifyUnavailableError(504, "Spotify request failed") from error async def _retry_once_if_unauthorized( self, response: httpx2.Response, method: str, path: str, - access_token: str, + refresh_generation: int, *, params: dict[str, str | int] | None, json: dict[str, object] | None, - ) -> httpx2.Response: + ) -> tuple[httpx2.Response, int]: if response.status_code != 401: - return response + return response, refresh_generation - await self._refresh_if_current(access_token) - return await self._send( - method, - path, - self.session.tokens.access_token, - params=params, - json=json, + await self._refresh_if_current(refresh_generation) + access_token, retry_generation = self._token_snapshot() + return ( + await self._send( + method, + path, + access_token, + params=params, + json=json, + ), + retry_generation, ) async def _retry_once_if_rate_limited( @@ -189,12 +206,13 @@ class SpotifyClient: response: httpx2.Response, method: str, path: str, + refresh_generation: int, *, params: dict[str, str | int] | None, json: dict[str, object] | None, - ) -> httpx2.Response: + ) -> tuple[httpx2.Response, int]: if response.status_code != 429: - return response + return response, refresh_generation retry_after_seconds = _parse_retry_after(response) _, reason = _parse_error_details(response) @@ -204,15 +222,19 @@ class SpotifyClient: or retry_after_seconds is None or retry_after_seconds > self.settings.spotify_retry_after_cap_seconds ): - return response + return response, refresh_generation await asyncio.sleep(retry_after_seconds) - return await self._send( - method, - path, - self.session.tokens.access_token, - params=params, - json=json, + access_token, retry_generation = self._token_snapshot() + return ( + await self._send( + method, + path, + access_token, + params=params, + json=json, + ), + retry_generation, ) def _raise_for_error(self, response: httpx2.Response) -> httpx2.Response: @@ -223,26 +245,33 @@ class SpotifyClient: if response.status_code == 401: raise SpotifyAuthenticationError("Spotify rejected refreshed authentication") if response.status_code == 429: + if reason == "QUOTA_EXCEEDED": + raise SpotifyQuotaExhaustedError(_parse_retry_after(response), reason) raise SpotifyRateLimitedError(_parse_retry_after(response), reason) if response.status_code >= 500: raise SpotifyUnavailableError(response.status_code, message) raise SpotifyRequestError(response.status_code, message) - async def _access_token(self) -> str: - access_token = self.session.tokens.access_token - if self.session.tokens.is_expired: - await self._refresh_if_current(access_token) - return self.session.tokens.access_token + async def _access_token(self) -> tuple[str, int]: + tokens = self.session.tokens + refresh_generation = self.session.refresh_generation + if tokens.is_expired: + await self._refresh_if_current(refresh_generation) + return self._token_snapshot() - async def _refresh_if_current(self, access_token: str) -> None: + async def _refresh_if_current(self, refresh_generation: int) -> None: async with self.session.refresh_lock: - if self.session.tokens.access_token != access_token: + if self.session.refresh_generation != refresh_generation: return self.session.tokens = await refresh_access_token( self.http, client_id=self.settings.spotify_client_id, tokens=self.session.tokens, ) + self.session.refresh_generation += 1 + + def _token_snapshot(self) -> tuple[str, int]: + return self.session.tokens.access_token, self.session.refresh_generation def _parse_retry_after(response: httpx2.Response) -> float | None: diff --git a/backend/app/adapters/spotify/errors.py b/backend/app/adapters/spotify/errors.py index 9665573..74468e0 100644 --- a/backend/app/adapters/spotify/errors.py +++ b/backend/app/adapters/spotify/errors.py @@ -11,7 +11,7 @@ class SpotifyAuthenticationError(SpotifyError): """Spotify rejected authentication or token refresh.""" -class SpotifyRateLimitedError(SpotifyError, CatalogQuotaExhaustedError): +class SpotifyRateLimitedError(SpotifyError): """Spotify rate limited a request that could not be retried.""" def __init__(self, retry_after_seconds: float | None, reason: str | None = None) -> None: @@ -21,6 +21,10 @@ class SpotifyRateLimitedError(SpotifyError, CatalogQuotaExhaustedError): self.reason = reason +class SpotifyQuotaExhaustedError(SpotifyRateLimitedError, CatalogQuotaExhaustedError): + """Spotify rejected a request because the application quota is exhausted.""" + + class SpotifyUnavailableError(SpotifyError): """Spotify returned a server-side failure.""" diff --git a/backend/app/adapters/spotify/session.py b/backend/app/adapters/spotify/session.py index 613933b..e9d12a0 100644 --- a/backend/app/adapters/spotify/session.py +++ b/backend/app/adapters/spotify/session.py @@ -17,6 +17,7 @@ class SpotifySession: tokens: TokenSet account_id: str display_name: str + refresh_generation: int = 0 refresh_lock: asyncio.Lock = field(default_factory=asyncio.Lock) @@ -51,7 +52,15 @@ class PendingLogins: def add(self, state: str, code_verifier: str) -> None: """Store a PKCE verifier for a newly issued OAuth state.""" - self._entries[state] = (code_verifier, time.monotonic()) + now = time.monotonic() + expired_states = ( + pending_state + for pending_state, (_, created_at) in self._entries.items() + if now - created_at >= PENDING_LOGIN_LIFETIME_SECONDS + ) + for expired_state in tuple(expired_states): + del self._entries[expired_state] + self._entries[state] = (code_verifier, now) def pop(self, state: str) -> str | None: """Consume a verifier unless its OAuth state is unknown or expired.""" diff --git a/backend/app/api/recommendations.py b/backend/app/api/recommendations.py index 4b36afb..218328c 100644 --- a/backend/app/api/recommendations.py +++ b/backend/app/api/recommendations.py @@ -8,7 +8,7 @@ import structlog from fastapi import APIRouter, HTTPException, Request from fastapi.responses import StreamingResponse -from app.adapters.spotify.errors import SpotifyError +from app.adapters.spotify.errors import SpotifyAuthenticationError, SpotifyError from app.adapters.spotify.session import SpotifySession from app.api.routes import resolve_session from app.api.schemas import ( @@ -69,7 +69,6 @@ async def recommendations( return StreamingResponse( _stream_lines( - request, pipeline, resolved.session_id, request_id, @@ -101,6 +100,9 @@ async def create_playlist( "Music discovery selected by the listener.", ) await writer.add_tracks_to_playlist(playlist.id, payload.track_uris) + except SpotifyAuthenticationError as error: + structlog.get_logger().warning("playlist_write_failed", error_type=type(error).__name__) + raise HTTPException(status_code=401, detail="Spotify authentication expired") from error except (SpotifyError, ValueError) as error: structlog.get_logger().warning("playlist_write_failed", error_type=type(error).__name__) raise HTTPException(status_code=502, detail="Spotify playlist creation failed") from error @@ -108,7 +110,6 @@ async def create_playlist( async def _stream_lines( - request: Request, pipeline: RecommendationPipeline, session_id: str, request_id: str, @@ -127,8 +128,6 @@ async def _stream_lines( ) try: async for event in event_stream: - if await request.is_disconnected(): - return yield f"{_to_wire_event(event).model_dump_json()}\n" except asyncio.CancelledError: raise @@ -137,12 +136,11 @@ async def _stream_lines( "recommendation_stream_failed", error_type=type(error).__name__, ) - if not await request.is_disconnected(): - failure = ErrorEvent( - code="recommendation_failed", - message="Recommendation could not be completed.", - ) - yield f"{failure.model_dump_json()}\n" + failure = ErrorEvent( + code="recommendation_failed", + message="Recommendation could not be completed.", + ) + yield f"{failure.model_dump_json()}\n" finally: await event_stream.aclose() diff --git a/backend/app/config.py b/backend/app/config.py index 7f02ee5..a560614 100644 --- a/backend/app/config.py +++ b/backend/app/config.py @@ -41,6 +41,8 @@ class Settings(BaseSettings): llm_model: str = "claude-sonnet-5" intent_effort: str = "low" rerank_effort: str = "medium" + # Bound provider calls independently from the grounding deadline. + llm_timeout_seconds: float = 120.0 # Ceilings include adaptive thinking tokens, which is why they sit far # above the size of the structured output itself. intent_max_tokens: int = 16384 diff --git a/backend/app/main.py b/backend/app/main.py index ee1ea42..b5cc8dc 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -5,6 +5,7 @@ from contextlib import asynccontextmanager from pathlib import Path import httpx2 +import structlog from anthropic import AsyncAnthropic from fastapi import FastAPI from fastapi.staticfiles import StaticFiles @@ -12,6 +13,7 @@ from fastapi.staticfiles import StaticFiles from app.adapters.anthropic.llm import AnthropicRecommender from app.adapters.spotify.auth import TokenSet, refresh_access_token from app.adapters.spotify.client import SpotifyClient +from app.adapters.spotify.errors import SpotifyError from app.adapters.spotify.session import PendingLogins, SessionStore, SpotifySession from app.api.recommendations import router as recommendations_router from app.api.routes import router @@ -44,7 +46,8 @@ def create_app( application.state.settings = active_settings application.state.seed_session_id = None anthropic_client = AsyncAnthropic( - api_key=active_settings.anthropic_api_key or "unused-demo-key" + api_key=active_settings.anthropic_api_key or "unused-demo-key", + timeout=active_settings.llm_timeout_seconds, ) application.state.anthropic = anthropic_client application.state.recommendation_pipeline = RecommendationPipeline( @@ -60,11 +63,17 @@ def create_app( active_settings.app_mode is AppMode.LIVE and active_settings.spotify_seed_refresh_token ): - application.state.seed_session_id = await _install_seed_session( - http, - application.state.session_store, - active_settings, - ) + try: + application.state.seed_session_id = await _install_seed_session( + http, + application.state.session_store, + active_settings, + ) + except (SpotifyError, ValueError) as error: + structlog.get_logger().warning( + "seed_session_install_failed", + error_type=type(error).__name__, + ) try: yield finally: diff --git a/backend/app/pipeline/grounding.py b/backend/app/pipeline/grounding.py index 7ecfba6..0ad7163 100644 --- a/backend/app/pipeline/grounding.py +++ b/backend/app/pipeline/grounding.py @@ -7,8 +7,10 @@ from collections.abc import Callable from dataclasses import dataclass from enum import StrEnum +import httpx2 import structlog +from app.adapters.spotify.errors import SpotifyError from app.config import Settings from app.domain.matching import candidate_key, judge_candidate_match, track_key from app.domain.models import Familiarity, Track, TrackCandidate @@ -22,6 +24,7 @@ class ResolutionStatus(StrEnum): RESOLVED = "resolved" MISS = "miss" MISMATCH = "mismatch" + FAILED = "failed" QUOTA = "quota" @@ -32,6 +35,7 @@ class GroundingMetrics: attempted_count: int miss_count: int mismatch_guard_count: int + failed_count: int cache_hit_count: int did_reach_deadline: bool did_exhaust_quota: bool @@ -111,6 +115,7 @@ class Grounder: settings.resolution_cache_ttl_seconds, settings.resolution_cache_max_entries, ) + self._semaphore = asyncio.Semaphore(settings.grounding_concurrency) async def ground( self, @@ -119,6 +124,7 @@ class Grounder: known_track_ids: frozenset[str], familiarity: Familiarity, pool_target: int, + deadline_at: float, ) -> GroundingResult: """Resolve candidates until the target, deadline, or quota boundary.""" accepted: dict[int, Track] = {} @@ -127,18 +133,18 @@ class Grounder: metrics = _MutableMetrics() pending: dict[asyncio.Task[_ResolutionAttempt], int] = {} next_index = 0 - deadline_at = time.monotonic() + self.settings.request_deadline_seconds - semaphore = asyncio.Semaphore(self.settings.grounding_concurrency) try: while next_index < len(candidates) or pending: if len(accepted) >= pool_target: break + if time.monotonic() >= deadline_at: + metrics.did_reach_deadline = True + break next_index = self._launch_tasks( catalog, candidates, pending, next_index, - semaphore, ) if not pending: break @@ -183,12 +189,9 @@ class Grounder: candidates: tuple[TrackCandidate, ...], pending: dict[asyncio.Task[_ResolutionAttempt], int], next_index: int, - semaphore: asyncio.Semaphore, ) -> int: while next_index < len(candidates) and len(pending) < self.settings.grounding_concurrency: - task = asyncio.create_task( - self._resolve(catalog, next_index, candidates[next_index], semaphore) - ) + task = asyncio.create_task(self._resolve(catalog, next_index, candidates[next_index])) pending[task] = next_index next_index += 1 return next_index @@ -228,9 +231,8 @@ class Grounder: catalog: MusicCatalog, index: int, candidate: TrackCandidate, - semaphore: asyncio.Semaphore, ) -> _ResolutionAttempt: - async with semaphore: + async with self._semaphore: return await self._resolve_with_slot(catalog, index, candidate) async def _resolve_with_slot( @@ -265,6 +267,15 @@ class Grounder: bare_results = [] except CatalogQuotaExhaustedError: return _ResolutionAttempt(index=index, status=ResolutionStatus.QUOTA) + except (SpotifyError, httpx2.HTTPError) as error: + structlog.get_logger().info( + "candidate_unresolved", + title=candidate.title, + artist=candidate.artist, + status=ResolutionStatus.FAILED, + error_type=type(error).__name__, + ) + return _ResolutionAttempt(index=index, status=ResolutionStatus.FAILED) if matched_track is not None: self.cache.put(key, matched_track) @@ -289,6 +300,7 @@ class _MutableMetrics: attempted_count: int = 0 miss_count: int = 0 mismatch_guard_count: int = 0 + failed_count: int = 0 cache_hit_count: int = 0 did_reach_deadline: bool = False did_exhaust_quota: bool = False @@ -297,6 +309,7 @@ class _MutableMetrics: self.attempted_count += 1 self.miss_count += attempt.status is ResolutionStatus.MISS self.mismatch_guard_count += attempt.status is ResolutionStatus.MISMATCH + self.failed_count += attempt.status is ResolutionStatus.FAILED self.cache_hit_count += attempt.is_cache_hit self.did_exhaust_quota = self.did_exhaust_quota or attempt.status is ResolutionStatus.QUOTA @@ -305,6 +318,7 @@ class _MutableMetrics: attempted_count=self.attempted_count, miss_count=self.miss_count, mismatch_guard_count=self.mismatch_guard_count, + failed_count=self.failed_count, cache_hit_count=self.cache_hit_count, did_reach_deadline=self.did_reach_deadline, did_exhaust_quota=self.did_exhaust_quota, @@ -340,6 +354,7 @@ def _log_grounding(result: GroundingResult) -> None: attempted_count=metrics.attempted_count, miss_rate=metrics.miss_rate, mismatch_guard_rate=metrics.mismatch_guard_rate, + failed_count=metrics.failed_count, cache_hits=metrics.cache_hit_count, deadline_reached=metrics.did_reach_deadline, quota_exhausted=metrics.did_exhaust_quota, diff --git a/backend/app/pipeline/orchestrator.py b/backend/app/pipeline/orchestrator.py index f9380b4..fc20eac 100644 --- a/backend/app/pipeline/orchestrator.py +++ b/backend/app/pipeline/orchestrator.py @@ -7,6 +7,7 @@ from contextlib import aclosing import structlog +from app.adapters.spotify.errors import SpotifyError from app.config import Settings from app.domain.models import ( CompressedTasteProfile, @@ -27,7 +28,12 @@ from app.pipeline.event import ( PipelineWarningEvent, ) from app.pipeline.grounding import Grounder -from app.ports.protocols import MusicCatalog, Recommender, RecommenderOutputError +from app.ports.protocols import ( + CatalogQuotaExhaustedError, + MusicCatalog, + Recommender, + RecommenderOutputError, +) RERANK_FALLBACK_CODE = "rerank_fallback" RERANK_FALLBACK_MESSAGE = "Ranking output was invalid, so grounded results are shown instead." @@ -115,21 +121,43 @@ class RecommendationPipeline: ) -> AsyncGenerator[PipelineEvent]: """Yield ordered events for one recommendation request.""" started_at = time.monotonic() - taste = await self.taste_cache.get(session_id, catalog) - intent = await self.recommender.create_intent( - query, - history, - previous_recommendations, - taste.text, - self.settings.candidate_count, - ) + deadline_at = started_at + self.settings.request_deadline_seconds + try: + taste = await self.taste_cache.get(session_id, catalog) + intent = await self.recommender.create_intent( + query, + history, + previous_recommendations, + taste.text, + self.settings.candidate_count, + ) + except RecommenderOutputError: + yield PipelineErrorEvent( + code="intent_failed", + message="Recommendation intent could not be generated from the model response.", + ) + return + except CatalogQuotaExhaustedError: + yield PipelineErrorEvent( + code="quota_exhausted", + message=( + "Spotify request quota was exhausted before recommendations could be prepared." + ), + ) + return + except SpotifyError: + yield PipelineErrorEvent( + code="spotify_unavailable", + message="Spotify was unavailable while preparing recommendations.", + ) + return yield PipelineMetadataEvent( request_id=request_id, intent_summary=intent.intent_summary, candidate_count=len(intent.candidates), ) - pool = await self._grounded_pool(session_id, catalog, intent, taste) + pool = await self._grounded_pool(session_id, catalog, intent, taste, deadline_at) if not pool: yield PipelineErrorEvent( code="no_grounded_results", @@ -160,6 +188,7 @@ class RecommendationPipeline: catalog: MusicCatalog, intent: Intent, taste: CompressedTasteProfile, + deadline_at: float, ) -> tuple[Track, ...]: """Reuse the session's pool on refinement, otherwise ground anew.""" if intent.is_refinement: @@ -172,6 +201,7 @@ class RecommendationPipeline: taste.known_track_ids, intent.familiarity, self.settings.rerank_count + self.settings.rerank_pool_buffer, + deadline_at, ) if result.tracks: self.last_pools[session_id] = result.tracks @@ -290,19 +320,31 @@ class _TasteProfileCache: return profile async def _fetch(self, catalog: MusicCatalog) -> CompressedTasteProfile: - short_artists, long_artists, short_tracks, long_tracks, saved_tracks = await asyncio.gather( - catalog.fetch_top_artists("short_term", self.settings.top_items_limit), - catalog.fetch_top_artists("long_term", self.settings.top_items_limit), - catalog.fetch_top_tracks("short_term", self.settings.top_items_limit), - catalog.fetch_top_tracks("long_term", self.settings.top_items_limit), - catalog.fetch_saved_tracks(self.settings.saved_tracks_limit), - ) + try: + async with asyncio.TaskGroup() as task_group: + short_artists_task = task_group.create_task( + catalog.fetch_top_artists("short_term", self.settings.top_items_limit) + ) + long_artists_task = task_group.create_task( + catalog.fetch_top_artists("long_term", self.settings.top_items_limit) + ) + short_tracks_task = task_group.create_task( + catalog.fetch_top_tracks("short_term", self.settings.top_items_limit) + ) + long_tracks_task = task_group.create_task( + catalog.fetch_top_tracks("long_term", self.settings.top_items_limit) + ) + saved_tracks_task = task_group.create_task( + catalog.fetch_saved_tracks(self.settings.saved_tracks_limit) + ) + except ExceptionGroup as errors: + raise errors.exceptions[0] from None return compress_taste_profile( TasteProfile( - short_term_artists=tuple(short_artists), - long_term_artists=tuple(long_artists), - short_term_tracks=tuple(short_tracks), - long_term_tracks=tuple(long_tracks), - saved_tracks=tuple(saved_tracks), + short_term_artists=tuple(short_artists_task.result()), + long_term_artists=tuple(long_artists_task.result()), + short_term_tracks=tuple(short_tracks_task.result()), + long_term_tracks=tuple(long_tracks_task.result()), + saved_tracks=tuple(saved_tracks_task.result()), ) ) diff --git a/backend/tests/test_anthropic_llm.py b/backend/tests/test_anthropic_llm.py new file mode 100644 index 0000000..27d3a61 --- /dev/null +++ b/backend/tests/test_anthropic_llm.py @@ -0,0 +1,13 @@ +"""Focused tests for Anthropic response parsing.""" + +import pytest + +from app.adapters.anthropic.llm import _RecommendationObjectParser +from app.ports.protocols import RecommenderOutputError + + +def test_parser_missing_object_start_raises_typed_output_error() -> None: + parser = _RecommendationObjectParser() + + with pytest.raises(RecommenderOutputError, match="object start position"): + parser._finish_object() diff --git a/backend/tests/test_auth_routes.py b/backend/tests/test_auth_routes.py index c1c067f..9484f37 100644 --- a/backend/tests/test_auth_routes.py +++ b/backend/tests/test_auth_routes.py @@ -113,6 +113,29 @@ def test_seed_session_authenticates_requests_without_a_cookie() -> None: assert response.json() == {"display_name": "Seed Listener"} +def test_seed_session_failure_keeps_application_serving() -> None: + async def spotify_handler(request: httpx2.Request) -> httpx2.Response: + return httpx2.Response(400) + + app = create_app( + application_settings=Settings( + app_mode=AppMode.LIVE, + spotify_client_id="client-id", + anthropic_api_key="test-key", + spotify_seed_refresh_token="seed-refresh", + ), + http_transport=httpx2.MockTransport(spotify_handler), + ) + with TestClient(app, follow_redirects=False) as client: + health_response = client.get("/api/health") + login_response = client.get("/api/auth/login") + + assert app.state.seed_session_id is None + + assert health_response.status_code == 200 + assert login_response.status_code == 307 + + def _live_settings() -> Settings: return Settings( app_mode=AppMode.LIVE, diff --git a/backend/tests/test_grounding.py b/backend/tests/test_grounding.py index e5b896e..757e7ea 100644 --- a/backend/tests/test_grounding.py +++ b/backend/tests/test_grounding.py @@ -1,8 +1,14 @@ """Deterministic tests for bounded Spotify grounding.""" import asyncio +import time from collections.abc import Awaitable, Callable +from app.adapters.spotify.errors import ( + SpotifyQuotaExhaustedError, + SpotifyRateLimitedError, + SpotifyUnavailableError, +) from app.config import Settings from app.domain.models import Familiarity, Track, TrackCandidate from app.pipeline.grounding import Grounder @@ -47,7 +53,14 @@ def test_early_stop_honors_pool_target() -> None: grounder = Grounder(_settings(grounding_concurrency=2)) candidates = tuple(TrackCandidate(f"track-{index}", "Artist") for index in range(6)) - result = await grounder.ground(catalog, candidates, frozenset(), Familiarity.MIX, 2) + result = await grounder.ground( + catalog, + candidates, + frozenset(), + Familiarity.MIX, + 2, + _deadline(), + ) assert len(result.tracks) == 2 assert len(catalog.search_queries) == 2 @@ -74,6 +87,7 @@ def test_miss_and_mismatch_are_counted_separately() -> None: frozenset(), Familiarity.MIX, 2, + _deadline(), ) assert result.metrics.miss_count == 1 @@ -92,9 +106,23 @@ def test_resolution_cache_hit_skips_catalog() -> None: grounder = Grounder(_settings()) candidates = (TrackCandidate("Cached Song", "Artist"),) - await grounder.ground(catalog, candidates, frozenset(), Familiarity.MIX, 1) + await grounder.ground( + catalog, + candidates, + frozenset(), + Familiarity.MIX, + 1, + _deadline(), + ) first_call_count = len(catalog.search_queries) - second = await grounder.ground(catalog, candidates, frozenset(), Familiarity.MIX, 1) + second = await grounder.ground( + catalog, + candidates, + frozenset(), + Familiarity.MIX, + 1, + _deadline(), + ) assert len(catalog.search_queries) == first_call_count assert second.metrics.cache_hit_count == 1 @@ -124,6 +152,7 @@ def test_deadline_returns_resolved_partial_pool() -> None: frozenset(), Familiarity.MIX, 2, + time.monotonic() + settings.request_deadline_seconds, ) assert [track.id for track in result.tracks] == ["fast"] @@ -132,6 +161,127 @@ def test_deadline_returns_resolved_partial_pool() -> None: asyncio.run(run()) +def test_spotify_failure_is_counted_and_remaining_candidates_continue() -> None: + async def run() -> None: + async def search(query: str) -> list[Track]: + if "Failing Song" in query: + raise SpotifyUnavailableError(503) + title = query.split('track:"', 1)[1].split('"', 1)[0] + return [_track(title.lower().replace(" ", "-"), title, "Artist")] + + catalog = FakeCatalog(search) + candidates = ( + TrackCandidate("Failing Song", "Artist"), + TrackCandidate("First Good Song", "Artist"), + TrackCandidate("Second Good Song", "Artist"), + ) + + result = await Grounder(_settings()).ground( + catalog, + candidates, + frozenset(), + Familiarity.MIX, + 2, + _deadline(), + ) + + assert [track.title for track in result.tracks] == [ + "First Good Song", + "Second Good Song", + ] + assert result.metrics.failed_count == 1 + assert result.metrics.attempted_count == 3 + assert not result.metrics.did_exhaust_quota + + asyncio.run(run()) + + +def test_plain_rate_limit_continues_but_quota_exhaustion_stops_fanout() -> None: + async def run() -> None: + async def plain_rate_limited_search(query: str) -> list[Track]: + if "Rate Limited" in query: + raise SpotifyRateLimitedError(6.0) + return [_track("found", "Found Song", "Artist")] + + plain_catalog = FakeCatalog(plain_rate_limited_search) + candidates = ( + TrackCandidate("Rate Limited", "Artist"), + TrackCandidate("Found Song", "Artist"), + ) + plain_result = await Grounder(_settings()).ground( + plain_catalog, + candidates, + frozenset(), + Familiarity.MIX, + 1, + _deadline(), + ) + + async def quota_search(query: str) -> list[Track]: + raise SpotifyQuotaExhaustedError(0.0, "QUOTA_EXCEEDED") + + quota_catalog = FakeCatalog(quota_search) + quota_result = await Grounder(_settings()).ground( + quota_catalog, + candidates, + frozenset(), + Familiarity.MIX, + 1, + _deadline(), + ) + + assert [track.id for track in plain_result.tracks] == ["found"] + assert plain_result.metrics.failed_count == 1 + assert not plain_result.metrics.did_exhaust_quota + assert quota_result.tracks == () + assert quota_result.metrics.did_exhaust_quota + assert len(quota_catalog.search_queries) == 1 + + asyncio.run(run()) + + +def test_grounding_concurrency_is_shared_across_requests() -> None: + async def run() -> None: + active_searches = 0 + maximum_active_searches = 0 + + async def search(query: str) -> list[Track]: + nonlocal active_searches, maximum_active_searches + active_searches += 1 + maximum_active_searches = max(maximum_active_searches, active_searches) + await asyncio.sleep(0.01) + active_searches -= 1 + title = query.split('track:"', 1)[1].split('"', 1)[0] + return [_track(title, title, "Artist")] + + catalog = FakeCatalog(search) + grounder = Grounder(_settings(grounding_concurrency=2)) + candidates = tuple(TrackCandidate(f"Song {index}", "Artist") for index in range(2)) + + await asyncio.gather( + grounder.ground( + catalog, + candidates, + frozenset(), + Familiarity.MIX, + 2, + _deadline(), + ), + grounder.ground( + catalog, + candidates, + frozenset(), + Familiarity.MIX, + 2, + _deadline(), + ), + ) + + assert maximum_active_searches == 2 + + asyncio.run(run()) + + def _settings(**overrides: object) -> Settings: values: dict[str, object] = { "grounding_concurrency": 1, @@ -141,6 +291,10 @@ def _settings(**overrides: object) -> Settings: return Settings.model_validate(values) +def _deadline() -> float: + return time.monotonic() + 1.0 + + def _track(track_id: str, title: str, artist: str) -> Track: return Track( id=track_id, diff --git a/backend/tests/test_health.py b/backend/tests/test_health.py index a876295..b4e9b61 100644 --- a/backend/tests/test_health.py +++ b/backend/tests/test_health.py @@ -1,7 +1,11 @@ """Smoke test for the application factory.""" +from unittest.mock import AsyncMock, Mock + +import pytest from fastapi.testclient import TestClient +from app.config import Settings from app.main import create_app @@ -10,3 +14,16 @@ def test_health_reports_mode() -> None: response = client.get("/api/health") assert response.status_code == 200 assert response.json()["mode"] in ("live", "demo") + + +def test_anthropic_client_uses_configured_timeout(monkeypatch: pytest.MonkeyPatch) -> None: + anthropic_client = Mock() + anthropic_client.close = AsyncMock() + constructor = Mock(return_value=anthropic_client) + monkeypatch.setattr("app.main.AsyncAnthropic", constructor) + + with TestClient(create_app(Settings(llm_timeout_seconds=42.0))) as client: + response = client.get("/api/health") + + assert response.status_code == 200 + constructor.assert_called_once_with(api_key="unused-demo-key", timeout=42.0) diff --git a/backend/tests/test_orchestrator.py b/backend/tests/test_orchestrator.py index 4f2fc6f..4dce350 100644 --- a/backend/tests/test_orchestrator.py +++ b/backend/tests/test_orchestrator.py @@ -3,6 +3,7 @@ import asyncio from collections.abc import AsyncGenerator +from app.adapters.spotify.errors import SpotifyQuotaExhaustedError, SpotifyUnavailableError from app.config import Settings from app.domain.models import ( ConversationTurn, @@ -13,7 +14,7 @@ from app.domain.models import ( Track, TrackCandidate, ) -from app.pipeline.event import PipelineEvent, PipelineTrackEvent +from app.pipeline.event import PipelineErrorEvent, PipelineEvent, PipelineTrackEvent from app.pipeline.orchestrator import RecommendationPipeline from app.ports.protocols import RecommenderOutputError, TimeRange @@ -61,11 +62,15 @@ class FakeRecommender: intents: list[Intent], selection_ids: tuple[str, ...] = (), failure_count: int = 0, + intent_error: Exception | None = None, + intent_delay_seconds: float = 0.0, ) -> None: """Store deterministic outputs for successive calls.""" self.intents = intents self.selection_ids = selection_ids self.failure_count = failure_count + self.intent_error = intent_error + self.intent_delay_seconds = intent_delay_seconds self.rerank_call_count = 0 async def create_intent( @@ -77,6 +82,9 @@ class FakeRecommender: candidate_count: int, ) -> Intent: """Return the next fixed intent.""" + await asyncio.sleep(self.intent_delay_seconds) + if self.intent_error is not None: + raise self.intent_error return self.intents.pop(0) async def stream_rerank( @@ -115,6 +123,108 @@ def test_event_order_and_rerank_ids_stay_inside_grounded_pool() -> None: asyncio.run(run()) +def test_intent_stage_failures_yield_one_typed_error_event() -> None: + async def run() -> None: + cases = ( + (RecommenderOutputError("invalid intent"), "intent_failed"), + ( + SpotifyQuotaExhaustedError(0.0, "QUOTA_EXCEEDED"), + "quota_exhausted", + ), + (SpotifyUnavailableError(503), "spotify_unavailable"), + ) + for error, expected_code in cases: + catalog = FakeCatalog(()) + recommender = FakeRecommender([], intent_error=error) + + events = await _run_pipeline(catalog, recommender) + + assert len(events) == 1 + assert events[0].type == "error" + assert events[0].code == expected_code + + asyncio.run(run()) + + +def test_taste_failure_cancels_sibling_fetches() -> None: + class FailingTasteCatalog(FakeCatalog): + """Fail one taste request after all sibling requests have started.""" + + def __init__(self) -> None: + super().__init__(()) + self.started_count = 0 + self.cancelled_count = 0 + self.all_started = asyncio.Event() + self.never_finishes = asyncio.Event() + + async def fetch_top_artists(self, time_range: TimeRange, limit: int) -> list[str]: + await self._wait_for_all_fetches() + await self._wait_until_cancelled() + return [] + + async def fetch_top_tracks(self, time_range: TimeRange, limit: int) -> list[Track]: + await self._wait_for_all_fetches() + await self._wait_until_cancelled() + return [] + + async def fetch_saved_tracks(self, limit: int) -> list[Track]: + await self._wait_for_all_fetches() + raise SpotifyUnavailableError(503) + + async def _wait_for_all_fetches(self) -> None: + self.started_count += 1 + if self.started_count == 5: + self.all_started.set() + await self.all_started.wait() + + async def _wait_until_cancelled(self) -> None: + try: + await self.never_finishes.wait() + except asyncio.CancelledError: + self.cancelled_count += 1 + raise + + async def run() -> None: + catalog = FailingTasteCatalog() + events = await _run_pipeline(catalog, FakeRecommender([])) + + assert len(events) == 1 + assert events[0].type == "error" + assert events[0].code == "spotify_unavailable" + assert catalog.cancelled_count == 4 + + asyncio.run(run()) + + +def test_grounding_deadline_starts_before_intent_generation() -> None: + async def run() -> None: + track = _track("found", "Found Song") + catalog = FakeCatalog((track,)) + recommender = FakeRecommender( + [_intent(track)], + intent_delay_seconds=0.02, + ) + pipeline = RecommendationPipeline( + recommender, + Settings( + rerank_count=1, + rerank_pool_buffer=0, + grounding_floor=1, + grounding_concurrency=1, + request_deadline_seconds=0.01, + ), + ) + + events = await _collect(pipeline, catalog, "query") + + assert [event.type for event in events] == ["metadata", "error"] + assert isinstance(events[-1], PipelineErrorEvent) + assert events[-1].code == "no_grounded_results" + assert catalog.search_call_count == 0 + + asyncio.run(run()) + + def test_rerank_fallback_warns_then_streams_grounded_order() -> None: async def run() -> None: first = _track("first", "First Song") diff --git a/backend/tests/test_recommendation_api.py b/backend/tests/test_recommendation_api.py index f5e83ce..1920454 100644 --- a/backend/tests/test_recommendation_api.py +++ b/backend/tests/test_recommendation_api.py @@ -3,10 +3,12 @@ import time from collections.abc import AsyncGenerator +import pytest from fastapi.testclient import TestClient from pydantic import TypeAdapter from app.adapters.spotify.auth import TokenSet +from app.adapters.spotify.errors import SpotifyAuthenticationError from app.adapters.spotify.session import SessionStore, SpotifySession from app.api.routes import SESSION_COOKIE_NAME from app.api.schemas import StreamEvent @@ -37,13 +39,16 @@ class FakePipeline: class FakePlaylistWriter: """Capture playlist writes without external calls.""" - def __init__(self) -> None: + def __init__(self, error: Exception | None = None) -> None: """Create an empty write trace.""" + self.error = error self.name: str | None = None self.track_uris: list[str] = [] async def create_playlist(self, name: str, description: str) -> CreatedPlaylist: """Record the prefixed name and return a stable playlist.""" + if self.error is not None: + raise self.error self.name = name return CreatedPlaylist("playlist", "https://open.spotify.com/playlist/playlist") @@ -52,7 +57,13 @@ class FakePlaylistWriter: self.track_uris = track_uris -def test_recommendations_stream_lines_validate_against_frozen_schemas() -> None: +def test_recommendations_stream_lines_validate_against_frozen_schemas( + monkeypatch: pytest.MonkeyPatch, +) -> None: + async def fail_if_polled(request: object) -> bool: + raise AssertionError("Request disconnect state must not be polled") + + monkeypatch.setattr("starlette.requests.Request.is_disconnected", fail_if_polled) app = create_app() with TestClient(app) as client: _authenticate(client, session_store=app.state.session_store) @@ -103,6 +114,26 @@ def test_playlist_endpoint_prefixes_name_and_adds_tracks() -> None: assert writer.track_uris == ["spotify:track:track"] +def test_playlist_authentication_failure_signals_relogin() -> None: + app = create_app() + writer = FakePlaylistWriter(SpotifyAuthenticationError("expired")) + with TestClient(app) as client: + _authenticate(client, session_store=app.state.session_store) + app.state.spotify_client_factory = lambda session: writer + + response = client.post( + "/api/playlists", + json={ + "schema_version": 1, + "name": "Night drive", + "track_uris": ["spotify:track:track"], + }, + ) + + assert response.status_code == 401 + assert response.json() == {"detail": "Spotify authentication expired"} + + def _authenticate(client: TestClient, session_store: SessionStore) -> None: session_id = session_store.create( SpotifySession( diff --git a/backend/tests/test_spotify_auth.py b/backend/tests/test_spotify_auth.py index c9f0565..8a9a360 100644 --- a/backend/tests/test_spotify_auth.py +++ b/backend/tests/test_spotify_auth.py @@ -6,12 +6,14 @@ import hashlib import time import httpx2 +import pytest from app.adapters.spotify.auth import ( TokenSet, derive_code_challenge, refresh_access_token, ) +from app.adapters.spotify.session import PendingLogins def test_code_challenge_is_unpadded_base64url_sha256() -> None: @@ -43,3 +45,18 @@ def test_refresh_keeps_existing_refresh_token_when_omitted() -> None: def test_token_expiry_uses_sixty_second_skew() -> None: assert TokenSet("access", "refresh", time.monotonic() + 59).is_expired assert not TokenSet("access", "refresh", time.monotonic() + 61).is_expired + + +def test_pending_login_add_sweeps_expired_entries(monkeypatch: pytest.MonkeyPatch) -> None: + current_time = 0.0 + monkeypatch.setattr( + "app.adapters.spotify.session.time.monotonic", + lambda: current_time, + ) + pending_logins = PendingLogins() + pending_logins.add("expired", "old-verifier") + + current_time = 601.0 + pending_logins.add("current", "new-verifier") + + assert set(pending_logins._entries) == {"current"} diff --git a/backend/tests/test_spotify_client.py b/backend/tests/test_spotify_client.py index 4840673..0d54ada 100644 --- a/backend/tests/test_spotify_client.py +++ b/backend/tests/test_spotify_client.py @@ -9,10 +9,16 @@ import pytest from app.adapters.spotify.auth import TokenSet from app.adapters.spotify.client import SpotifyClient -from app.adapters.spotify.errors import SpotifyRateLimitedError, SpotifyRequestError +from app.adapters.spotify.errors import ( + SpotifyQuotaExhaustedError, + SpotifyRateLimitedError, + SpotifyRequestError, + SpotifyUnavailableError, +) from app.adapters.spotify.session import SpotifySession from app.config import Settings from app.domain.models import Track +from app.ports.protocols import CatalogQuotaExhaustedError TransportHandler = Callable[[httpx2.Request], Coroutine[None, None, httpx2.Response]] @@ -44,19 +50,19 @@ def test_unauthorized_response_refreshes_once_and_returns_result() -> None: def test_concurrent_unauthorized_responses_share_one_refresh() -> None: async def run() -> None: token_calls = 0 - old_api_calls = 0 - both_old_requests_arrived = asyncio.Event() + api_calls = 0 + both_initial_requests_arrived = asyncio.Event() async def handler(request: httpx2.Request) -> httpx2.Response: - nonlocal old_api_calls, token_calls + nonlocal api_calls, token_calls if request.url.host == "accounts.spotify.com": token_calls += 1 - return _token_response() - if request.headers["Authorization"] == "Bearer old-access": - old_api_calls += 1 - if old_api_calls == 2: - both_old_requests_arrived.set() - await asyncio.wait_for(both_old_requests_arrived.wait(), timeout=1) + return _token_response("old-access") + api_calls += 1 + if api_calls <= 2: + if api_calls == 2: + both_initial_requests_arrived.set() + await asyncio.wait_for(both_initial_requests_arrived.wait(), timeout=1) return httpx2.Response(401) return httpx2.Response(200, json=_search_payload()) @@ -69,6 +75,7 @@ def test_concurrent_unauthorized_responses_share_one_refresh() -> None: assert first == second assert token_calls == 1 + assert client.session.refresh_generation == 1 asyncio.run(run()) @@ -105,6 +112,7 @@ def test_get_rate_limit_above_cap_raises_without_retry() -> None: await _search_with_handler(handler) assert error.value.retry_after_seconds == 6 + assert not isinstance(error.value, CatalogQuotaExhaustedError) assert api_calls == 1 asyncio.run(run()) @@ -136,10 +144,11 @@ def test_quota_exhaustion_raises_without_retry_or_sleep( ) monkeypatch.setattr("app.adapters.spotify.client.asyncio.sleep", fake_sleep) - with pytest.raises(SpotifyRateLimitedError) as error: + with pytest.raises(SpotifyQuotaExhaustedError) as error: await _search_with_handler(handler) assert error.value.reason == "QUOTA_EXCEEDED" + assert isinstance(error.value, CatalogQuotaExhaustedError) assert api_calls == 1 assert sleep_calls == 0 @@ -172,6 +181,46 @@ def test_authentication_then_rate_limit_retries_each_policy_once() -> None: asyncio.run(run()) +def test_rate_limit_retry_landing_on_unauthorized_refreshes_once() -> None: + async def run() -> None: + token_calls = 0 + api_calls = 0 + + async def handler(request: httpx2.Request) -> httpx2.Response: + nonlocal api_calls, token_calls + if request.url.host == "accounts.spotify.com": + token_calls += 1 + return _token_response() + api_calls += 1 + if api_calls == 1: + return httpx2.Response(429, headers={"Retry-After": "0"}) + if api_calls == 2: + return httpx2.Response(401) + return httpx2.Response(200, json=_search_payload()) + + tracks = await _search_with_handler(handler) + + assert len(tracks) == 1 + assert token_calls == 1 + assert api_calls == 3 + + asyncio.run(run()) + + +def test_transport_error_becomes_spotify_unavailable() -> None: + async def run() -> None: + async def handler(request: httpx2.Request) -> httpx2.Response: + raise httpx2.ConnectError("connection failed", request=request) + + with pytest.raises(SpotifyUnavailableError) as error: + await _search_with_handler(handler) + + assert error.value.status_code == 504 + assert str(error.value) == "Spotify request failed" + + asyncio.run(run()) + + def test_request_error_includes_parsed_spotify_message() -> None: async def run() -> None: async def handler(request: httpx2.Request) -> httpx2.Response: @@ -267,8 +316,8 @@ def _client(http: httpx2.AsyncClient) -> SpotifyClient: return SpotifyClient(http, session, Settings(spotify_client_id="client")) -def _token_response() -> httpx2.Response: - return httpx2.Response(200, json={"access_token": "new-access", "expires_in": 3600}) +def _token_response(access_token: str = "new-access") -> httpx2.Response: + return httpx2.Response(200, json={"access_token": access_token, "expires_in": 3600}) def _search_payload() -> dict[str, object]: diff --git a/docs/logboek.md b/docs/logboek.md index e0782b2..96858ea 100644 --- a/docs/logboek.md +++ b/docs/logboek.md @@ -318,3 +318,29 @@ Waarom: Wat ik heb laten vallen of uitgesteld: - Verdere styling; de tijd gaat naar eval, demo mode en de README. + +### Backend hardening + +Wat ik deed: + +- Een hardening pass over de backend randgevallen, deels gevonden via een + adversarial review: fouten per candidate ingedamd zodat 1 kapotte + candidate nooit de hele request breekt, quota exhaustion apart herkend + van gewone 429's, token refresh single-flight per sessie-generatie, + typed errors voor de intent stap, en de seed-sessie kan de boot niet + meer laten crashen. +- De request deadline start nu bij binnenkomst van de request en dekt + alles tot en met grounding. De gestreamde rerank heeft bewust een eigen + timeout: een totaalbudget zou een gezonde stream halverwege afkappen. +- Concurrency op de grounding fan-out is nu process-wide begrensd in + plaats van per request. + +Waarom: + +- Dit zijn precies de randgevallen die je in een demo niet wilt zien; ze + nu dichtzetten is goedkoper dan er straks 1 in een review tegenkomen. + +Wat ik heb laten vallen of uitgesteld: + +- Een totaalbudget over de hele request heen; de afweging staat hierboven + en komt ook in de README. From 3dc1af5f0c3463e6ccfdca2eba0d9773b430c20c Mon Sep 17 00:00:00 2001 From: Justin Visser Date: Mon, 10 Aug 2026 21:56:05 +0200 Subject: [PATCH 3/7] fix(prompt): favor verifiable adjacent discoveries --- backend/app/prompts.py | 26 +++++++++++++++++--------- docs/logboek.md | 26 ++++++++++++++++++++++++++ 2 files changed, 43 insertions(+), 9 deletions(-) diff --git a/backend/app/prompts.py b/backend/app/prompts.py index 62440c3..ab112bf 100644 --- a/backend/app/prompts.py +++ b/backend/app/prompts.py @@ -49,15 +49,23 @@ appears prominently in the taste profile. Avoid duplicate titles by the same art avoid multiple editions of the same recording. Use a range of strong fits so a later ranking step has meaningful choices rather than thirty near-identical songs. -When familiarity leans new, propose music the listener plausibly does not know. Move beyond -the named top artists and tracks while retaining understandable bridges through genre, -scene, production style, instrumentation, energy, era, or songwriting. Do not simply select -deep cuts from every familiar artist. Prefer adjacent artists, overlooked catalogs, -regional scenes, and credible cross-genre connections. The profile is not exhaustive, so -never claim that a candidate is definitely unknown. When familiarity is familiar, -candidates may include supplied top or saved tracks, but remain responsive to the current -request. When familiarity is mix, combine recognizable anchors with adjacent discoveries -rather than splitting into unrelated halves. +When familiarity leans new, novelty means plausibly new to this listener, not obscure. +Known tracks are excluded after grounding, so novelty relative to the taste profile is +enforced downstream; do not chase rarity. Name each artist's signature track, biggest +single, or a similarly famous recording from their catalog: a title you have seen written +down many times, spelled exactly as released. Never guess a title that merely sounds like +the artist; if no specific famous title comes to mind for an artist, pick a different +artist whose hit you can name with certainty. Famous artists adjacent to the taste profile +are welcome; their best-known work is still new to a listener who does not play them. +Prefer the anthems of the profile's own scenes and neighboring scenes over global chart +hits: the certainty bar stays the same, but a scene's signature tracks fit the taste far +better than whatever topped the general charts. +Retain understandable bridges through genre, scene, production style, instrumentation, +energy, era, or songwriting. The profile is not exhaustive, so never claim that a +candidate is definitely unknown. When familiarity is +familiar, candidates may include supplied top or saved tracks, but remain responsive to the +current request. When familiarity is mix, combine recognizable anchors with real, +confidently identifiable adjacent discoveries rather than splitting into unrelated halves. Use musical knowledge conservatively. Base selection on durable, commonly knowable attributes of recordings. Do not invent listening statistics, personal memories, release diff --git a/docs/logboek.md b/docs/logboek.md index 96858ea..ce9f358 100644 --- a/docs/logboek.md +++ b/docs/logboek.md @@ -344,3 +344,29 @@ Wat ik heb laten vallen of uitgesteld: - Een totaalbudget over de hele request heen; de afweging staat hierboven en komt ook in de README. + +### Discover-new gefixt in de intent prompt + +Wat ik deed: + +- Het discover-new scenario faalde live steeds op de grounding: call 1 + verzon voor echte, goed gekozen artiesten generieke titels die niet + bestaan ("Vibes", "Drift", "Shine"), en de matcher liet terecht niets + door. Niet de matcher aangepast maar de prompt: bij familiarity=new + alleen signature tracks en scene-anthems noemen die het model met + zekerheid kan spellen; nieuw-voor-de-luisteraar wordt toch al + afgedwongen door de exact-ID exclusion na grounding. +- Live gevalideerd: het scenario levert nu 15 tracks van 16 artiesten. + Van de 32 kandidaten vielen er 12 als verzinsel af en resolvede de + rest; drop-over-substitute deed precies wat het moet doen. + +Waarom: + +- Titel-recall van een LLM stort in zodra je bewust om onbekend werk + vraagt; om obscuriteit vragen is dan het verkeerde gereedschap. Nieuw + en obscuur zijn geen synoniemen. + +Wat ik heb laten vallen of uitgesteld: + +- Een repair loop die gefaalde kandidaten opnieuw aan het model + voorlegt; blijft staan als potentiele vervolgstap. From 0664cc2d27be2ab4a95fee7e40150fb016f22275 Mon Sep 17 00:00:00 2001 From: Justin Visser Date: Mon, 10 Aug 2026 22:21:04 +0200 Subject: [PATCH 4/7] test: add scenario eval runner, recorded fixtures, and baseline comparison --- .github/workflows/ci.yml | 6 +- .gitignore | 5 + backend/app/main.py | 3 + backend/pyproject.toml | 6 +- backend/tests/test_health.py | 2 +- backend/uv.lock | 15 + docs/logboek.md | 26 + eval/baseline.py | 114 +++ .../fixtures/dinner-background/anthropic.json | 65 ++ eval/fixtures/dinner-background/spotify.json | 442 +++++++++ eval/fixtures/discover-new/anthropic.json | 72 ++ eval/fixtures/discover-new/spotify.json | 616 ++++++++++++ eval/fixtures/dutch-chill/anthropic.json | 55 ++ eval/fixtures/dutch-chill/spotify.json | 894 ++++++++++++++++++ .../focus-coding-refine/anthropic.json | 127 +++ .../fixtures/focus-coding-refine/spotify.json | 413 ++++++++ eval/fixtures/focus-coding/anthropic.json | 65 ++ eval/fixtures/focus-coding/spotify.json | 795 ++++++++++++++++ .../nineties-nostalgia/anthropic.json | 66 ++ eval/fixtures/nineties-nostalgia/spotify.json | 439 +++++++++ eval/fixtures/rainy-sunday/anthropic.json | 66 ++ eval/fixtures/rainy-sunday/spotify.json | 408 ++++++++ eval/fixtures/workout-energy/anthropic.json | 64 ++ eval/fixtures/workout-energy/spotify.json | 773 +++++++++++++++ eval/live.py | 284 ++++++ eval/record_fixtures.py | 142 +++ eval/recording/__init__.py | 14 + eval/recording/model.py | 30 + eval/recording/redaction.py | 219 +++++ eval/recording/storage.py | 32 + eval/recording/synthetic_taste.json | 95 ++ eval/recording/transport.py | 154 +++ eval/run_eval.py | 98 ++ eval/scenario.py | 79 ++ eval/scenarios.yaml | 49 + eval/tests/test_live.py | 78 ++ eval/tests/test_recording.py | 134 +++ eval/wire.py | 46 + 38 files changed, 6986 insertions(+), 5 deletions(-) create mode 100644 eval/baseline.py create mode 100644 eval/fixtures/dinner-background/anthropic.json create mode 100644 eval/fixtures/dinner-background/spotify.json create mode 100644 eval/fixtures/discover-new/anthropic.json create mode 100644 eval/fixtures/discover-new/spotify.json create mode 100644 eval/fixtures/dutch-chill/anthropic.json create mode 100644 eval/fixtures/dutch-chill/spotify.json create mode 100644 eval/fixtures/focus-coding-refine/anthropic.json create mode 100644 eval/fixtures/focus-coding-refine/spotify.json create mode 100644 eval/fixtures/focus-coding/anthropic.json create mode 100644 eval/fixtures/focus-coding/spotify.json create mode 100644 eval/fixtures/nineties-nostalgia/anthropic.json create mode 100644 eval/fixtures/nineties-nostalgia/spotify.json create mode 100644 eval/fixtures/rainy-sunday/anthropic.json create mode 100644 eval/fixtures/rainy-sunday/spotify.json create mode 100644 eval/fixtures/workout-energy/anthropic.json create mode 100644 eval/fixtures/workout-energy/spotify.json create mode 100644 eval/live.py create mode 100644 eval/record_fixtures.py create mode 100644 eval/recording/__init__.py create mode 100644 eval/recording/model.py create mode 100644 eval/recording/redaction.py create mode 100644 eval/recording/storage.py create mode 100644 eval/recording/synthetic_taste.json create mode 100644 eval/recording/transport.py create mode 100644 eval/run_eval.py create mode 100644 eval/scenario.py create mode 100644 eval/scenarios.yaml create mode 100644 eval/tests/test_live.py create mode 100644 eval/tests/test_recording.py create mode 100644 eval/wire.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 020d3fb..97b44a1 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -15,9 +15,9 @@ jobs: - uses: actions/checkout@v4 - uses: astral-sh/setup-uv@v5 - run: uv sync --frozen - - run: uv run ruff check . - - run: uv run ruff format --check . - - run: uv run mypy app + - run: uv run ruff check . ../eval + - run: uv run ruff format --check . ../eval + - run: uv run mypy app tests ../eval - run: uv run pytest frontend: diff --git a/.gitignore b/.gitignore index 94b8263..c49b927 100644 --- a/.gitignore +++ b/.gitignore @@ -18,3 +18,8 @@ frontend/dist/ # eval: raw (unredacted) recordings never enter the repo eval/fixtures/raw/ +eval/reports/ + +# eval outputs (reports, baseline snapshots) are generated, never shipped +eval/reports/ +eval/snapshots/ diff --git a/backend/app/main.py b/backend/app/main.py index b5cc8dc..4b1a37c 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -4,6 +4,7 @@ from collections.abc import AsyncIterator from contextlib import asynccontextmanager from pathlib import Path +import httpx import httpx2 import structlog from anthropic import AsyncAnthropic @@ -28,6 +29,7 @@ FRONTEND_DIST = Path(__file__).parent / "static" def create_app( application_settings: Settings | None = None, http_transport: httpx2.AsyncBaseTransport | None = None, + anthropic_http_client: httpx.AsyncClient | None = None, ) -> FastAPI: """Build the FastAPI app: API routes plus the built SPA on one port.""" active_settings = application_settings or settings @@ -48,6 +50,7 @@ def create_app( anthropic_client = AsyncAnthropic( api_key=active_settings.anthropic_api_key or "unused-demo-key", timeout=active_settings.llm_timeout_seconds, + http_client=anthropic_http_client, ) application.state.anthropic = anthropic_client application.state.recommendation_pipeline = RecommendationPipeline( diff --git a/backend/pyproject.toml b/backend/pyproject.toml index 7e25a69..723caa3 100644 --- a/backend/pyproject.toml +++ b/backend/pyproject.toml @@ -6,8 +6,10 @@ requires-python = "==3.13.*" dependencies = [ "anthropic==0.121.0", "fastapi>=0.116", + "httpx>=0.28", "httpx2>=2.10", "pydantic-settings>=2.10", + "pyyaml>=6.0", "structlog>=25.4", "uvicorn[standard]>=0.35", ] @@ -17,6 +19,7 @@ dev = [ "mypy>=1.17", "pytest>=8.4", "ruff>=0.12", + "types-pyyaml>=6.0", ] [tool.ruff] @@ -36,4 +39,5 @@ module = ["app.domain.*", "app.ports.*", "app.pipeline.*"] strict = true [tool.pytest.ini_options] -testpaths = ["tests"] +pythonpath = [".", "../eval"] +testpaths = ["tests", "../eval/tests"] diff --git a/backend/tests/test_health.py b/backend/tests/test_health.py index b4e9b61..441bdc1 100644 --- a/backend/tests/test_health.py +++ b/backend/tests/test_health.py @@ -26,4 +26,4 @@ def test_anthropic_client_uses_configured_timeout(monkeypatch: pytest.MonkeyPatc response = client.get("/api/health") assert response.status_code == 200 - constructor.assert_called_once_with(api_key="unused-demo-key", timeout=42.0) + constructor.assert_called_once_with(api_key="unused-demo-key", timeout=42.0, http_client=None) diff --git a/backend/uv.lock b/backend/uv.lock index e466a75..6681f12 100644 --- a/backend/uv.lock +++ b/backend/uv.lock @@ -132,8 +132,10 @@ source = { virtual = "." } dependencies = [ { name = "anthropic" }, { name = "fastapi" }, + { name = "httpx" }, { name = "httpx2" }, { name = "pydantic-settings" }, + { name = "pyyaml" }, { name = "structlog" }, { name = "uvicorn", extra = ["standard"] }, ] @@ -143,14 +145,17 @@ dev = [ { name = "mypy" }, { name = "pytest" }, { name = "ruff" }, + { name = "types-pyyaml" }, ] [package.metadata] requires-dist = [ { name = "anthropic", specifier = "==0.121.0" }, { name = "fastapi", specifier = ">=0.116" }, + { name = "httpx", specifier = ">=0.28" }, { name = "httpx2", specifier = ">=2.10" }, { name = "pydantic-settings", specifier = ">=2.10" }, + { name = "pyyaml", specifier = ">=6.0" }, { name = "structlog", specifier = ">=25.4" }, { name = "uvicorn", extras = ["standard"], specifier = ">=0.35" }, ] @@ -160,6 +165,7 @@ dev = [ { name = "mypy", specifier = ">=1.17" }, { name = "pytest", specifier = ">=8.4" }, { name = "ruff", specifier = ">=0.12" }, + { name = "types-pyyaml", specifier = ">=6.0" }, ] [[package]] @@ -580,6 +586,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/19/97/56608b2249fe206a67cd573bc93cd9896e1efb9e98bce9c163bcdc704b88/truststore-0.10.4-py3-none-any.whl", hash = "sha256:adaeaecf1cbb5f4de3b1959b42d41f6fab57b2b1666adb59e89cb0b53361d981", size = 18660, upload-time = "2025-08-12T18:49:01.46Z" }, ] +[[package]] +name = "types-pyyaml" +version = "6.0.12.20260724" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3f/6f/a28f44bcd56bebed42b028a2894c79853e2f5e6b5279e633cb3f287a05e7/types_pyyaml-6.0.12.20260724.tar.gz", hash = "sha256:3c1ce1bb73cd5ec02e90390c2b1f00e810d241d8825fd73ff359696839271b6b", size = 17893, upload-time = "2026-07-24T04:58:43.453Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/42/0337fefc615e20ee55d1c8f71b774a9b2b734a04669139c20753b27a2a3a/types_pyyaml-6.0.12.20260724-py3-none-any.whl", hash = "sha256:d57db930a4b2efbc57cf430ec8882765d246929432fa253092f383902329a453", size = 20312, upload-time = "2026-07-24T04:58:42.486Z" }, +] + [[package]] name = "typing-extensions" version = "4.16.0" diff --git a/docs/logboek.md b/docs/logboek.md index ce9f358..d70a432 100644 --- a/docs/logboek.md +++ b/docs/logboek.md @@ -370,3 +370,29 @@ Wat ik heb laten vallen of uitgesteld: - Een repair loop die gefaalde kandidaten opnieuw aan het model voorlegt; blijft staan als potentiele vervolgstap. + +### Evaluatie en fixtures + +Wat ik deed: + +- Een eval-script dat de app de 8 standaardvragen stelt en de antwoorden + controleert: komen de events in de juiste volgorde, zijn alle tracks + uniek, heeft elke track een reden, kwam de eerste kaart binnen het + tijdsbudget, en gaat het antwoord echt over wat er gevraagd werd. +- Dezelfde 8 vragen ook aan de kale Spotify search gesteld; de + vergelijking tussen die twee wordt de tabel in de README. +- Elk scenario 1 keer opgenomen tegen de echte API's en opgeslagen als + cassettes; demo mode speelt die af, dus de app werkt straks ook zonder + keys. Persoonlijke data gaat er bij het opnemen uit (nepprofiel, geen + tokens); de ruwe opnames blijven buiten git. +- Dit draait ook in CI, zonder keys. + +Waarom: + +- De claim dat de LLM-laag iets toevoegt moet meetbaar zijn, niet + beweerd. En de reviewer moet de app kunnen starten zonder eigen keys. + +Wat ik heb laten vallen of uitgesteld: + +- Byte-snapshots per pipeline-stap; de checks hierboven en de cassettes + zijn nu het bewijs. diff --git a/eval/baseline.py b/eval/baseline.py new file mode 100644 index 0000000..c46e3e5 --- /dev/null +++ b/eval/baseline.py @@ -0,0 +1,114 @@ +"""Record bare Spotify search results and render side-by-side comparisons.""" + +import json +from pathlib import Path + +import httpx +from scenario import Scenario + +TOKEN_URL = "https://accounts.spotify.com/api/token" +SEARCH_URL = "https://api.spotify.com/v1/search" + + +async def record_baselines( + scenarios: tuple[Scenario, ...], + client_id: str, + client_secret: str, + snapshot_root: Path, +) -> None: + """Snapshot the top ten results from bare searches for every query.""" + snapshot_root.mkdir(parents=True, exist_ok=True) + async with httpx.AsyncClient(timeout=20.0) as client: + token_response = await client.post( + TOKEN_URL, + data={"grant_type": "client_credentials"}, + auth=(client_id, client_secret), + ) + token_response.raise_for_status() + access_token = token_response.json()["access_token"] + for scenario in scenarios: + response = await client.get( + SEARCH_URL, + params={"q": scenario.query, "type": "track", "limit": 10}, + headers={"Authorization": f"Bearer {access_token}"}, + ) + response.raise_for_status() + tracks = response.json().get("tracks", {}).get("items", [])[:10] + _write_json( + snapshot_root / f"{scenario.key}.json", + {"key": scenario.key, "query": scenario.query, "tracks": tracks}, + ) + + +def write_comparison( + scenarios: tuple[Scenario, ...], + snapshot_root: Path, + report_root: Path, + top_n: int, +) -> Path: + """Write a markdown comparison for scenarios with both result arms.""" + report_root.mkdir(parents=True, exist_ok=True) + lines = ["# Pipeline and bare search comparison", ""] + compared = 0 + for scenario in scenarios: + baseline_path = snapshot_root / f"{scenario.key}.json" + pipeline_path = report_root / f"{scenario.key}.json" + if not baseline_path.exists() or not pipeline_path.exists(): + continue + baseline = json.loads(baseline_path.read_text(encoding="ascii")) + pipeline = json.loads(pipeline_path.read_text(encoding="ascii")) + lines.extend(_comparison_section(scenario, pipeline, baseline, top_n)) + compared += 1 + if compared == 0: + lines.extend(["No scenario has results from both arms yet.", ""]) + output_path = report_root / "baseline-comparison.md" + output_path.write_text("\n".join(lines), encoding="utf-8") + return output_path + + +def _comparison_section( + scenario: Scenario, + pipeline: object, + baseline: object, + top_n: int, +) -> list[str]: + pipeline_tracks = pipeline.get("tracks", []) if isinstance(pipeline, dict) else [] + baseline_tracks = baseline.get("tracks", []) if isinstance(baseline, dict) else [] + lines = [f"## {scenario.chip}", "", "| Rank | Pipeline | Bare search |", "| ---: | --- | --- |"] + for index in range(top_n): + pipeline_label = _pipeline_label(pipeline_tracks, index) + baseline_label = _spotify_label(baseline_tracks, index) + lines.append(f"| {index + 1} | {pipeline_label} | {baseline_label} |") + lines.append("") + return lines + + +def _pipeline_label(tracks: object, index: int) -> str: + if not isinstance(tracks, list) or index >= len(tracks): + return "" + event = tracks[index] + track = event.get("track") if isinstance(event, dict) else None + return _track_label(track, "title") + + +def _spotify_label(tracks: object, index: int) -> str: + if not isinstance(tracks, list) or index >= len(tracks): + return "" + return _track_label(tracks[index], "name") + + +def _track_label(track: object, title_key: str) -> str: + if not isinstance(track, dict): + return "" + artists = track.get("artists", []) + names = [ + artist.get("name", "") if isinstance(artist, dict) else str(artist) for artist in artists + ] + return f"{track.get(title_key, '')} by {', '.join(names)}" + + +def _write_json(path: Path, payload: object) -> None: + path.write_text( + json.dumps(payload, ensure_ascii=True, indent=2, sort_keys=True) + "\n", + encoding="ascii", + ) diff --git a/eval/fixtures/dinner-background/anthropic.json b/eval/fixtures/dinner-background/anthropic.json new file mode 100644 index 0000000..e8e618c --- /dev/null +++ b/eval/fixtures/dinner-background/anthropic.json @@ -0,0 +1,65 @@ +[ + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"query\":\"something jazzy for during dinner, not too present\",\"history\":[],\"prior_recommendations\":[],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"required_candidate_count\":35}"}],"model":"claude-sonnet-5","output_config":{"effort":"low","format":{"schema":{"$defs":{"CandidateOutput":{"type":"object","description":"One bounded candidate in the intent response.","title":"CandidateOutput","properties":{"title":{"type":"string","title":"Title","description":"{maxLength: 200, minLength: 1}"},"artist":{"type":"string","title":"Artist","description":"{maxLength: 200, minLength: 1}"}},"additionalProperties":false,"required":["title","artist"]},"Familiarity":{"type":"string","enum":["familiar","mix","new"],"description":"How strongly a request should favor known or unknown music.","title":"Familiarity"}},"type":"object","description":"Bounded structured output for the intent call.","title":"IntentOutput","properties":{"mood":{"type":"array","title":"Mood","items":{"type":"string"},"description":"{maxItems: 6}"},"activity":{"anyOf":[{"type":"string","description":"{maxLength: 100}"},{"type":"null"}],"title":"Activity","description":"{default: None}"},"era":{"type":"array","title":"Era","items":{"type":"string"},"description":"{maxItems: 5}"},"languages":{"type":"array","title":"Languages","items":{"type":"string"},"description":"{maxItems: 8}"},"genres":{"type":"array","title":"Genres","items":{"type":"string"},"description":"{maxItems: 8}"},"familiarity":{"$ref":"#/$defs/Familiarity"},"is_refinement":{"type":"boolean","title":"Is Refinement"},"intent_summary":{"type":"string","title":"Intent Summary","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"},"candidates":{"type":"array","title":"Candidates","items":{"$ref":"#/$defs/CandidateOutput"},"description":"{maxItems: 50, minItems: 10}"}},"additionalProperties":false,"required":["familiarity","is_refinement","intent_summary","candidates"]},"type":"json_schema"}},"system":[{"type":"text","text":"You are the intent interpreter and candidate generator for a music discovery system. Your job is to understand one listener request, use the supplied taste evidence carefully, and propose real recordings that another service can resolve against Spotify. Return only data that conforms to the provided output schema. Do not add prose before or after the structured response.\n\nInterpret the request in context. The variable input can contain a current query, a bounded conversation history, recommendations from an earlier response, and a compact taste profile. Treat the current query as authoritative. Use history only to resolve references, continuity, or explicit changes such as \"more like the third one\" or \"less energetic.\" Prior recommendations are evidence about what the listener has just seen, not proof that the listener likes every item. The Spotify taste profile is evidence of listening behavior, not a complete identity and not permission to stereotype the listener.\n\nPopulate every schema field honestly. Mood is a short bounded list of useful musical or emotional qualities. Activity is a concise listening context when one is stated or strongly implied, otherwise null. Era contains only time periods that matter to the request. Languages contains requested or strongly implied vocal languages; use an empty list when language is irrelevant or the music can be instrumental. Genres should be specific enough to guide selection without inventing a false precision. Familiarity must be familiar, mix, or new. Use familiar when the listener asks for comfort, favorites, known songs, or reliable crowd recognition. Use new when the listener asks for discovery, obscurity, unfamiliar music, or a departure from their habits. Use mix for a balanced bridge or when the request does not justify either extreme.\n\nSet is_refinement to true only when the listener is revising, narrowing, extending, or referring to an earlier recommendation result in the supplied conversation. A standalone request is not a refinement merely because history exists. The intent summary must be one plain-English sentence that tells the listener how the request was understood. It must not mention internal models, candidate generation, schemas, retrieval, or Spotify search behavior.\n\nGenerate the exact candidate count requested in the variable input. Each candidate contains only a track title and the credited artist name most likely to identify the recording. Choose recordings that plausibly exist in Spotify's catalog. Use canonical spellings. Do not fabricate tracks, mash up titles and artists, translate titles, or use descriptive placeholders. Avoid remixes, live versions, remasters, edits, sped-up versions, slowed versions, karaoke versions, covers, and tribute recordings unless the user explicitly asks for them. When several recordings share a title, choose the artist credit that makes the intended recording unambiguous.\n\nCandidate quality matters more than superficial variety. Every candidate should fit the interpreted mood, activity, era, language, genre, and familiarity. Still, spread the set across artists. Do not let one artist dominate the candidate list, even when that artist appears prominently in the taste profile. Avoid duplicate titles by the same artist and avoid multiple editions of the same recording. Use a range of strong fits so a later ranking step has meaningful choices rather than thirty near-identical songs.\n\nWhen familiarity leans new, propose music the listener plausibly does not know. Move beyond the named top artists and tracks while retaining understandable bridges through genre, scene, production style, instrumentation, energy, era, or songwriting. Do not simply select deep cuts from every familiar artist. Prefer adjacent artists, overlooked catalogs, regional scenes, and credible cross-genre connections. The profile is not exhaustive, so never claim that a candidate is definitely unknown. When familiarity is familiar, candidates may include supplied top or saved tracks, but remain responsive to the current request. When familiarity is mix, combine recognizable anchors with adjacent discoveries rather than splitting into unrelated halves.\n\nUse musical knowledge conservatively. Base selection on durable, commonly knowable attributes of recordings. Do not invent listening statistics, personal memories, release stories, chart facts, cultural identities, lyrical meanings, or audio features. Do not infer sensitive traits from taste. Explicit safety or content constraints in the request are binding. If a request is broad, create a coherent interpretation instead of asking a question. If constraints conflict, prioritize explicit exclusions, then the current query, then history, then taste evidence.\n\nThe downstream resolver first tries an exact field-filtered search and then a fuzzy bare-text search. Help it succeed with correct title and artist spelling. It will reject weak title or artist matches, so substituting a vaguely related track wastes a candidate. Prefer a confidently identifiable recording over an obscure item whose title or credit you cannot state accurately. Do not include Spotify identifiers, album names, explanations, scores, or justifications in candidate objects.\n\nBefore returning, silently check that the response matches the schema, the candidate list has exactly the requested size, familiarity uses the allowed value, is_refinement reflects conversation continuity, the intent summary is one line, spellings are credible, artist distribution is broad, and no candidate violates an explicit exclusion. Return strictly the structured response and nothing else.\n","cache_control":{"type":"ephemeral"}}]}", + "response_body_base64": "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", + "response_chunks_base64": [ + "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" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"intent\":{\"mood\":[\"mellow\",\"relaxed\",\"warm\",\"understated\",\"smooth\"],\"activity\":\"dinner\",\"era\":[],\"languages\":[],\"genres\":[\"jazz\",\"smooth jazz\",\"bossa nova\",\"lounge jazz\"],\"familiarity\":\"mix\",\"intent_summary\":\"Looking for smooth, low-key jazz that stays in the background during dinner.\"},\"grounded_pool\":[{\"track_id\":\"7JtcCde09fsajDNHmPFrX7\",\"title\":\"Autumn Leaves\",\"artists\":[\"Bill Evans\",\"Scott LaFaro\",\"Paul Motian\"]},{\"track_id\":\"0aWMVrwxPNYkKmFthzmpRi\",\"title\":\"Blue in Green (feat. John Coltrane & Bill Evans)\",\"artists\":[\"Miles Davis\",\"John Coltrane\",\"Bill Evans\"]},{\"track_id\":\"0Wh99eifNTNqDFRtzWhCE2\",\"title\":\"Corcovado (Quiet Nights Of Quiet Stars)\",\"artists\":[\"Stan Getz\",\"Jo\\u00e3o Gilberto\",\"Astrud Gilberto\",\"Ant\\u00f4nio Carlos Jobim\"]},{\"track_id\":\"7znjbX9XdoQayIrVNdd50Z\",\"title\":\"The Girl From Ipanema\",\"artists\":[\"Stan Getz\"]},{\"track_id\":\"7bMrdOiYdHjz5dplqSxj8r\",\"title\":\"Waltz For Debby\",\"artists\":[\"Bill Evans\"]},{\"track_id\":\"4vLYewWIvqHfKtJDk8c8tq\",\"title\":\"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)\",\"artists\":[\"Miles Davis\",\"John Coltrane\",\"Cannonball Adderley\",\"Bill Evans\"]},{\"track_id\":\"4l9hml2UCnxoNI3yCdL1BW\",\"title\":\"My Funny Valentine\",\"artists\":[\"Chet Baker\"]},{\"track_id\":\"79dhjqvk5LOW1Ah1dQDGgU\",\"title\":\"Con Alma\",\"artists\":[\"Dizzy Gillespie\"]},{\"track_id\":\"0E8q2Fx2XuzXCO2NSAppkR\",\"title\":\"In A Sentimental Mood\",\"artists\":[\"Duke Ellington\",\"John Coltrane\"]},{\"track_id\":\"1wl5b2lw3YagQtZiYZbQWP\",\"title\":\"'Round Midnight\",\"artists\":[\"Thelonious Monk\"]},{\"track_id\":\"2M7EflZCPCqqRLB9hy5MDy\",\"title\":\"Feels So Good\",\"artists\":[\"Chuck Mangione\"]},{\"track_id\":\"5mhf7JKdWeD75rFrtVoH9G\",\"title\":\"Watch What Happens\",\"artists\":[\"Wes Montgomery\"]},{\"track_id\":\"7oxwhQxkGegjlMf3k9sWgm\",\"title\":\"Desafinado\",\"artists\":[\"Ant\\u00f4nio Carlos Jobim\"]},{\"track_id\":\"5UbLKRX1qVROlwDFOooEvG\",\"title\":\"Take Five\",\"artists\":[\"Dave Brubeck\",\"The Dave Brubeck Quartet\"]},{\"track_id\":\"7pNzValdo55jNcM7iIlR4J\",\"title\":\"Nardis\",\"artists\":[\"Bill Evans\",\"Eddie G\\u00f3mez\",\"Jack DeJohnette\"]},{\"track_id\":\"0PHqHvmg4TIaANfbsvDMTR\",\"title\":\"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb)\",\"artists\":[\"Miles Davis\",\"John Coltrane\",\"Hank Mobley\",\"Wynton Kelly\",\"Paul Chambers\",\"Jimmy Cobb\"]},{\"track_id\":\"1zNXF2svmdlNxfS5XeNUgr\",\"title\":\"Don't Know Why\",\"artists\":[\"Norah Jones\"]},{\"track_id\":\"6xcIBTUOeeK4IN8a3xctqc\",\"title\":\"Softly As In A Morning Sunrise - Afternoon Take / Live At The Village Vanguard/1957\",\"artists\":[\"Sonny Rollins\"]},{\"track_id\":\"1z0ibdcLwz3TwZgUIWzXd5\",\"title\":\"Blue Bossa\",\"artists\":[\"Kenny Dorham\",\"Davidsen Duo\"]},{\"track_id\":\"3GijK6y7FQ2p5YMEgN85RH\",\"title\":\"Moonlight In Vermont\",\"artists\":[\"Johnny Smith\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"history\":[],\"requested_selection_count\":15,\"correction\":null}"}],"model":"claude-sonnet-5","output_config":{"effort":"medium","format":{"type":"json_schema","schema":{"$defs":{"RerankSelectionOutput":{"type":"object","description":"One validated object extracted from the rerank stream.","title":"RerankSelectionOutput","properties":{"track_id":{"type":"string","title":"Track Id","description":"{maxLength: 200, minLength: 1}"},"justification":{"type":"string","title":"Justification","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"}},"additionalProperties":false,"required":["track_id","justification"]}},"type":"object","description":"Complete bounded rerank output used for final validation.","title":"RerankOutput","properties":{"recommendations":{"type":"array","title":"Recommendations","items":{"$ref":"#/$defs/RerankSelectionOutput"},"minItems":1,"description":"{maxItems: 50}"}},"additionalProperties":false,"required":["recommendations"]}}},"system":[{"type":"text","text":"You are the final ranking component of a music discovery system. Select and order tracks only from the grounded Spotify pool supplied in the variable input. Return only data that conforms to the provided JSON schema. Output strictly the JSON object required by that schema, with no markdown, no code fence, no introductory sentence, and no trailing commentary.\n\nThe variable input contains the interpreted intent, a compact listener taste summary, bounded conversation history, and a grounded pool. Every pool entry includes a Spotify track id, title, and artist names. The pool is the complete set of allowed choices. Copy track_id values exactly. Never create, alter, guess, shorten, or normalize an id. Never select a title that is absent from the pool, even if it would be a better recommendation. Never return the same track id twice.\n\nChoose up to the requested selection count, ordered from strongest to weakest recommendation. Prefer a shorter set of honest strong fits over padding with clearly unsuitable material, but normally fill the requested count when the pool contains enough relevant choices. Ranking should respond to the current intent first. Use the taste summary to personalize among plausible fits, not to override an explicit request. Use history to understand refinements and references. Treat prior assistant statements as conversation context rather than verified facts about a recording.\n\nRespect the interpreted mood, activity, era, languages, genres, and familiarity together. A track need not satisfy every soft descriptor equally, but the ordering should form a coherent listening path. Put the clearest overall matches early. Consider transitions in energy, texture, and familiarity when that creates a more useful sequence, while avoiding a mechanical pattern. Spread selections across artists where the grounded pool permits it. Do not rank several editions of the same recording merely to fill space.\n\nFamiliarity affects ordering, but it does not grant access to information outside the input. For familiar requests, favor grounded tracks that visibly connect to the supplied taste evidence or prior recommendations. For new requests, favor credible adjacent discoveries and avoid leaning entirely on artists named in the taste summary. For mix requests, use recognizable anchors and exploratory choices in a coherent balance. The application may already have filtered known tracks, so do not claim that any selection is definitely new or previously unheard.\n\nWrite one concise, plain-English justification for each selection. It should connect the track to the stated intent and, only when supported, to an explicit item or pattern in the supplied taste summary. Keep it to one line. Make the reason useful to the listener rather than describing internal ranking operations. Good reasons identify a grounded connection such as pacing for the activity, a genre bridge, a requested era, a compatible vocal language, a mood transition, or continuity with a named preference.\n\nBe exact and modest. Do not invent audio measurements, tempo values, key signatures, instrumentation, lyrical subjects, release dates, artist biographies, chart history, cultural significance, collaborations, popularity, or claims about what the listener has heard. A title and artist name alone do not prove detailed sonic or lyrical facts. You may use stable general musical knowledge when confident, but phrase the justification around the supplied intent and visible evidence. If the inputs do not support a specific fact, use a restrained reason such as \"A focused fit for the requested late-night electronic mood\" rather than manufacturing detail.\n\nDo not mention Spotify search, grounding, the candidate generator, language models, schemas, hidden scores, safety filters, cache state, or missing data in a justification. Do not tell the listener that a track was selected because it was available in the pool. Do not compare a selection with tracks that are not in the pool. Do not repeat the same generic sentence for every item. Avoid promotional language and absolute claims such as \"perfect,\" \"guaranteed,\" or \"the best.\"\n\nWhen the variable input says this is a correction attempt, treat the stated validation failure as a strict constraint. Return a fresh complete JSON object, not a patch or explanation. Correct invalid ids, duplicates, malformed fields, count problems, and formatting errors using only the supplied pool. The correction instruction never allows an out-of-pool id.\n\nThe response must be one JSON object with the exact top-level field required by the schema. Each array item must contain exactly a track_id and justification in the required types. Preserve the requested ranking order in the array. Use valid JSON quoting and escaping. Do not emit comments, dangling commas, alternate keys, null justifications, numeric ids, or additional properties.\n\nBefore returning, silently verify every track_id against the supplied pool, ensure all ids are unique, ensure the number of items does not exceed the requested count, confirm each justification is honest and one line, confirm the ranking follows the current intent, and confirm the entire response is valid against the provided JSON schema. Return only the JSON object.\n","cache_control":{"type":"ephemeral"}}],"stream":true}", + "response_body_base64": "event: message_start
data: {"type":"message_start","message":{"model":"claude-sonnet-5","id":"msg_011CdtuZtMFaKydKXQRpi52K","type":"message","role":"assistant","content":[],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":6515,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"global"}}      }

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}      }

event: ping
data: {"type": "ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"{"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"rec"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ommendations\":[{\"track"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"_id\":\"0Wh99eifNTNqDFRt"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"zWhCE2\",\"justification\":\"A gentle bossa nova classic that sets a war"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"m, unobtrusive tone for dinner.\"},{\"track_id\":\"7znjbX9XdoQ"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ayIrVNdd50Z\",\"justification\":\"Smooth, famil"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"iar bossa nova that stays soft in the background without demanding attention.\"},{\"track_id\":\"7oxwhQxk"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"GegjlMf3k9sWgm"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"Light bossa nova rhythm that keeps the mellow dinner mood flowing.\"},{\"track_id\":\"1z0ib"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"dcLwz3TwZgUI"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"WzXd5\",\"justification\":\"A relaxed jazz-bossa bridge that adds warmth without breaking the low"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"-key feel.\"},{\"track_id\":\"7bMrdOiYdHjz"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"5dplqSxj8r\",\"justification\":\"Delicate piano trio work"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" that stays understated and easy to enjoy over a meal.\"},{\"track_id\":\"7JtcCde09f"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"sajDNHmPFrX7\",\"justification\":\"A g"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"entle, reflective take on a jazz standard that suits quiet conversation.\"},{\"track_id\":\"7pNzValdo55j"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"NcM7iIlR4J\",\"justification\":\"Smooth,"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" atmospheric trio playing that keeps energy soft and understated.\"},{\"track_id\":\"0aWMVr"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"wxPNYkKmFthzm"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"pRi\",\"justification\":\"Sparse and calm modal jazz that stays gently in the background.\"},{\"track_id\":\"4l9hml"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"2UCnxoNI3yCd"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"L1BW\",\"justification\":\"A warm, intimate vocal jazz ballad fitting for a relaxed dinner setting.\"},{\"track_id\":\"0E8"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"q2Fx2XuzXCO2N"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"SAppkR\",\"justification\":\"Slow, tender jazz mood that adds warmth without overpowering con"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"versation.\"},{\"track_id\":\"3GijK6y7FQ2p5YM"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"EgN85RH\",\"justification\":\"Soft guitar-led jazz standard that keeps the ambiance smooth and low"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"-key.\"},{\"track_id\":\"5mhf7JKdWeD75"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"rFrtVoH9G\",\"justification\":\"Mellow guitar jazz with a rel"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"axed groove suited to background listening.\"},{\"track_id\":\"1wl5b2lw3Y"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"agQtZiYZbQWP\",\"justification\":\"A class"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ic, unhurried jazz tune that maintains a subdued dinner atmosphere.\"},{\"track_id\":\"1zNXF2"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"svmdlNxfS5XeN"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Ugr\",\"justification\":\"A soft, contemporary jazz-pop vocal track that eases the mix to"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ward familiarity.\"},{\"track_id\":\"6xcIBTUOeeK4"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"IN8a3xctqc\",\"justification\":\"A smooth, underst"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ated live jazz performance that closes the set gently.\"}]}"}             }

event: content_block_stop
data: {"type":"content_block_stop","index":0          }

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null,"stop_details":null},"usage":{"input_tokens":6515,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"output_tokens":932,"output_tokens_details":{"thinking_tokens":0}}            }

event: message_stop
data: {"type":"message_stop"   }

", + "response_chunks_base64": [ + "ZXZlbnQ6IG1lc3NhZ2Vfc3RhcnQKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9zdGFydCIsIm1lc3NhZ2U=", + "Ijp7Im1vZGVsIjoiY2xhdWRlLXNvbm5ldC01IiwiaWQiOiJtc2dfMDExQ2R0dVp0TUZhS3lkS1hRUnBpNTJLIiwidHlwZSI6Im1lc3NhZ2UiLCJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6W10sInN0b3BfcmVhc29uIjpudWxsLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NjUxNSwiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MjExMywiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MCwiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjEsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Imdsb2JhbCJ9fSAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RhcnQKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19zdGFydCIsImluZGV4IjowLCJjb250ZW50X2Jsb2NrIjp7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IiJ9ICAgICAgfQoK", + "ZXZlbnQ6IHBpbmcKZGF0YTogeyJ0eXBlIjogInBpbmcifQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ7In0gICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInJlYyJ9ICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvbW1lbmRhdGlvbnNcIjpbe1widHJhY2sifSAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJfaWRcIjpcIjBXaDk5ZWlmTlROcURGUnQifSAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ6V2hDRTJcIixcImp1c3RpZmljYXRpb25cIjpcIkEgZ2VudGxlIGJvc3NhIG5vdmEgY2xhc3NpYyB0aGF0IHNldHMgYSB3YXIifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJtLCB1bm9idHJ1c2l2ZSB0b25lIGZvciBkaW5uZXIuXCJ9LHtcInRyYWNrX2lkXCI6XCI3em5qYlg5WGRvUSJ9ICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJheUlyVk5kZDUwWlwiLFwianVzdGlmaWNhdGlvblwiOlwiU21vb3RoLCBmYW1pbCJ9ICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpYXIgYm9zc2Egbm92YSB0aGF0IHN0YXlzIHNvZnQgaW4gdGhlIGJhY2tncm91bmQgd2l0aG91dCBkZW1hbmRpbmcgYXR0ZW50aW9uLlwifSx7XCJ0cmFja19pZFwiOlwiN294d2hReGsifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJHZWdqbE1mM2s5c1dnbSJ9ICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIkxpZ2h0IGJvc3NhIG5vdmEgcmh5dGhtIHRoYXQga2VlcHMgdGhlIG1lbGxvdyBkaW5uZXIgbW9vZCBmbG93aW5nLlwifSx7XCJ0cmFja19pZFwiOlwiMXowaWIifSAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJkY0x3ejNUd1pnVUkifSAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJXelhkNVwiLFwianVzdGlmaWNhdGlvblwiOlwiQSByZWxheGVkIGphenotYm9zc2EgYnJpZGdlIHRoYXQgYWRkcyB3YXJtdGggd2l0aG91dCBicmVha2luZyB0aGUgbG93In0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIta2V5IGZlZWwuXCJ9LHtcInRyYWNrX2lkXCI6XCI3Yk1yZE9pWWRIanoifSAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI1ZHBscVN4ajhyXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJEZWxpY2F0ZSBwaWFubyB0cmlvIHdvcmsifSAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgdGhhdCBzdGF5cyB1bmRlcnN0YXRlZCBhbmQgZWFzeSB0byBlbmpveSBvdmVyIGEgbWVhbC5cIn0se1widHJhY2tfaWRcIjpcIjdKdGNDZGUwOWYifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJzYWpETkhtUEZyWDdcIixcImp1c3RpZmljYXRpb25cIjpcIkEgZyJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlbnRsZSwgcmVmbGVjdGl2ZSB0YWtlIG9uIGEgamF6eiBzdGFuZGFyZCB0aGF0IHN1aXRzIHF1aWV0IGNvbnZlcnNhdGlvbi5cIn0se1widHJhY2tfaWRcIjpcIjdwTnpWYWxkbzU1aiJ9ICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJOY003aUlsUjRKXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJTbW9vdGgsIn0gICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgYXRtb3NwaGVyaWMgdHJpbyBwbGF5aW5nIHRoYXQga2VlcHMgZW5lcmd5IHNvZnQgYW5kIHVuZGVyc3RhdGVkLlwifSx7XCJ0cmFja19pZFwiOlwiMGFXTVZyIn0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ3eFBOWWtLbUZ0aHptIn0gICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJwUmlcIixcImp1c3RpZmljYXRpb25cIjpcIlNwYXJzZSBhbmQgY2FsbSBtb2RhbCBqYXp6IHRoYXQgc3RheXMgZ2VudGx5IGluIHRoZSBiYWNrZ3JvdW5kLlwifSx7XCJ0cmFja19pZFwiOlwiNGw5aG1sIn0gICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIyVUNueG9OSTN5Q2QifSAgICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJMMUJXXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIHdhcm0sIGludGltYXRlIHZvY2FsIGphenogYmFsbGFkIGZpdHRpbmcgZm9yIGEgcmVsYXhlZCBkaW5uZXIgc2V0dGluZy5cIn0se1widHJhY2tfaWRcIjpcIjBFOCJ9fQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJxMkZ4Mlh1elhDTzJOIn0gICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJTQXBwa1JcIixcImp1c3RpZmljYXRpb25cIjpcIlNsb3csIHRlbmRlciBqYXp6IG1vb2QgdGhhdCBhZGRzIHdhcm10aCB3aXRob3V0IG92ZXJwb3dlcmluZyBjb24ifSAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ2ZXJzYXRpb24uXCJ9LHtcInRyYWNrX2lkXCI6XCIzR2lqSzZ5N0ZRMnA1WU0ifSAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJFZ044NVJIXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJTb2Z0IGd1aXRhci1sZWQgamF6eiBzdGFuZGFyZCB0aGF0IGtlZXBzIHRoZSBhbWJpYW5jZSBzbW9vdGggYW5kIGxvdyJ9ICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIta2V5LlwifSx7XCJ0cmFja19pZFwiOlwiNW1oZjdKS2RXZUQ3NSJ9ICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJyRnJ0Vm9IOUdcIixcImp1c3RpZmljYXRpb25cIjpcIk1lbGxvdyBndWl0YXIgamF6eiB3aXRoIGEgcmVsIn0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJheGVkIGdyb292ZSBzdWl0ZWQgdG8gYmFja2dyb3VuZCBsaXN0ZW5pbmcuXCJ9LHtcInRyYWNrX2lkXCI6XCIxd2w1YjJsdzNZIn0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJhZ1F0WmlZWmJRV1BcIixcImp1c3RpZmljYXRpb25cIjpcIkEgY2xhc3MifSAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpYywgdW5odXJyaWVkIGphenogdHVuZSB0aGF0IG1haW50YWlucyBhIHN1YmR1ZWQgZGlubmVyIGF0bW9zcGhlcmUuXCJ9LHtcInRyYWNrX2lkXCI6XCIxek5YRjIifSAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJzdm1kbE54ZlM1WGVOIn0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJVZ3JcIixcImp1c3RpZmljYXRpb25cIjpcIkEgc29mdCwgY29udGVtcG9yYXJ5IGphenotcG9wIHZvY2FsIHRyYWNrIHRoYXQgZWFzZXMgdGhlIG1peCB0byJ9ICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ3YXJkIGZhbWlsaWFyaXR5LlwifSx7XCJ0cmFja19pZFwiOlwiNnhjSUJUVU9lZUs0In0gfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJJTjhhM3hjdHFjXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIHNtb290aCwgdW5kZXJzdCJ9ICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJhdGVkIGxpdmUgamF6eiBwZXJmb3JtYW5jZSB0aGF0IGNsb3NlcyB0aGUgc2V0IGdlbnRseS5cIn1dfSJ9ICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RvcApkYXRhOiB7InR5cGUiOiJjb250ZW50X2Jsb2NrX3N0b3AiLCJpbmRleCI6MCAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IG1lc3NhZ2VfZGVsdGEKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9kZWx0YSIsImRlbHRhIjp7InN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGx9LCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjY1MTUsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjIxMTMsIm91dHB1dF90b2tlbnMiOjkzMiwib3V0cHV0X3Rva2Vuc19kZXRhaWxzIjp7InRoaW5raW5nX3Rva2VucyI6MH19ICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IG1lc3NhZ2Vfc3RvcApkYXRhOiB7InR5cGUiOiJtZXNzYWdlX3N0b3AiICAgfQoK" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + } +] diff --git a/eval/fixtures/dinner-background/spotify.json b/eval/fixtures/dinner-background/spotify.json new file mode 100644 index 0000000..9612c99 --- /dev/null +++ b/eval/fixtures/dinner-background/spotify.json @@ -0,0 +1,442 @@ +[ + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=", + "response_chunks_base64": [ + "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=0" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Autumn%20Leaves%22%20artist%3A%22Bill%20Evans%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/7dlYNvbD4QYDL3sSkTCjxi"},"href":"https://api.spotify.com/v1/albums/7dlYNvbD4QYDL3sSkTCjxi","id":"7dlYNvbD4QYDL3sSkTCjxi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273079febd5ded0a77d42d70a55"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02079febd5ded0a77d42d70a55"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851079febd5ded0a77d42d70a55"}],"is_playable":true,"name":"Portrait In Jazz [Keepnews Collection]","release_date":"1960","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:7dlYNvbD4QYDL3sSkTCjxi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4g7uUySyORXh2KgDEhgxXa"},"href":"https://api.spotify.com/v1/artists/4g7uUySyORXh2KgDEhgxXa","id":"4g7uUySyORXh2KgDEhgxXa","name":"Scott LaFaro","type":"artist","uri":"spotify:artist:4g7uUySyORXh2KgDEhgxXa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4VIPZJwfn4EGbJxYVHJ0WX"},"href":"https://api.spotify.com/v1/artists/4VIPZJwfn4EGbJxYVHJ0WX","id":"4VIPZJwfn4EGbJxYVHJ0WX","name":"Paul Motian","type":"artist","uri":"spotify:artist:4VIPZJwfn4EGbJxYVHJ0WX"}],"disc_number":1,"duration_ms":360546,"explicit":false,"external_ids":{"isrc":"USC4R0720029"},"external_urls":{"spotify":"https://open.spotify.com/track/7JtcCde09fsajDNHmPFrX7"},"href":"https://api.spotify.com/v1/tracks/7JtcCde09fsajDNHmPFrX7","id":"7JtcCde09fsajDNHmPFrX7","is_local":false,"is_playable":true,"name":"Autumn Leaves","track_number":2,"type":"track","uri":"spotify:track:7JtcCde09fsajDNHmPFrX7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/093nLQ4H81HusNsFdGS4Or"},"href":"https://api.spotify.com/v1/albums/093nLQ4H81HusNsFdGS4Or","id":"093nLQ4H81HusNsFdGS4Or","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b4eb45cec85a844eafa21b69"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b4eb45cec85a844eafa21b69"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b4eb45cec85a844eafa21b69"}],"is_playable":true,"name":"Portrait In Jazz","release_date":"1960","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:093nLQ4H81HusNsFdGS4Or"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":356960,"explicit":false,"external_ids":{"isrc":"USFI86000048"},"external_urls":{"spotify":"https://open.spotify.com/track/6Mh2Ieqmav2dtir0O8MB9L"},"href":"https://api.spotify.com/v1/tracks/6Mh2Ieqmav2dtir0O8MB9L","id":"6Mh2Ieqmav2dtir0O8MB9L","is_local":false,"is_playable":true,"name":"Autumn Leaves - Album Version - (Take 1)","track_number":2,"type":"track","uri":"spotify:track:6Mh2Ieqmav2dtir0O8MB9L"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/093nLQ4H81HusNsFdGS4Or"},"href":"https://api.spotify.com/v1/albums/093nLQ4H81HusNsFdGS4Or","id":"093nLQ4H81HusNsFdGS4Or","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b4eb45cec85a844eafa21b69"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b4eb45cec85a844eafa21b69"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b4eb45cec85a844eafa21b69"}],"is_playable":true,"name":"Portrait In Jazz","release_date":"1960","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:093nLQ4H81HusNsFdGS4Or"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":321960,"explicit":false,"external_ids":{"isrc":"USFI86000049"},"external_urls":{"spotify":"https://open.spotify.com/track/0FxrRWZPY9DHymBIrGSJMQ"},"href":"https://api.spotify.com/v1/tracks/0FxrRWZPY9DHymBIrGSJMQ","id":"0FxrRWZPY9DHymBIrGSJMQ","is_local":false,"is_playable":true,"name":"Autumn Leaves - Album Version - (take 2 bonus track)","track_number":3,"type":"track","uri":"spotify:track:0FxrRWZPY9DHymBIrGSJMQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/7dlYNvbD4QYDL3sSkTCjxi"},"href":"https://api.spotify.com/v1/albums/7dlYNvbD4QYDL3sSkTCjxi","id":"7dlYNvbD4QYDL3sSkTCjxi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273079febd5ded0a77d42d70a55"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02079febd5ded0a77d42d70a55"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851079febd5ded0a77d42d70a55"}],"is_playable":true,"name":"Portrait In Jazz [Keepnews Collection]","release_date":"1960","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:7dlYNvbD4QYDL3sSkTCjxi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4g7uUySyORXh2KgDEhgxXa"},"href":"https://api.spotify.com/v1/artists/4g7uUySyORXh2KgDEhgxXa","id":"4g7uUySyORXh2KgDEhgxXa","name":"Scott LaFaro","type":"artist","uri":"spotify:artist:4g7uUySyORXh2KgDEhgxXa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4VIPZJwfn4EGbJxYVHJ0WX"},"href":"https://api.spotify.com/v1/artists/4VIPZJwfn4EGbJxYVHJ0WX","id":"4VIPZJwfn4EGbJxYVHJ0WX","name":"Paul Motian","type":"artist","uri":"spotify:artist:4VIPZJwfn4EGbJxYVHJ0WX"}],"disc_number":1,"duration_ms":325960,"explicit":false,"external_ids":{"isrc":"USC4R0720038"},"external_urls":{"spotify":"https://open.spotify.com/track/5SJxPNJCpMCgMGLVaxO9gq"},"href":"https://api.spotify.com/v1/tracks/5SJxPNJCpMCgMGLVaxO9gq","id":"5SJxPNJCpMCgMGLVaxO9gq","is_local":false,"is_playable":true,"name":"Autumn Leaves (Take 9 - monaural)","track_number":11,"type":"track","uri":"spotify:track:5SJxPNJCpMCgMGLVaxO9gq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0ffBb2SCAQzfwrs1PoYSiW"},"href":"https://api.spotify.com/v1/artists/0ffBb2SCAQzfwrs1PoYSiW","id":"0ffBb2SCAQzfwrs1PoYSiW","name":"Jeremy Steig","type":"artist","uri":"spotify:artist:0ffBb2SCAQzfwrs1PoYSiW"}],"external_urls":{"spotify":"https://open.spotify.com/album/4YbzDovoNtQ5b66zsLi2mO"},"href":"https://api.spotify.com/v1/albums/4YbzDovoNtQ5b66zsLi2mO","id":"4YbzDovoNtQ5b66zsLi2mO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e1328fa0b9f3598b322e27d8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e1328fa0b9f3598b322e27d8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e1328fa0b9f3598b322e27d8"}],"is_playable":true,"name":"What's New","release_date":"1969-01-01","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:4YbzDovoNtQ5b66zsLi2mO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0ffBb2SCAQzfwrs1PoYSiW"},"href":"https://api.spotify.com/v1/artists/0ffBb2SCAQzfwrs1PoYSiW","id":"0ffBb2SCAQzfwrs1PoYSiW","name":"Jeremy Steig","type":"artist","uri":"spotify:artist:0ffBb2SCAQzfwrs1PoYSiW"}],"disc_number":1,"duration_ms":375840,"explicit":false,"external_ids":{"isrc":"USPR36905217"},"external_urls":{"spotify":"https://open.spotify.com/track/0wgmlXuUdl9gdwEUjwDkrD"},"href":"https://api.spotify.com/v1/tracks/0wgmlXuUdl9gdwEUjwDkrD","id":"0wgmlXuUdl9gdwEUjwDkrD","is_local":false,"is_playable":true,"name":"Autumn Leaves","track_number":4,"type":"track","uri":"spotify:track:0wgmlXuUdl9gdwEUjwDkrD"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/3cX2IAd775B5dXMG2nQVQG"},"href":"https://api.spotify.com/v1/albums/3cX2IAd775B5dXMG2nQVQG","id":"3cX2IAd775B5dXMG2nQVQG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b35a9bf27e0f7a7dc3c1d8ba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b35a9bf27e0f7a7dc3c1d8ba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b35a9bf27e0f7a7dc3c1d8ba"}],"is_playable":true,"name":"Autumn Leaves","release_date":"2021-04-23","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3cX2IAd775B5dXMG2nQVQG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":359706,"explicit":false,"external_ids":{"isrc":"USC4R2003665"},"external_urls":{"spotify":"https://open.spotify.com/track/2x7mt5320UkRNRkExOs8SB"},"href":"https://api.spotify.com/v1/tracks/2x7mt5320UkRNRkExOs8SB","id":"2x7mt5320UkRNRkExOs8SB","is_local":false,"is_playable":true,"name":"Autumn Leaves","track_number":1,"type":"track","uri":"spotify:track:2x7mt5320UkRNRkExOs8SB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GAlJcapheEZDKdlCUGOFq"},"href":"https://api.spotify.com/v1/albums/5GAlJcapheEZDKdlCUGOFq","id":"5GAlJcapheEZDKdlCUGOFq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f794511b5186f8c3cd56b52a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f794511b5186f8c3cd56b52a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f794511b5186f8c3cd56b52a"}],"is_playable":true,"name":"Haunted Heart: The Legendary Riverside Studio Recordings (Remastered 2025)","release_date":"2025-11-07","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:5GAlJcapheEZDKdlCUGOFq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":359715,"explicit":false,"external_ids":{"isrc":"USC4R2500464"},"external_urls":{"spotify":"https://open.spotify.com/track/3rCNodMoMhFpGLxxOMVZOq"},"href":"https://api.spotify.com/v1/tracks/3rCNodMoMhFpGLxxOMVZOq","id":"3rCNodMoMhFpGLxxOMVZOq","is_local":false,"is_playable":true,"name":"Autumn Leaves - Remastered Stereo 2025","track_number":2,"type":"track","uri":"spotify:track:3rCNodMoMhFpGLxxOMVZOq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GAlJcapheEZDKdlCUGOFq"},"href":"https://api.spotify.com/v1/albums/5GAlJcapheEZDKdlCUGOFq","id":"5GAlJcapheEZDKdlCUGOFq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f794511b5186f8c3cd56b52a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f794511b5186f8c3cd56b52a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f794511b5186f8c3cd56b52a"}],"is_playable":true,"name":"Haunted Heart: The Legendary Riverside Studio Recordings (Remastered 2025)","release_date":"2025-11-07","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:5GAlJcapheEZDKdlCUGOFq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":324936,"explicit":false,"external_ids":{"isrc":"USC4R2500485"},"external_urls":{"spotify":"https://open.spotify.com/track/16BtcWbLhoAKTJYM7Ig4Tt"},"href":"https://api.spotify.com/v1/tracks/16BtcWbLhoAKTJYM7Ig4Tt","id":"16BtcWbLhoAKTJYM7Ig4Tt","is_local":false,"is_playable":true,"name":"Autumn Leaves - Remastered Mono 2025 / Take 9","track_number":15,"type":"track","uri":"spotify:track:16BtcWbLhoAKTJYM7Ig4Tt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1NLGIv3lw2irzjONDrU28K"},"href":"https://api.spotify.com/v1/albums/1NLGIv3lw2irzjONDrU28K","id":"1NLGIv3lw2irzjONDrU28K","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee141722d2487374664b1f45"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee141722d2487374664b1f45"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee141722d2487374664b1f45"}],"is_playable":true,"name":"Everybody Still Digs Bill Evans","release_date":"2021-06-25","release_date_precision":"day","total_tracks":61,"type":"album","uri":"spotify:album:1NLGIv3lw2irzjONDrU28K"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":359706,"explicit":false,"external_ids":{"isrc":"USC4R2003665"},"external_urls":{"spotify":"https://open.spotify.com/track/1L8kzHRTFE69YQYL7iv9TK"},"href":"https://api.spotify.com/v1/tracks/1L8kzHRTFE69YQYL7iv9TK","id":"1L8kzHRTFE69YQYL7iv9TK","is_local":false,"is_playable":true,"name":"Autumn Leaves","track_number":4,"type":"track","uri":"spotify:track:1L8kzHRTFE69YQYL7iv9TK"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1CjnyyNFm22vUIjRfxT6ex"},"href":"https://api.spotify.com/v1/albums/1CjnyyNFm22vUIjRfxT6ex","id":"1CjnyyNFm22vUIjRfxT6ex","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273439422845abf1fbe5926ea48"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02439422845abf1fbe5926ea48"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851439422845abf1fbe5926ea48"}],"is_playable":true,"name":"Portraits at the Penthouse: Live in Seattle","release_date":"2026-01-16","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1CjnyyNFm22vUIjRfxT6ex"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6HBVTGmPHytchERPb8YGPr"},"href":"https://api.spotify.com/v1/artists/6HBVTGmPHytchERPb8YGPr","id":"6HBVTGmPHytchERPb8YGPr","name":"Eddie G\u00f3mez","type":"artist","uri":"spotify:artist:6HBVTGmPHytchERPb8YGPr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6TsAKBA7qM66xRgpTwKrK8"},"href":"https://api.spotify.com/v1/artists/6TsAKBA7qM66xRgpTwKrK8","id":"6TsAKBA7qM66xRgpTwKrK8","name":"Joe Hunt","type":"artist","uri":"spotify:artist:6TsAKBA7qM66xRgpTwKrK8"}],"disc_number":1,"duration_ms":190516,"explicit":false,"external_ids":{"isrc":"USA2P2547815"},"external_urls":{"spotify":"https://open.spotify.com/track/2CnZG0lYxqvZ00L7VFnJJu"},"href":"https://api.spotify.com/v1/tracks/2CnZG0lYxqvZ00L7VFnJJu","id":"2CnZG0lYxqvZ00L7VFnJJu","is_local":false,"is_playable":true,"name":"Autumn Leaves (Live at the Penthouse in Seattle May 19, 1966)","track_number":10,"type":"track","uri":"spotify:track:2CnZG0lYxqvZ00L7VFnJJu"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Autumn%20Leaves%22%20artist%3A%22Bill%20Evans%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/7dlYNvbD4QYDL3sSkTCjxi"},"href":"https://api.spotify.com/v1/albums/7dlYNvbD4QYDL3sSkTCjxi","id":"7dlYNvbD4QYDL3sSkTCjxi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273079febd5ded0a77d42d70a55"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02079febd5ded0a77d42d70a55"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851079febd5ded0a77d42d70a55"}],"is_playable":true,"name":"Portrait In Jazz [Keepnews Collection]","release_date":"1960","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:7dlYNvbD4QYDL3sSkTCjxi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4g7uUySyORXh2KgDEhgxXa"},"href":"https://api.spotify.com/v1/artists/4g7uUySyORXh2KgDEhgxXa","id":"4g7uUySyORXh2KgDEhgxXa","name":"Scott LaFaro","type":"artist","uri":"spotify:artist:4g7uUySyORXh2KgDEhgxXa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4VIPZJwfn4EGbJxYVHJ0WX"},"href":"https://api.spotify.com/v1/artists/4VIPZJwfn4EGbJxYVHJ0WX","id":"4VIPZJwfn4EGbJxYVHJ0WX","name":"Paul Motian","type":"artist","uri":"spotify:artist:4VIPZJwfn4EGbJxYVHJ0WX"}],"disc_number":1,"duration_ms":360546,"explicit":false,"external_ids":{"isrc":"USC4R0720029"},"external_urls":{"spotify":"https://open.spotify.com/track/7JtcCde09fsajDNHmPFrX7"},"href":"https://api.spotify.com/v1/tracks/7JtcCde09fsajDNHmPFrX7","id":"7JtcCde09fsajDNHmPFrX7","is_local":false,"is_playable":true,"name":"Autumn Leaves","track_number":2,"type":"track","uri":"spotify:track:7JtcCde09fsajDNHmPFrX7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/093nLQ4H81HusNsFdGS4Or"},"href":"https://api.spotify.com/v1/albums/093nLQ4H81HusNsFdGS4Or","id":"093nLQ4H81HusNsFdGS4Or","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b4eb45cec85a844eafa21b69"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b4eb45cec85a844eafa21b69"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b4eb45cec85a844eafa21b69"}],"is_playable":true,"name":"Portrait In Jazz","release_date":"1960","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:093nLQ4H81HusNsFdGS4Or"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":356960,"explicit":false,"external_ids":{"isrc":"USFI86000048"},"external_urls":{"spotify":"https://open.spotify.com/track/6Mh2Ieqmav2dtir0O8MB9L"},"href":"https://api.spotify.com/v1/tracks/6Mh2Ieqmav2dtir0O8MB9L","id":"6Mh2Ieqmav2dtir0O8MB9L","is_local":false,"is_playable":true,"name":"Autumn Leaves - Album Version - (Take 1)","track_number":2,"type":"track","uri":"spotify:track:6Mh2Ieqmav2dtir0O8MB9L"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/093nLQ4H81HusNsFdGS4Or"},"href":"https://api.spotify.com/v1/albums/093nLQ4H81HusNsFdGS4Or","id":"093nLQ4H81HusNsFdGS4Or","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b4eb45cec85a844eafa21b69"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b4eb45cec85a844eafa21b69"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b4eb45cec85a844eafa21b69"}],"is_playable":true,"name":"Portrait In Jazz","release_date":"1960","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:093nLQ4H81HusNsFdGS4Or"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":321960,"explicit":false,"external_ids":{"isrc":"USFI86000049"},"external_urls":{"spotify":"https://open.spotify.com/track/0FxrRWZPY9DHymBIrGSJMQ"},"href":"https://api.spotify.com/v1/tracks/0FxrRWZPY9DHymBIrGSJMQ","id":"0FxrRWZPY9DHymBIrGSJMQ","is_local":false,"is_playable":true,"name":"Autumn Leaves - Album Version - (take 2 bonus track)","track_number":3,"type":"track","uri":"spotify:track:0FxrRWZPY9DHymBIrGSJMQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/7dlYNvbD4QYDL3sSkTCjxi"},"href":"https://api.spotify.com/v1/albums/7dlYNvbD4QYDL3sSkTCjxi","id":"7dlYNvbD4QYDL3sSkTCjxi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273079febd5ded0a77d42d70a55"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02079febd5ded0a77d42d70a55"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851079febd5ded0a77d42d70a55"}],"is_playable":true,"name":"Portrait In Jazz [Keepnews Collection]","release_date":"1960","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:7dlYNvbD4QYDL3sSkTCjxi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4g7uUySyORXh2KgDEhgxXa"},"href":"https://api.spotify.com/v1/artists/4g7uUySyORXh2KgDEhgxXa","id":"4g7uUySyORXh2KgDEhgxXa","name":"Scott LaFaro","type":"artist","uri":"spotify:artist:4g7uUySyORXh2KgDEhgxXa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4VIPZJwfn4EGbJxYVHJ0WX"},"href":"https://api.spotify.com/v1/artists/4VIPZJwfn4EGbJxYVHJ0WX","id":"4VIPZJwfn4EGbJxYVHJ0WX","name":"Paul Motian","type":"artist","uri":"spotify:artist:4VIPZJwfn4EGbJxYVHJ0WX"}],"disc_number":1,"duration_ms":325960,"explicit":false,"external_ids":{"isrc":"USC4R0720038"},"external_urls":{"spotify":"https://open.spotify.com/track/5SJxPNJCpMCgMGLVaxO9gq"},"href":"https://api.spotify.com/v1/tracks/5SJxPNJCpMCgMGLVaxO9gq","id":"5SJxPNJCpMCgMGLVaxO9gq","is_local":false,"is_playable":true,"name":"Autumn Leaves (Take 9 - monaural)","track_number":11,"type":"track","uri":"spotify:track:5SJxPNJCpMCgMGLVaxO9gq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0ffBb2SCAQzfwrs1PoYSiW"},"href":"https://api.spotify.com/v1/artists/0ffBb2SCAQzfwrs1PoYSiW","id":"0ffBb2SCAQzfwrs1PoYSiW","name":"Jeremy Steig","type":"artist","uri":"spotify:artist:0ffBb2SCAQzfwrs1PoYSiW"}],"external_urls":{"spotify":"https://open.spotify.com/album/4YbzDovoNtQ5b66zsLi2mO"},"href":"https://api.spotify.com/v1/albums/4YbzDovoNtQ5b66zsLi2mO","id":"4YbzDovoNtQ5b66zsLi2mO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e1328fa0b9f3598b322e27d8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e1328fa0b9f3598b322e27d8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e1328fa0b9f3598b322e27d8"}],"is_playable":true,"name":"What's New","release_date":"1969-01-01","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:4YbzDovoNtQ5b66zsLi2mO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0ffBb2SCAQzfwrs1PoYSiW"},"href":"https://api.spotify.com/v1/artists/0ffBb2SCAQzfwrs1PoYSiW","id":"0ffBb2SCAQzfwrs1PoYSiW","name":"Jeremy Steig","type":"artist","uri":"spotify:artist:0ffBb2SCAQzfwrs1PoYSiW"}],"disc_number":1,"duration_ms":375840,"explicit":false,"external_ids":{"isrc":"USPR36905217"},"external_urls":{"spotify":"https://open.spotify.com/track/0wgmlXuUdl9gdwEUjwDkrD"},"href":"https://api.spotify.com/v1/tracks/0wgmlXuUdl9gdwEUjwDkrD","id":"0wgmlXuUdl9gdwEUjwDkrD","is_local":false,"is_playable":true,"name":"Autumn Leaves","track_number":4,"type":"track","uri":"spotify:track:0wgmlXuUdl9gdwEUjwDkrD"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/3cX2IAd775B5dXMG2nQVQG"},"href":"https://api.spotify.com/v1/albums/3cX2IAd775B5dXMG2nQVQG","id":"3cX2IAd775B5dXMG2nQVQG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b35a9bf27e0f7a7dc3c1d8ba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b35a9bf27e0f7a7dc3c1d8ba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b35a9bf27e0f7a7dc3c1d8ba"}],"is_playable":true,"name":"Autumn Leaves","release_date":"2021-04-23","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3cX2IAd775B5dXMG2nQVQG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":359706,"explicit":false,"external_ids":{"isrc":"USC4R2003665"},"external_urls":{"spotify":"https://open.spotify.com/track/2x7mt5320UkRNRkExOs8SB"},"href":"https://api.spotify.com/v1/tracks/2x7mt5320UkRNRkExOs8SB","id":"2x7mt5320UkRNRkExOs8SB","is_local":false,"is_playable":true,"name":"Autumn Leaves","track_number":1,"type":"track","uri":"spotify:track:2x7mt5320UkRNRkExOs8SB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GAlJcapheEZDKdlCUGOFq"},"href":"https://api.spotify.com/v1/albums/5GAlJcapheEZDKdlCUGOFq","id":"5GAlJcapheEZDKdlCUGOFq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f794511b5186f8c3cd56b52a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f794511b5186f8c3cd56b52a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f794511b5186f8c3cd56b52a"}],"is_playable":true,"name":"Haunted Heart: The Legendary Riverside Studio Recordings (Remastered 2025)","release_date":"2025-11-07","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:5GAlJcapheEZDKdlCUGOFq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":359715,"explicit":false,"external_ids":{"isrc":"USC4R2500464"},"external_urls":{"spotify":"https://open.spotify.com/track/3rCNodMoMhFpGLxxOMVZOq"},"href":"https://api.spotify.com/v1/tracks/3rCNodMoMhFpGLxxOMVZOq","id":"3rCNodMoMhFpGLxxOMVZOq","is_local":false,"is_playable":true,"name":"Autumn Leaves - Remastered Stereo 2025","track_number":2,"type":"track","uri":"spotify:track:3rCNodMoMhFpGLxxOMVZOq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GAlJcapheEZDKdlCUGOFq"},"href":"https://api.spotify.com/v1/albums/5GAlJcapheEZDKdlCUGOFq","id":"5GAlJcapheEZDKdlCUGOFq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f794511b5186f8c3cd56b52a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f794511b5186f8c3cd56b52a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f794511b5186f8c3cd56b52a"}],"is_playable":true,"name":"Haunted Heart: The Legendary Riverside Studio Recordings (Remastered 2025)","release_date":"2025-11-07","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:5GAlJcapheEZDKdlCUGOFq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":324936,"explicit":false,"external_ids":{"isrc":"USC4R2500485"},"external_urls":{"spotify":"https://open.spotify.com/track/16BtcWbLhoAKTJYM7Ig4Tt"},"href":"https://api.spotify.com/v1/tracks/16BtcWbLhoAKTJYM7Ig4Tt","id":"16BtcWbLhoAKTJYM7Ig4Tt","is_local":false,"is_playable":true,"name":"Autumn Leaves - Remastered Mono 2025 / Take 9","track_number":15,"type":"track","uri":"spotify:track:16BtcWbLhoAKTJYM7Ig4Tt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1NLGIv3lw2irzjONDrU28K"},"href":"https://api.spotify.com/v1/albums/1NLGIv3lw2irzjONDrU28K","id":"1NLGIv3lw2irzjONDrU28K","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee141722d2487374664b1f45"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee141722d2487374664b1f45"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee141722d2487374664b1f45"}],"is_playable":true,"name":"Everybody Still Digs Bill Evans","release_date":"2021-06-25","release_date_precision":"day","total_tracks":61,"type":"album","uri":"spotify:album:1NLGIv3lw2irzjONDrU28K"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":359706,"explicit":false,"external_ids":{"isrc":"USC4R2003665"},"external_urls":{"spotify":"https://open.spotify.com/track/1L8kzHRTFE69YQYL7iv9TK"},"href":"https://api.spotify.com/v1/tracks/1L8kzHRTFE69YQYL7iv9TK","id":"1L8kzHRTFE69YQYL7iv9TK","is_local":false,"is_playable":true,"name":"Autumn Leaves","track_number":4,"type":"track","uri":"spotify:track:1L8kzHRTFE69YQYL7iv9TK"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1CjnyyNFm22vUIjRfxT6ex"},"href":"https://api.spotify.com/v1/albums/1CjnyyNFm22vUIjRfxT6ex","id":"1CjnyyNFm22vUIjRfxT6ex","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273439422845abf1fbe5926ea48"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02439422845abf1fbe5926ea48"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851439422845abf1fbe5926ea48"}],"is_playable":true,"name":"Portraits at the Penthouse: Live in Seattle","release_date":"2026-01-16","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1CjnyyNFm22vUIjRfxT6ex"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6HBVTGmPHytchERPb8YGPr"},"href":"https://api.spotify.com/v1/artists/6HBVTGmPHytchERPb8YGPr","id":"6HBVTGmPHytchERPb8YGPr","name":"Eddie G\u00f3mez","type":"artist","uri":"spotify:artist:6HBVTGmPHytchERPb8YGPr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6TsAKBA7qM66xRgpTwKrK8"},"href":"https://api.spotify.com/v1/artists/6TsAKBA7qM66xRgpTwKrK8","id":"6TsAKBA7qM66xRgpTwKrK8","name":"Joe Hunt","type":"artist","uri":"spotify:artist:6TsAKBA7qM66xRgpTwKrK8"}],"disc_number":1,"duration_ms":190516,"explicit":false,"external_ids":{"isrc":"USA2P2547815"},"external_urls":{"spotify":"https://open.spotify.com/track/2CnZG0lYxqvZ00L7VFnJJu"},"href":"https://api.spotify.com/v1/tracks/2CnZG0lYxqvZ00L7VFnJJu","id":"2CnZG0lYxqvZ00L7VFnJJu","is_local":false,"is_playable":true,"name":"Autumn Leaves (Live at the Penthouse in Seattle May 19, 1966)","track_number":10,"type":"track","uri":"spotify:track:2CnZG0lYxqvZ00L7VFnJJu"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Autumn+Leaves%22+artist%3A%22Bill+Evans%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22The%20Girl%20from%20Ipanema%22%20artist%3A%22Stan%20Getz%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":167533,"explicit":false,"external_ids":{"isrc":"USUMG0000425"},"external_urls":{"spotify":"https://open.spotify.com/track/4qGfJb2KByjvzrwo8HNibg"},"href":"https://api.spotify.com/v1/tracks/4qGfJb2KByjvzrwo8HNibg","id":"4qGfJb2KByjvzrwo8HNibg","is_local":false,"is_playable":true,"name":"The Girl From Ipanema - Single Version","track_number":17,"type":"track","uri":"spotify:track:4qGfJb2KByjvzrwo8HNibg"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":320253,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/7znjbX9XdoQayIrVNdd50Z"},"href":"https://api.spotify.com/v1/tracks/7znjbX9XdoQayIrVNdd50Z","id":"7znjbX9XdoQayIrVNdd50Z","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":1,"type":"track","uri":"spotify:track:7znjbX9XdoQayIrVNdd50Z"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4I26wT2bckDbv8Xl5iVInQ"},"href":"https://api.spotify.com/v1/albums/4I26wT2bckDbv8Xl5iVInQ","id":"4I26wT2bckDbv8Xl5iVInQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c21e95926400939bba3c8730"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c21e95926400939bba3c8730"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c21e95926400939bba3c8730"}],"is_playable":true,"name":"The Girl From Ipanema - The Bossa Nova Years","release_date":"1989-01-01","release_date_precision":"day","total_tracks":51,"type":"album","uri":"spotify:album:4I26wT2bckDbv8Xl5iVInQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":3,"duration_ms":321826,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/3898C4AbdbptwYet6547e5"},"href":"https://api.spotify.com/v1/tracks/3898C4AbdbptwYet6547e5","id":"3898C4AbdbptwYet6547e5","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":1,"type":"track","uri":"spotify:track:3898C4AbdbptwYet6547e5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/73ZRKdD3Ds43IjHrhKgucY"},"href":"https://api.spotify.com/v1/albums/73ZRKdD3Ds43IjHrhKgucY","id":"73ZRKdD3Ds43IjHrhKgucY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bbf35173afc8f6ae9041b6c3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bbf35173afc8f6ae9041b6c3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bbf35173afc8f6ae9041b6c3"}],"is_playable":true,"name":"Getz/Gilberto","release_date":"1964-03-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:73ZRKdD3Ds43IjHrhKgucY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":324600,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/0Eir5hEgKUjm8liGGXfghF"},"href":"https://api.spotify.com/v1/tracks/0Eir5hEgKUjm8liGGXfghF","id":"0Eir5hEgKUjm8liGGXfghF","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":1,"type":"track","uri":"spotify:track:0Eir5hEgKUjm8liGGXfghF"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/7lMJv2oB4lCZMXn9kW9mlg"},"href":"https://api.spotify.com/v1/albums/7lMJv2oB4lCZMXn9kW9mlg","id":"7lMJv2oB4lCZMXn9kW9mlg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273207b0e5155c3174aa5d76482"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02207b0e5155c3174aa5d76482"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851207b0e5155c3174aa5d76482"}],"is_playable":true,"name":"Getz For Lovers (Deluxe Edition)","release_date":"2022-02-10","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:7lMJv2oB4lCZMXn9kW9mlg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":322040,"explicit":false,"external_ids":{"isrc":"USF096400700"},"external_urls":{"spotify":"https://open.spotify.com/track/7z3l6quyFofhd78Vx94fi1"},"href":"https://api.spotify.com/v1/tracks/7z3l6quyFofhd78Vx94fi1","id":"7z3l6quyFofhd78Vx94fi1","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":14,"type":"track","uri":"spotify:track:7z3l6quyFofhd78Vx94fi1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4oAW7P6NLMFwb6Y0Q7sxaM"},"href":"https://api.spotify.com/v1/albums/4oAW7P6NLMFwb6Y0Q7sxaM","id":"4oAW7P6NLMFwb6Y0Q7sxaM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273240b34c29882bfc76199b22c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02240b34c29882bfc76199b22c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851240b34c29882bfc76199b22c"}],"is_playable":true,"name":"The Very Best Of Stan Getz","release_date":"2002-03-12","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:4oAW7P6NLMFwb6Y0Q7sxaM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":322973,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/1on3OPqgqXYXfwiA6pYyCk"},"href":"https://api.spotify.com/v1/tracks/1on3OPqgqXYXfwiA6pYyCk","id":"1on3OPqgqXYXfwiA6pYyCk","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":8,"type":"track","uri":"spotify:track:1on3OPqgqXYXfwiA6pYyCk"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dRfiJ2650SZu6GbydcHNb"},"href":"https://api.spotify.com/v1/artists/3dRfiJ2650SZu6GbydcHNb","id":"3dRfiJ2650SZu6GbydcHNb","name":"John Williams","type":"artist","uri":"spotify:artist:3dRfiJ2650SZu6GbydcHNb"}],"external_urls":{"spotify":"https://open.spotify.com/album/0GtsAUyw0cnT1IkSzkOOi6"},"href":"https://api.spotify.com/v1/albums/0GtsAUyw0cnT1IkSzkOOi6","id":"0GtsAUyw0cnT1IkSzkOOi6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27311bf8bab589aeeda37b0ce56"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0211bf8bab589aeeda37b0ce56"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485111bf8bab589aeeda37b0ce56"}],"is_playable":true,"name":"Catch Me If You Can","release_date":"2002-01-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0GtsAUyw0cnT1IkSzkOOi6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":315133,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/4qfQ6OlAbyf4XjE4IOHYgW"},"href":"https://api.spotify.com/v1/tracks/4qfQ6OlAbyf4XjE4IOHYgW","id":"4qfQ6OlAbyf4XjE4IOHYgW","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":6,"type":"track","uri":"spotify:track:4qfQ6OlAbyf4XjE4IOHYgW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4gfH6Bco0I18IEHqXClxdG"},"href":"https://api.spotify.com/v1/albums/4gfH6Bco0I18IEHqXClxdG","id":"4gfH6Bco0I18IEHqXClxdG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27389b6f04a1ebd762788cd3d4f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0289b6f04a1ebd762788cd3d4f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485189b6f04a1ebd762788cd3d4f"}],"is_playable":true,"name":"Getz For Lovers","release_date":"2002-01-14","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4gfH6Bco0I18IEHqXClxdG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":322826,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/2awrRfYfbI8uvHi2yvnT3C"},"href":"https://api.spotify.com/v1/tracks/2awrRfYfbI8uvHi2yvnT3C","id":"2awrRfYfbI8uvHi2yvnT3C","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":14,"type":"track","uri":"spotify:track:2awrRfYfbI8uvHi2yvnT3C"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/0aHK9O3C6xF8oBZhPTD73Z"},"href":"https://api.spotify.com/v1/albums/0aHK9O3C6xF8oBZhPTD73Z","id":"0aHK9O3C6xF8oBZhPTD73Z","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27369365d2a68cac384ad281c41"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0269365d2a68cac384ad281c41"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485169365d2a68cac384ad281c41"}],"is_playable":true,"name":"The Best Of The Verve Years Vol.1","release_date":"1991-12-03","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:0aHK9O3C6xF8oBZhPTD73Z"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":2,"duration_ms":325200,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/6IoJWhjKb9hyf56OMRfMfX"},"href":"https://api.spotify.com/v1/tracks/6IoJWhjKb9hyf56OMRfMfX","id":"6IoJWhjKb9hyf56OMRfMfX","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":8,"type":"track","uri":"spotify:track:6IoJWhjKb9hyf56OMRfMfX"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22The%20Girl%20from%20Ipanema%22%20artist%3A%22Stan%20Getz%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":167533,"explicit":false,"external_ids":{"isrc":"USUMG0000425"},"external_urls":{"spotify":"https://open.spotify.com/track/4qGfJb2KByjvzrwo8HNibg"},"href":"https://api.spotify.com/v1/tracks/4qGfJb2KByjvzrwo8HNibg","id":"4qGfJb2KByjvzrwo8HNibg","is_local":false,"is_playable":true,"name":"The Girl From Ipanema - Single Version","track_number":17,"type":"track","uri":"spotify:track:4qGfJb2KByjvzrwo8HNibg"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":320253,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/7znjbX9XdoQayIrVNdd50Z"},"href":"https://api.spotify.com/v1/tracks/7znjbX9XdoQayIrVNdd50Z","id":"7znjbX9XdoQayIrVNdd50Z","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":1,"type":"track","uri":"spotify:track:7znjbX9XdoQayIrVNdd50Z"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4I26wT2bckDbv8Xl5iVInQ"},"href":"https://api.spotify.com/v1/albums/4I26wT2bckDbv8Xl5iVInQ","id":"4I26wT2bckDbv8Xl5iVInQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c21e95926400939bba3c8730"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c21e95926400939bba3c8730"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c21e95926400939bba3c8730"}],"is_playable":true,"name":"The Girl From Ipanema - The Bossa Nova Years","release_date":"1989-01-01","release_date_precision":"day","total_tracks":51,"type":"album","uri":"spotify:album:4I26wT2bckDbv8Xl5iVInQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":3,"duration_ms":321826,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/3898C4AbdbptwYet6547e5"},"href":"https://api.spotify.com/v1/tracks/3898C4AbdbptwYet6547e5","id":"3898C4AbdbptwYet6547e5","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":1,"type":"track","uri":"spotify:track:3898C4AbdbptwYet6547e5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/73ZRKdD3Ds43IjHrhKgucY"},"href":"https://api.spotify.com/v1/albums/73ZRKdD3Ds43IjHrhKgucY","id":"73ZRKdD3Ds43IjHrhKgucY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bbf35173afc8f6ae9041b6c3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bbf35173afc8f6ae9041b6c3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bbf35173afc8f6ae9041b6c3"}],"is_playable":true,"name":"Getz/Gilberto","release_date":"1964-03-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:73ZRKdD3Ds43IjHrhKgucY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":324600,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/0Eir5hEgKUjm8liGGXfghF"},"href":"https://api.spotify.com/v1/tracks/0Eir5hEgKUjm8liGGXfghF","id":"0Eir5hEgKUjm8liGGXfghF","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":1,"type":"track","uri":"spotify:track:0Eir5hEgKUjm8liGGXfghF"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/7lMJv2oB4lCZMXn9kW9mlg"},"href":"https://api.spotify.com/v1/albums/7lMJv2oB4lCZMXn9kW9mlg","id":"7lMJv2oB4lCZMXn9kW9mlg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273207b0e5155c3174aa5d76482"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02207b0e5155c3174aa5d76482"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851207b0e5155c3174aa5d76482"}],"is_playable":true,"name":"Getz For Lovers (Deluxe Edition)","release_date":"2022-02-10","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:7lMJv2oB4lCZMXn9kW9mlg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":322040,"explicit":false,"external_ids":{"isrc":"USF096400700"},"external_urls":{"spotify":"https://open.spotify.com/track/7z3l6quyFofhd78Vx94fi1"},"href":"https://api.spotify.com/v1/tracks/7z3l6quyFofhd78Vx94fi1","id":"7z3l6quyFofhd78Vx94fi1","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":14,"type":"track","uri":"spotify:track:7z3l6quyFofhd78Vx94fi1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4oAW7P6NLMFwb6Y0Q7sxaM"},"href":"https://api.spotify.com/v1/albums/4oAW7P6NLMFwb6Y0Q7sxaM","id":"4oAW7P6NLMFwb6Y0Q7sxaM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273240b34c29882bfc76199b22c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02240b34c29882bfc76199b22c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851240b34c29882bfc76199b22c"}],"is_playable":true,"name":"The Very Best Of Stan Getz","release_date":"2002-03-12","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:4oAW7P6NLMFwb6Y0Q7sxaM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":322973,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/1on3OPqgqXYXfwiA6pYyCk"},"href":"https://api.spotify.com/v1/tracks/1on3OPqgqXYXfwiA6pYyCk","id":"1on3OPqgqXYXfwiA6pYyCk","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":8,"type":"track","uri":"spotify:track:1on3OPqgqXYXfwiA6pYyCk"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dRfiJ2650SZu6GbydcHNb"},"href":"https://api.spotify.com/v1/artists/3dRfiJ2650SZu6GbydcHNb","id":"3dRfiJ2650SZu6GbydcHNb","name":"John Williams","type":"artist","uri":"spotify:artist:3dRfiJ2650SZu6GbydcHNb"}],"external_urls":{"spotify":"https://open.spotify.com/album/0GtsAUyw0cnT1IkSzkOOi6"},"href":"https://api.spotify.com/v1/albums/0GtsAUyw0cnT1IkSzkOOi6","id":"0GtsAUyw0cnT1IkSzkOOi6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27311bf8bab589aeeda37b0ce56"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0211bf8bab589aeeda37b0ce56"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485111bf8bab589aeeda37b0ce56"}],"is_playable":true,"name":"Catch Me If You Can","release_date":"2002-01-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0GtsAUyw0cnT1IkSzkOOi6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":315133,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/4qfQ6OlAbyf4XjE4IOHYgW"},"href":"https://api.spotify.com/v1/tracks/4qfQ6OlAbyf4XjE4IOHYgW","id":"4qfQ6OlAbyf4XjE4IOHYgW","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":6,"type":"track","uri":"spotify:track:4qfQ6OlAbyf4XjE4IOHYgW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4gfH6Bco0I18IEHqXClxdG"},"href":"https://api.spotify.com/v1/albums/4gfH6Bco0I18IEHqXClxdG","id":"4gfH6Bco0I18IEHqXClxdG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27389b6f04a1ebd762788cd3d4f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0289b6f04a1ebd762788cd3d4f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485189b6f04a1ebd762788cd3d4f"}],"is_playable":true,"name":"Getz For Lovers","release_date":"2002-01-14","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4gfH6Bco0I18IEHqXClxdG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":1,"duration_ms":322826,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/2awrRfYfbI8uvHi2yvnT3C"},"href":"https://api.spotify.com/v1/tracks/2awrRfYfbI8uvHi2yvnT3C","id":"2awrRfYfbI8uvHi2yvnT3C","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":14,"type":"track","uri":"spotify:track:2awrRfYfbI8uvHi2yvnT3C"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/0aHK9O3C6xF8oBZhPTD73Z"},"href":"https://api.spotify.com/v1/albums/0aHK9O3C6xF8oBZhPTD73Z","id":"0aHK9O3C6xF8oBZhPTD73Z","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27369365d2a68cac384ad281c41"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0269365d2a68cac384ad281c41"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485169365d2a68cac384ad281c41"}],"is_playable":true,"name":"The Best Of The Verve Years Vol.1","release_date":"1991-12-03","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:0aHK9O3C6xF8oBZhPTD73Z"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"disc_number":2,"duration_ms":325200,"explicit":false,"external_ids":{"isrc":"USPR36305146"},"external_urls":{"spotify":"https://open.spotify.com/track/6IoJWhjKb9hyf56OMRfMfX"},"href":"https://api.spotify.com/v1/tracks/6IoJWhjKb9hyf56OMRfMfX","id":"6IoJWhjKb9hyf56OMRfMfX","is_local":false,"is_playable":true,"name":"The Girl From Ipanema","track_number":8,"type":"track","uri":"spotify:track:6IoJWhjKb9hyf56OMRfMfX"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22The+Girl+from+Ipanema%22+artist%3A%22Stan+Getz%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Waltz%20for%20Debby%22%20artist%3A%22Bill%20Evans%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/7y2ddYBwV1It5KNemqqQFv"},"href":"https://api.spotify.com/v1/albums/7y2ddYBwV1It5KNemqqQFv","id":"7y2ddYBwV1It5KNemqqQFv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273929f54e5cc041223a098e39e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02929f54e5cc041223a098e39e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851929f54e5cc041223a098e39e"}],"is_playable":true,"name":"New Jazz Conceptions","release_date":"1956","release_date_precision":"year","total_tracks":12,"type":"album","uri":"spotify:album:7y2ddYBwV1It5KNemqqQFv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":78333,"explicit":false,"external_ids":{"isrc":"USFI85700301"},"external_urls":{"spotify":"https://open.spotify.com/track/7bMrdOiYdHjz5dplqSxj8r"},"href":"https://api.spotify.com/v1/tracks/7bMrdOiYdHjz5dplqSxj8r","id":"7bMrdOiYdHjz5dplqSxj8r","is_local":false,"is_playable":true,"name":"Waltz For Debby","track_number":8,"type":"track","uri":"spotify:track:7bMrdOiYdHjz5dplqSxj8r"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/6kaZAT1UBgjchdmNv9hUHj"},"href":"https://api.spotify.com/v1/albums/6kaZAT1UBgjchdmNv9hUHj","id":"6kaZAT1UBgjchdmNv9hUHj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273172f210803d390d6d0dbf8e9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02172f210803d390d6d0dbf8e9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851172f210803d390d6d0dbf8e9"}],"is_playable":true,"name":"At The Village Vanguard","release_date":"1961","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:6kaZAT1UBgjchdmNv9hUHj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":409640,"explicit":false,"external_ids":{"isrc":"USFI86100092"},"external_urls":{"spotify":"https://open.spotify.com/track/6EC51OfUhguCbNp5H5SdGm"},"href":"https://api.spotify.com/v1/tracks/6EC51OfUhguCbNp5H5SdGm","id":"6EC51OfUhguCbNp5H5SdGm","is_local":false,"is_playable":true,"name":"Waltz For Debby - Live At The Village Vanguard, New York / 1961 / Take 2","track_number":9,"type":"track","uri":"spotify:track:6EC51OfUhguCbNp5H5SdGm"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/439SsuO2Esw1G67Xuw1HPS"},"href":"https://api.spotify.com/v1/albums/439SsuO2Esw1G67Xuw1HPS","id":"439SsuO2Esw1G67Xuw1HPS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e74acbf1abfe4389cac16853"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e74acbf1abfe4389cac16853"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e74acbf1abfe4389cac16853"}],"is_playable":true,"name":"Know What I Mean?","release_date":"1961","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:439SsuO2Esw1G67Xuw1HPS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":312426,"explicit":false,"external_ids":{"isrc":"USFI86200299"},"external_urls":{"spotify":"https://open.spotify.com/track/4mH2GwDyurRpDSO9Ks3E6K"},"href":"https://api.spotify.com/v1/tracks/4mH2GwDyurRpDSO9Ks3E6K","id":"4mH2GwDyurRpDSO9Ks3E6K","is_local":false,"is_playable":true,"name":"Waltz For Debby","track_number":1,"type":"track","uri":"spotify:track:4mH2GwDyurRpDSO9Ks3E6K"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/0MjlKhtsyax9HSWNkYaWM2"},"href":"https://api.spotify.com/v1/albums/0MjlKhtsyax9HSWNkYaWM2","id":"0MjlKhtsyax9HSWNkYaWM2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b97f82fd92c92369eafd9a47"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b97f82fd92c92369eafd9a47"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b97f82fd92c92369eafd9a47"}],"is_playable":true,"name":"Waltz For Debby (Original Jazz Classics Remaster 2010)","release_date":"1961","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:0MjlKhtsyax9HSWNkYaWM2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":409760,"explicit":false,"external_ids":{"isrc":"USC4R1016856"},"external_urls":{"spotify":"https://open.spotify.com/track/5cx1qoUiJhVJX4tHUiauNj"},"href":"https://api.spotify.com/v1/tracks/5cx1qoUiJhVJX4tHUiauNj","id":"5cx1qoUiJhVJX4tHUiauNj","is_local":false,"is_playable":true,"name":"Waltz for Debby (take 1) - Alternate Take","track_number":9,"type":"track","uri":"spotify:track:5cx1qoUiJhVJX4tHUiauNj"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/5KMFvQIC2Of0UtJe9w5e0n"},"href":"https://api.spotify.com/v1/albums/5KMFvQIC2Of0UtJe9w5e0n","id":"5KMFvQIC2Of0UtJe9w5e0n","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732002c3ce32dee8c19958fcf4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022002c3ce32dee8c19958fcf4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512002c3ce32dee8c19958fcf4"}],"is_playable":true,"name":"The Bill Evans Album","release_date":"1971","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:5KMFvQIC2Of0UtJe9w5e0n"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":461493,"explicit":false,"external_ids":{"isrc":"USSM17100050"},"external_urls":{"spotify":"https://open.spotify.com/track/1tSzm6vk58gS0NZwYS18W0"},"href":"https://api.spotify.com/v1/tracks/1tSzm6vk58gS0NZwYS18W0","id":"1tSzm6vk58gS0NZwYS18W0","is_local":false,"is_playable":true,"name":"Waltz for Debby","track_number":4,"type":"track","uri":"spotify:track:1tSzm6vk58gS0NZwYS18W0"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/37Aevjp3ZRrGx3rxwpWW5A"},"href":"https://api.spotify.com/v1/albums/37Aevjp3ZRrGx3rxwpWW5A","id":"37Aevjp3ZRrGx3rxwpWW5A","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273800af01bf8b2ced8be5c00d6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02800af01bf8b2ced8be5c00d6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851800af01bf8b2ced8be5c00d6"}],"is_playable":true,"name":"The Best Of Bill Evans","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:37Aevjp3ZRrGx3rxwpWW5A"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":81720,"explicit":false,"external_ids":{"isrc":"USFI85700301"},"external_urls":{"spotify":"https://open.spotify.com/track/7ePWUCoUSviqsKHjcMwnBq"},"href":"https://api.spotify.com/v1/tracks/7ePWUCoUSviqsKHjcMwnBq","id":"7ePWUCoUSviqsKHjcMwnBq","is_local":false,"is_playable":true,"name":"Waltz For Debby","track_number":1,"type":"track","uri":"spotify:track:7ePWUCoUSviqsKHjcMwnBq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/0DtERUqwqrF8lAO3PFzU2H"},"href":"https://api.spotify.com/v1/albums/0DtERUqwqrF8lAO3PFzU2H","id":"0DtERUqwqrF8lAO3PFzU2H","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273717acd746db3d2dc9928781e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02717acd746db3d2dc9928781e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851717acd746db3d2dc9928781e"}],"is_playable":true,"name":"New Jazz Conceptions","release_date":"1956","release_date_precision":"year","total_tracks":12,"type":"album","uri":"spotify:album:0DtERUqwqrF8lAO3PFzU2H"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":78066,"explicit":false,"external_ids":{"isrc":"USFI85700301"},"external_urls":{"spotify":"https://open.spotify.com/track/6wB2oSvNU4hIVFkraC7oIX"},"href":"https://api.spotify.com/v1/tracks/6wB2oSvNU4hIVFkraC7oIX","id":"6wB2oSvNU4hIVFkraC7oIX","is_local":false,"is_playable":true,"name":"Waltz For Debby","track_number":8,"type":"track","uri":"spotify:track:6wB2oSvNU4hIVFkraC7oIX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/3SNo2NOIHpUN6AxIXiaixC"},"href":"https://api.spotify.com/v1/albums/3SNo2NOIHpUN6AxIXiaixC","id":"3SNo2NOIHpUN6AxIXiaixC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731eeff2d8424b8f804f0b539d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021eeff2d8424b8f804f0b539d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511eeff2d8424b8f804f0b539d"}],"is_playable":true,"name":"Waltz For Debby","release_date":"1961","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:3SNo2NOIHpUN6AxIXiaixC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":416000,"explicit":false,"external_ids":{"isrc":"USFI86100092"},"external_urls":{"spotify":"https://open.spotify.com/track/4ZMIYuiM4UlVRePiGIlgXT"},"href":"https://api.spotify.com/v1/tracks/4ZMIYuiM4UlVRePiGIlgXT","id":"4ZMIYuiM4UlVRePiGIlgXT","is_local":false,"is_playable":true,"name":"Waltz For Debby - Live At The Village Vanguard, New York / 1961 / Take 2","track_number":2,"type":"track","uri":"spotify:track:4ZMIYuiM4UlVRePiGIlgXT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Thtq5sXXzQb41zCl5FZVQ"},"href":"https://api.spotify.com/v1/albums/6Thtq5sXXzQb41zCl5FZVQ","id":"6Thtq5sXXzQb41zCl5FZVQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27316bc3eecbbe30ae8744237e2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0216bc3eecbbe30ae8744237e2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485116bc3eecbbe30ae8744237e2"}],"is_playable":true,"name":"You're Gonna Hear From Me","release_date":"1988-01-01","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:6Thtq5sXXzQb41zCl5FZVQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":330373,"explicit":false,"external_ids":{"isrc":"USFI88800199"},"external_urls":{"spotify":"https://open.spotify.com/track/2FGnyW1cZ8BsvBnybwjpAY"},"href":"https://api.spotify.com/v1/tracks/2FGnyW1cZ8BsvBnybwjpAY","id":"2FGnyW1cZ8BsvBnybwjpAY","is_local":false,"is_playable":true,"name":"Waltz For Debby","track_number":3,"type":"track","uri":"spotify:track:2FGnyW1cZ8BsvBnybwjpAY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/3SNo2NOIHpUN6AxIXiaixC"},"href":"https://api.spotify.com/v1/albums/3SNo2NOIHpUN6AxIXiaixC","id":"3SNo2NOIHpUN6AxIXiaixC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731eeff2d8424b8f804f0b539d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021eeff2d8424b8f804f0b539d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511eeff2d8424b8f804f0b539d"}],"is_playable":true,"name":"Waltz For Debby","release_date":"1961","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:3SNo2NOIHpUN6AxIXiaixC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":410093,"explicit":false,"external_ids":{"isrc":"USFI88400001"},"external_urls":{"spotify":"https://open.spotify.com/track/75BIMWSUSmDuL45C40QmQr"},"href":"https://api.spotify.com/v1/tracks/75BIMWSUSmDuL45C40QmQr","id":"75BIMWSUSmDuL45C40QmQr","is_local":false,"is_playable":true,"name":"Waltz For Debby - Live / Take 1","track_number":3,"type":"track","uri":"spotify:track:75BIMWSUSmDuL45C40QmQr"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhbHR6JTIwZm9yJTIwRGViYnklMjIlMjBhcnRpc3QlM0ElMjJCaWxsJTIwRXZhbnMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRqWGZGemVQNjZaeTY3SE0ybXZJSUYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsImlkIjoiNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsIm5hbWUiOiJCaWxsIEV2YW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRqWGZGemVQNjZaeTY3SE0ybXZJSUYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83eTJkZFlCd1YxSXQ1S05lbXFxUUZ2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3kyZGRZQndWMUl0NUtOZW1xcVFGdiIsImlkIjoiN3kyZGRZQndWMUl0NUtOZW1xcVFGdiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5z", + "Y2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5MjlmNTRlNWNjMDQxMjIzYTA5OGUzOWUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTI5ZjU0ZTVjYzA0MTIyM2EwOThlMzllIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5MjlmNTRlNWNjMDQxMjIzYTA5OGUzOWUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmV3IEphenogQ29uY2VwdGlvbnMiLCJyZWxlYXNlX2RhdGUiOiIxOTU2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjd5MmRkWUJ3VjFJdDVLTmVtcXFRRnYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80alhmRnplUDY2Wnk2N0hNMm12SUlGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJpZCI6IjRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJuYW1lIjoiQmlsbCBFdmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0alhmRnplUDY2Wnk2N0hNMm12SUlGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjc4MzMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNGSTg1NzAwMzAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83Yk1yZE9pWWRIano1ZHBscVN4ajhyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2JNcmRPaVlkSGp6NWRwbHFTeGo4ciIsImlkIjoiN2JNcmRPaVlkSGp6NWRwbHFTeGo4ciIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWx0eiBGb3IgRGViYnkiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2JNcmRPaVlkSGp6NWRwbHFTeGo4ciJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVkVHNmd4RklNZmw0Q2RvZzI2YXZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJpZCI6IjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJuYW1lIjoiQmlsbCBFdmFucyBUcmlvIiwidA==", + "eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1ZFRzZneEZJTWZsNENkb2cyNmF2UyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZrYVpBVDFVQmdqY2hkbU52OWhVSGoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82a2FaQVQxVUJnamNoZG1OdjloVUhqIiwiaWQiOiI2a2FaQVQxVUJnamNoZG1OdjloVUhqIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE3MmYyMTA4MDNkMzkwZDZkMGRiZjhlOSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNzJmMjEwODAzZDM5MGQ2ZDBkYmY4ZTkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE3MmYyMTA4MDNkMzkwZDZkMGRiZjhlOSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBdCBUaGUgVmlsbGFnZSBWYW5ndWFyZCIsInJlbGVhc2VfZGF0ZSI6IjE5NjEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NmthWkFUMVVCZ2pjaGRtTnY5aFVIaiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM1ZFRzZneEZJTWZsNENkb2cyNmF2UyIsImlkIjoiM1ZFRzZneEZJTWZsNENkb2cyNmF2UyIsIm5hbWUiOiJCaWxsIEV2YW5zIFRyaW8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1ZFRzZneEZJTWZsNENkb2cyNmF2UyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MDk2NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0ZJODYxMDAwOTIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZFQzUxT2ZVaGd1Q2JOcDVINVNkR20ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82RUM1MU9mVWhndUNiTnA1SDVTZEdtIiwiaWQiOiI2RUM1MU9mVWhndUNiTnA1SDVTZEdtIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhbHR6IEZvciBEZWJieSAtIExpdmUgQXQgVGhlIFZpbGxhZ2UgVmFuZw==", + "dWFyZCwgTmV3IFlvcmsgLyAxOTYxIC8gVGFrZSAyIiwidHJhY2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZFQzUxT2ZVaGd1Q2JOcDVINVNkR20ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXY3NG1UMTFLR0pxYWRmOXNMdzRkQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81djc0bVQxMUtHSnFhZGY5c0x3NGRBIiwiaWQiOiI1djc0bVQxMUtHSnFhZGY5c0x3NGRBIiwibmFtZSI6IkNhbm5vbmJhbGwgQWRkZXJsZXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXY3NG1UMTFLR0pxYWRmOXNMdzRkQSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80alhmRnplUDY2Wnk2N0hNMm12SUlGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJpZCI6IjRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJuYW1lIjoiQmlsbCBFdmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0alhmRnplUDY2Wnk2N0hNMm12SUlGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNDM5U3N1TzJFc3cxRzY3WHV3MUhQUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzQzOVNzdU8yRXN3MUc2N1h1dzFIUFMiLCJpZCI6IjQzOVNzdU8yRXN3MUc2N1h1dzFIUFMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZTc0YWNiZjFhYmZlNDM4OWNhYzE2ODUzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmU3NGFjYmYxYWJmZTQzODljYWMxNjg1MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZTc0YWNiZjFhYmZlNDM4OWNhYzE2ODUzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Iktub3cgV2hhdCBJIE1lYW4/IiwicmVsZWFzZV9kYXRlIjoiMTk2MSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0MzlTc3VPMkVzdzFHNjdYdXcxSFBTIn0sImFydGlzdHMiOlt7ImV4dA==", + "ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81djc0bVQxMUtHSnFhZGY5c0x3NGRBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV2NzRtVDExS0dKcWFkZjlzTHc0ZEEiLCJpZCI6IjV2NzRtVDExS0dKcWFkZjlzTHc0ZEEiLCJuYW1lIjoiQ2Fubm9uYmFsbCBBZGRlcmxleSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1djc0bVQxMUtHSnFhZGY5c0x3NGRBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRqWGZGemVQNjZaeTY3SE0ybXZJSUYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsImlkIjoiNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsIm5hbWUiOiJCaWxsIEV2YW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRqWGZGemVQNjZaeTY3SE0ybXZJSUYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzEyNDI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNGSTg2MjAwMjk5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80bUgyR3dEeXVyUnBEU085S3MzRTZLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNG1IMkd3RHl1clJwRFNPOUtzM0U2SyIsImlkIjoiNG1IMkd3RHl1clJwRFNPOUtzM0U2SyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWx0eiBGb3IgRGViYnkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NG1IMkd3RHl1clJwRFNPOUtzM0U2SyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVkVHNmd4RklNZmw0Q2RvZzI2YXZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJpZCI6IjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJuYW1lIjoiQmlsbCBFdmFucyBUcmlvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wTWpsS2h0c3lheDlIU1dOa1lhV00yIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbQ==", + "L3YxL2FsYnVtcy8wTWpsS2h0c3lheDlIU1dOa1lhV00yIiwiaWQiOiIwTWpsS2h0c3lheDlIU1dOa1lhV00yIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I5N2Y4MmZkOTJjOTIzNjllYWZkOWE0NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiOTdmODJmZDkyYzkyMzY5ZWFmZDlhNDcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI5N2Y4MmZkOTJjOTIzNjllYWZkOWE0NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWx0eiBGb3IgRGViYnkgKE9yaWdpbmFsIEphenogQ2xhc3NpY3MgUmVtYXN0ZXIgMjAxMCkiLCJyZWxlYXNlX2RhdGUiOiIxOTYxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBNamxLaHRzeWF4OUhTV05rWWFXTTIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVkVHNmd4RklNZmw0Q2RvZzI2YXZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJpZCI6IjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJuYW1lIjoiQmlsbCBFdmFucyBUcmlvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDA5NzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNDNFIxMDE2ODU2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81Y3gxcW9VaUpoVkpYNHRIVWlhdU5qIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNWN4MXFvVWlKaFZKWDR0SFVpYXVOaiIsImlkIjoiNWN4MXFvVWlKaFZKWDR0SFVpYXVOaiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWx0eiBmb3IgRGViYnkgKHRha2UgMSkgLSBBbHRlcm5hdGUgVGFrZSIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1Y3gxcW9VaUpoVkpYNHRIVWlhdU5qIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZg==", + "eSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80alhmRnplUDY2Wnk2N0hNMm12SUlGIiwiaWQiOiI0alhmRnplUDY2Wnk2N0hNMm12SUlGIiwibmFtZSI6IkJpbGwgRXZhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVLTUZ2UUlDMk9mMFV0SmU5dzVlMG4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81S01GdlFJQzJPZjBVdEplOXc1ZTBuIiwiaWQiOiI1S01GdlFJQzJPZjBVdEplOXc1ZTBuIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzIwMDJjM2NlMzJkZWU4YzE5OTU4ZmNmNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyMDAyYzNjZTMyZGVlOGMxOTk1OGZjZjQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTIwMDJjM2NlMzJkZWU4YzE5OTU4ZmNmNCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgQmlsbCBFdmFucyBBbGJ1bSIsInJlbGVhc2VfZGF0ZSI6IjE5NzEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUtNRnZRSUMyT2YwVXRKZTl3NWUwbiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRqWGZGemVQNjZaeTY3SE0ybXZJSUYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsImlkIjoiNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsIm5hbWUiOiJCaWxsIEV2YW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRqWGZGemVQNjZaeTY3SE0ybXZJSUYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDYxNDkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTE3MTAwMDUwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xdFN6bTZ2azU4Z1MwTlp3WVMxOFcwIn0sImhyZWYiOiJodA==", + "dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xdFN6bTZ2azU4Z1MwTlp3WVMxOFcwIiwiaWQiOiIxdFN6bTZ2azU4Z1MwTlp3WVMxOFcwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhbHR6IGZvciBEZWJieSIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxdFN6bTZ2azU4Z1MwTlp3WVMxOFcwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRqWGZGemVQNjZaeTY3SE0ybXZJSUYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsImlkIjoiNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsIm5hbWUiOiJCaWxsIEV2YW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRqWGZGemVQNjZaeTY3SE0ybXZJSUYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zN0FldmpwM1pSckd4M3J4d3BXVzVBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMzdBZXZqcDNaUnJHeDNyeHdwV1c1QSIsImlkIjoiMzdBZXZqcDNaUnJHeDNyeHdwV1c1QSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4MDBhZjAxYmY4YjJjZWQ4YmU1YzAwZDYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODAwYWYwMWJmOGIyY2VkOGJlNWMwMGQ2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4MDBhZjAxYmY4YjJjZWQ4YmU1YzAwZDYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEJlc3QgT2YgQmlsbCBFdmFucyIsInJlbGVhc2VfZGF0ZSI6IjIwMDQtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozN0FldmpwM1pSckd4M3J4d3BXVzVBIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80alhmRnplUDY2Wnk2N0hNMm12SQ==", + "SUYiLCJpZCI6IjRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJuYW1lIjoiQmlsbCBFdmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0alhmRnplUDY2Wnk2N0hNMm12SUlGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjgxNzIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNGSTg1NzAwMzAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83ZVBXVUNvVVN2aXFzS0hqY013bkJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2VQV1VDb1VTdmlxc0tIamNNd25CcSIsImlkIjoiN2VQV1VDb1VTdmlxc0tIamNNd25CcSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWx0eiBGb3IgRGViYnkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2VQV1VDb1VTdmlxc0tIamNNd25CcSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80alhmRnplUDY2Wnk2N0hNMm12SUlGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJpZCI6IjRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJuYW1lIjoiQmlsbCBFdmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0alhmRnplUDY2Wnk2N0hNMm12SUlGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMER0RVJVcXdxckY4bEFPM1BGelUySCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBEdEVSVXF3cXJGOGxBTzNQRnpVMkgiLCJpZCI6IjBEdEVSVXF3cXJGOGxBTzNQRnpVMkgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzE3YWNkNzQ2ZGIzZDJkYzk5Mjg3ODFlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjcxN2FjZDc0NmRiM2QyZGM5OTI4NzgxZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzE3YWNkNzQ2ZGIzZDJkYzk5Mjg3ODFlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5ldyBKYXp6IENvbmNlcHRpb25zIiwicg==", + "ZWxlYXNlX2RhdGUiOiIxOTU2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBEdEVSVXF3cXJGOGxBTzNQRnpVMkgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80alhmRnplUDY2Wnk2N0hNMm12SUlGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJpZCI6IjRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJuYW1lIjoiQmlsbCBFdmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0alhmRnplUDY2Wnk2N0hNMm12SUlGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjc4MDY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNGSTg1NzAwMzAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82d0Iyb1N2TlU0aElWRmtyYUM3b0lYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNndCMm9Tdk5VNGhJVkZrcmFDN29JWCIsImlkIjoiNndCMm9Tdk5VNGhJVkZrcmFDN29JWCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWx0eiBGb3IgRGViYnkiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NndCMm9Tdk5VNGhJVkZrcmFDN29JWCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVkVHNmd4RklNZmw0Q2RvZzI2YXZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJpZCI6IjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJuYW1lIjoiQmlsbCBFdmFucyBUcmlvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zU05vMk5PSUhwVU42QXhJWGlhaXhDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM1NObzJOT0lIcFVONkF4SVhpYWl4QyIsImlkIjoiM1NObzJOT0lIcFVONkF4SVhpYWl4QyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYQ==", + "Z2UvYWI2NzYxNmQwMDAwYjI3MzFlZWZmMmQ4NDI0YjhmODA0ZjBiNTM5ZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxZWVmZjJkODQyNGI4ZjgwNGYwYjUzOWQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTFlZWZmMmQ4NDI0YjhmODA0ZjBiNTM5ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWx0eiBGb3IgRGViYnkiLCJyZWxlYXNlX2RhdGUiOiIxOTYxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNTTm8yTk9JSHBVTjZBeElYaWFpeEMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVkVHNmd4RklNZmw0Q2RvZzI2YXZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJpZCI6IjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJuYW1lIjoiQmlsbCBFdmFucyBUcmlvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDE2MDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNGSTg2MTAwMDkyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80Wk1JWXVpTTRVbFZSZVBpR0lsZ1hUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNFpNSVl1aU00VWxWUmVQaUdJbGdYVCIsImlkIjoiNFpNSVl1aU00VWxWUmVQaUdJbGdYVCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWx0eiBGb3IgRGViYnkgLSBMaXZlIEF0IFRoZSBWaWxsYWdlIFZhbmd1YXJkLCBOZXcgWW9yayAvIDE5NjEgLyBUYWtlIDIiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFpNSVl1aU00VWxWUmVQaUdJbGdYVCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80alhmRnplUDY2Wnk2N0hNMm12SUlGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJpZCI6IjRqWA==", + "ZkZ6ZVA2Nlp5NjdITTJtdklJRiIsIm5hbWUiOiJCaWxsIEV2YW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRqWGZGemVQNjZaeTY3SE0ybXZJSUYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82VGh0cTVzWFh6UWI0MXpDbDVGWlZRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNlRodHE1c1hYelFiNDF6Q2w1RlpWUSIsImlkIjoiNlRodHE1c1hYelFiNDF6Q2w1RlpWUSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNmJjM2VlY2JiZTMwYWU4NzQ0MjM3ZTIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTZiYzNlZWNiYmUzMGFlODc0NDIzN2UyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExNmJjM2VlY2JiZTMwYWU4NzQ0MjM3ZTIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWW91J3JlIEdvbm5hIEhlYXIgRnJvbSBNZSIsInJlbGVhc2VfZGF0ZSI6IjE5ODgtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZUaHRxNXNYWHpRYjQxekNsNUZaVlEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80alhmRnplUDY2Wnk2N0hNMm12SUlGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJpZCI6IjRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJuYW1lIjoiQmlsbCBFdmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0alhmRnplUDY2Wnk2N0hNMm12SUlGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMzMDM3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRkk4ODgwMDE5OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMkZHbnlXMWNaOEJzdkJueWJ3anBBWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJGR255VzFjWjhCc3ZCbnlid2pwQVkiLCJpZCI6IjJGR255VzFjWjhCc3ZCbnlid2pwQVkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIg==", + "OiJXYWx0eiBGb3IgRGViYnkiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MkZHbnlXMWNaOEJzdkJueWJ3anBBWSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVkVHNmd4RklNZmw0Q2RvZzI2YXZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJpZCI6IjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMiLCJuYW1lIjoiQmlsbCBFdmFucyBUcmlvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNWRUc2Z3hGSU1mbDRDZG9nMjZhdlMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zU05vMk5PSUhwVU42QXhJWGlhaXhDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM1NObzJOT0lIcFVONkF4SVhpYWl4QyIsImlkIjoiM1NObzJOT0lIcFVONkF4SVhpYWl4QyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxZWVmZjJkODQyNGI4ZjgwNGYwYjUzOWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWVlZmYyZDg0MjRiOGY4MDRmMGI1MzlkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExZWVmZjJkODQyNGI4ZjgwNGYwYjUzOWQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2FsdHogRm9yIERlYmJ5IiwicmVsZWFzZV9kYXRlIjoiMTk2MSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozU05vMk5PSUhwVU42QXhJWGlhaXhDIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1ZFRzZneEZJTWZsNENkb2cyNmF2UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zVkVHNmd4RklNZmw0Q2RvZzI2YXZTIiwiaWQiOiIzVkVHNmd4RklNZmw0Q2RvZzI2YXZTIiwibmFtZSI6IkJpbGwgRXZhbnMgVHJpbyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozVkVHNmd4RklNZmw0Q2RvZzI2YXZTIn1dLCJkaXNjX251bWJlciI6MSwiZA==", + "dXJhdGlvbl9tcyI6NDEwMDkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNGSTg4NDAwMDAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83NUJJTVdTVVNtRHVMNDVDNDBRbVFyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNzVCSU1XU1VTbUR1TDQ1QzQwUW1RciIsImlkIjoiNzVCSU1XU1VTbUR1TDQ1QzQwUW1RciIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWx0eiBGb3IgRGViYnkgLSBMaXZlIC8gVGFrZSAxIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjc1QklNV1NVU21EdUw0NUM0MFFtUXIifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Waltz+for+Debby%22+artist%3A%22Bill+Evans%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Blue%20in%20Green%22%20artist%3A%22Miles%20Davis%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4sb0eMpDn3upAFfyi4q2rw"},"href":"https://api.spotify.com/v1/albums/4sb0eMpDn3upAFfyi4q2rw","id":"4sb0eMpDn3upAFfyi4q2rw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730ebc17239b6b18ba88cfb8ca"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020ebc17239b6b18ba88cfb8ca"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510ebc17239b6b18ba88cfb8ca"}],"is_playable":true,"name":"Kind Of Blue (Legacy Edition)","release_date":"1959-08-17","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4sb0eMpDn3upAFfyi4q2rw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":337733,"explicit":false,"external_ids":{"isrc":"USSM15900115"},"external_urls":{"spotify":"https://open.spotify.com/track/0aWMVrwxPNYkKmFthzmpRi"},"href":"https://api.spotify.com/v1/tracks/0aWMVrwxPNYkKmFthzmpRi","id":"0aWMVrwxPNYkKmFthzmpRi","is_local":false,"is_playable":true,"name":"Blue in Green (feat. John Coltrane & Bill Evans)","track_number":3,"type":"track","uri":"spotify:track:0aWMVrwxPNYkKmFthzmpRi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/1weenld61qoidwYuZ1GESA"},"href":"https://api.spotify.com/v1/albums/1weenld61qoidwYuZ1GESA","id":"1weenld61qoidwYuZ1GESA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273387a29c90de3b2398c29c34f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02387a29c90de3b2398c29c34f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851387a29c90de3b2398c29c34f"}],"is_playable":true,"name":"Kind Of Blue","release_date":"1959-08-17","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:1weenld61qoidwYuZ1GESA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":335938,"explicit":false,"external_ids":{"isrc":"USSM15900115"},"external_urls":{"spotify":"https://open.spotify.com/track/6bP4GyrKNbcKPMDqWJqpxI"},"href":"https://api.spotify.com/v1/tracks/6bP4GyrKNbcKPMDqWJqpxI","id":"6bP4GyrKNbcKPMDqWJqpxI","is_local":false,"is_playable":true,"name":"Blue in Green (feat. John Coltrane & Bill Evans)","track_number":3,"type":"track","uri":"spotify:track:6bP4GyrKNbcKPMDqWJqpxI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/3GA7ZC3j2tp43UAuMvSArL"},"href":"https://api.spotify.com/v1/albums/3GA7ZC3j2tp43UAuMvSArL","id":"3GA7ZC3j2tp43UAuMvSArL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27327d69f712d76ce6ab427acaa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0227d69f712d76ce6ab427acaa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485127d69f712d76ce6ab427acaa"}],"is_playable":true,"name":"Sunday in Spring","release_date":"2010-02-10","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:3GA7ZC3j2tp43UAuMvSArL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":2,"duration_ms":336786,"explicit":false,"external_ids":{"isrc":"FRZ335801090"},"external_urls":{"spotify":"https://open.spotify.com/track/3tlQzZfXef3jQX51QlnO6W"},"href":"https://api.spotify.com/v1/tracks/3tlQzZfXef3jQX51QlnO6W","id":"3tlQzZfXef3jQX51QlnO6W","is_local":false,"is_playable":true,"name":"Blue In Green","track_number":9,"type":"track","uri":"spotify:track:3tlQzZfXef3jQX51QlnO6W"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dgvus7LDXgBw4eji4gsRQ"},"href":"https://api.spotify.com/v1/artists/3dgvus7LDXgBw4eji4gsRQ","id":"3dgvus7LDXgBw4eji4gsRQ","name":"Miles Davis","type":"artist","uri":"spotify:artist:3dgvus7LDXgBw4eji4gsRQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/6VsC6NfnHUFMbsE8NigOaz"},"href":"https://api.spotify.com/v1/albums/6VsC6NfnHUFMbsE8NigOaz","id":"6VsC6NfnHUFMbsE8NigOaz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a0530dfc25467ae9b3560237"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a0530dfc25467ae9b3560237"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a0530dfc25467ae9b3560237"}],"is_playable":true,"name":"Miles in the Movies","release_date":"2010-06-14","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:6VsC6NfnHUFMbsE8NigOaz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dgvus7LDXgBw4eji4gsRQ"},"href":"https://api.spotify.com/v1/artists/3dgvus7LDXgBw4eji4gsRQ","id":"3dgvus7LDXgBw4eji4gsRQ","name":"Miles Davis","type":"artist","uri":"spotify:artist:3dgvus7LDXgBw4eji4gsRQ"}],"disc_number":1,"duration_ms":337266,"explicit":false,"external_ids":{"isrc":"GBBLY1003932"},"external_urls":{"spotify":"https://open.spotify.com/track/0CYXM5UOz5Ywe4eZvCVNxt"},"href":"https://api.spotify.com/v1/tracks/0CYXM5UOz5Ywe4eZvCVNxt","id":"0CYXM5UOz5Ywe4eZvCVNxt","is_local":false,"is_playable":true,"name":"Blue in Green","track_number":14,"type":"track","uri":"spotify:track:0CYXM5UOz5Ywe4eZvCVNxt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4sb0eMpDn3upAFfyi4q2rw"},"href":"https://api.spotify.com/v1/albums/4sb0eMpDn3upAFfyi4q2rw","id":"4sb0eMpDn3upAFfyi4q2rw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730ebc17239b6b18ba88cfb8ca"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020ebc17239b6b18ba88cfb8ca"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510ebc17239b6b18ba88cfb8ca"}],"is_playable":true,"name":"Kind Of Blue (Legacy Edition)","release_date":"1959-08-17","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4sb0eMpDn3upAFfyi4q2rw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":116906,"explicit":false,"external_ids":{"isrc":"USSM10802766"},"external_urls":{"spotify":"https://open.spotify.com/track/4S0JzmCCQjaRjbPfIF6JV1"},"href":"https://api.spotify.com/v1/tracks/4S0JzmCCQjaRjbPfIF6JV1","id":"4S0JzmCCQjaRjbPfIF6JV1","is_local":false,"is_playable":true,"name":"Blue in Green - Studio Sequence","track_number":12,"type":"track","uri":"spotify:track:4S0JzmCCQjaRjbPfIF6JV1"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1FayrEV2WYTH8tzkxkWZzP"},"href":"https://api.spotify.com/v1/artists/1FayrEV2WYTH8tzkxkWZzP","id":"1FayrEV2WYTH8tzkxkWZzP","name":"Fuse","type":"artist","uri":"spotify:artist:1FayrEV2WYTH8tzkxkWZzP"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GfooGhPu8EQfw20L0MM6C"},"href":"https://api.spotify.com/v1/albums/5GfooGhPu8EQfw20L0MM6C","id":"5GfooGhPu8EQfw20L0MM6C","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376df16a911775588f94bacb7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276df16a911775588f94bacb7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176df16a911775588f94bacb7"}],"is_playable":true,"name":"Studio 3","release_date":"2020-11-27","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5GfooGhPu8EQfw20L0MM6C"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1FayrEV2WYTH8tzkxkWZzP"},"href":"https://api.spotify.com/v1/artists/1FayrEV2WYTH8tzkxkWZzP","id":"1FayrEV2WYTH8tzkxkWZzP","name":"Fuse","type":"artist","uri":"spotify:artist:1FayrEV2WYTH8tzkxkWZzP"}],"disc_number":1,"duration_ms":349879,"explicit":false,"external_ids":{"isrc":"NLM9R2000003"},"external_urls":{"spotify":"https://open.spotify.com/track/0zIRPgQetYLhILnoMpBPfh"},"href":"https://api.spotify.com/v1/tracks/0zIRPgQetYLhILnoMpBPfh","id":"0zIRPgQetYLhILnoMpBPfh","is_local":false,"is_playable":true,"name":"Blue in Green","track_number":3,"type":"track","uri":"spotify:track:0zIRPgQetYLhILnoMpBPfh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4s1vbvX3vZsjAqhDVxv8tE"},"href":"https://api.spotify.com/v1/albums/4s1vbvX3vZsjAqhDVxv8tE","id":"4s1vbvX3vZsjAqhDVxv8tE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27353916cd700eef7318d795479"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0253916cd700eef7318d795479"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485153916cd700eef7318d795479"}],"is_playable":true,"name":"The Jazz Masters - 27 Classic Performances From The Columbia Masterpieces Series","release_date":"1989-03-28","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:4s1vbvX3vZsjAqhDVxv8tE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":324160,"explicit":false,"external_ids":{"isrc":"USSM10028181"},"external_urls":{"spotify":"https://open.spotify.com/track/5o6PkOAAwHvdkkOBGPxi20"},"href":"https://api.spotify.com/v1/tracks/5o6PkOAAwHvdkkOBGPxi20","id":"5o6PkOAAwHvdkkOBGPxi20","is_local":false,"is_playable":true,"name":"Blue In Green","track_number":7,"type":"track","uri":"spotify:track:5o6PkOAAwHvdkkOBGPxi20"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2lf1NQPFMIpS2wOOeCoFHy"},"href":"https://api.spotify.com/v1/albums/2lf1NQPFMIpS2wOOeCoFHy","id":"2lf1NQPFMIpS2wOOeCoFHy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f7375d5f3612a80eaba57210"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f7375d5f3612a80eaba57210"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f7375d5f3612a80eaba57210"}],"is_playable":true,"name":"Jazz Legends: Saxophone","release_date":"2003-03-27","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:2lf1NQPFMIpS2wOOeCoFHy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":335293,"explicit":false,"external_ids":{"isrc":"USSM15900115"},"external_urls":{"spotify":"https://open.spotify.com/track/5n5xLwT3ZbXzLoIcRd3Ggn"},"href":"https://api.spotify.com/v1/tracks/5n5xLwT3ZbXzLoIcRd3Ggn","id":"5n5xLwT3ZbXzLoIcRd3Ggn","is_local":false,"is_playable":true,"name":"Blue in Green (feat. John Coltrane & Bill Evans)","track_number":3,"type":"track","uri":"spotify:track:5n5xLwT3ZbXzLoIcRd3Ggn"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/77TvtJAiUlwM8q4r7VneKL"},"href":"https://api.spotify.com/v1/albums/77TvtJAiUlwM8q4r7VneKL","id":"77TvtJAiUlwM8q4r7VneKL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273af7661fa42b9426dddb7f82b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02af7661fa42b9426dddb7f82b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851af7661fa42b9426dddb7f82b"}],"is_playable":true,"name":"Pure... Chillout","release_date":"2011-06-06","release_date_precision":"day","total_tracks":68,"type":"album","uri":"spotify:album:77TvtJAiUlwM8q4r7VneKL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":4,"duration_ms":334320,"explicit":false,"external_ids":{"isrc":"USSM15901177"},"external_urls":{"spotify":"https://open.spotify.com/track/06ObzeUnB2vr3XlxEB5kLR"},"href":"https://api.spotify.com/v1/tracks/06ObzeUnB2vr3XlxEB5kLR","id":"06ObzeUnB2vr3XlxEB5kLR","is_local":false,"is_playable":true,"name":"Blue In Green","track_number":2,"type":"track","uri":"spotify:track:06ObzeUnB2vr3XlxEB5kLR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/1sR0Ymo55UT2tkcOn05Qur"},"href":"https://api.spotify.com/v1/albums/1sR0Ymo55UT2tkcOn05Qur","id":"1sR0Ymo55UT2tkcOn05Qur","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27348713eebe44a437d9cb7a452"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0248713eebe44a437d9cb7a452"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485148713eebe44a437d9cb7a452"}],"is_playable":true,"name":"The Complete Miles Davis Featuring John Coltrane","release_date":"1959-08-18","release_date_precision":"day","total_tracks":58,"type":"album","uri":"spotify:album:1sR0Ymo55UT2tkcOn05Qur"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":4,"duration_ms":334226,"explicit":false,"external_ids":{"isrc":"USSM15901177"},"external_urls":{"spotify":"https://open.spotify.com/track/62M7rdje0DMGlSN0oCGz6k"},"href":"https://api.spotify.com/v1/tracks/62M7rdje0DMGlSN0oCGz6k","id":"62M7rdje0DMGlSN0oCGz6k","is_local":false,"is_playable":true,"name":"Blue In Green","track_number":5,"type":"track","uri":"spotify:track:62M7rdje0DMGlSN0oCGz6k"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJsdWUlMjBpbiUyMEdyZWVuJTIyJTIwYXJ0aXN0JTNBJTIyTWlsZXMlMjBEYXZpcyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGtiWVROUWI0UGIxclBiYmFGMHBUNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwiaWQiOiIwa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwibmFtZSI6Ik1pbGVzIERhdmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBrYllUTlFiNFBiMXJQYmJhRjBwVDQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80c2IwZU1wRG4zdXBBRmZ5aTRxMnJ3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHNiMGVNcERuM3VwQUZmeWk0cTJydyIsImlkIjoiNHNiMGVNcERuM3VwQUZmeWk0cTJydyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5z", + "Y2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZWJjMTcyMzliNmIxOGJhODhjZmI4Y2EifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGViYzE3MjM5YjZiMThiYTg4Y2ZiOGNhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwZWJjMTcyMzliNmIxOGJhODhjZmI4Y2EifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS2luZCBPZiBCbHVlIChMZWdhY3kgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIxOTU5LTA4LTE3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NHNiMGVNcERuM3VwQUZmeWk0cTJydyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBrYllUTlFiNFBiMXJQYmJhRjBwVDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsImlkIjoiMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsIm5hbWUiOiJNaWxlcyBEYXZpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa2JZVE5RYjRQYjFyUGJiYUYwcFQ0In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsImlkIjoiMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsIm5hbWUiOiJKb2huIENvbHRyYW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80alhmRnplUDY2Wnk2N0hNMm12SUlGIiwiaWQiOiI0alhmRnplUDY2Wnk2N0hNMm12SUlGIiwibmFtZSI6IkJpbGwgRXZhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMzc3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTU5MDAxMTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcA==", + "b3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMGFXTVZyd3hQTllrS21GdGh6bXBSaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBhV01Wcnd4UE5Za0ttRnRoem1wUmkiLCJpZCI6IjBhV01Wcnd4UE5Za0ttRnRoem1wUmkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmx1ZSBpbiBHcmVlbiAoZmVhdC4gSm9obiBDb2x0cmFuZSAmIEJpbGwgRXZhbnMpIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBhV01Wcnd4UE5Za0ttRnRoem1wUmkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGtiWVROUWI0UGIxclBiYmFGMHBUNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwiaWQiOiIwa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwibmFtZSI6Ik1pbGVzIERhdmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBrYllUTlFiNFBiMXJQYmJhRjBwVDQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xd2VlbmxkNjFxb2lkd1l1WjFHRVNBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMXdlZW5sZDYxcW9pZHdZdVoxR0VTQSIsImlkIjoiMXdlZW5sZDYxcW9pZHdZdVoxR0VTQSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzODdhMjljOTBkZTNiMjM5OGMyOWMzNGYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzg3YTI5YzkwZGUzYjIzOThjMjljMzRmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzODdhMjljOTBkZTNiMjM5OGMyOWMzNGYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS2luZCBPZiBCbHVlIiwicmVsZWFzZV9kYXRlIjoiMTk1OS0wOC0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXdlZW5sZDYxcW9pZHdZdVoxR0VTQSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aQ==", + "c3QvMGtiWVROUWI0UGIxclBiYmFGMHBUNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwiaWQiOiIwa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwibmFtZSI6Ik1pbGVzIERhdmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBrYllUTlFiNFBiMXJQYmJhRjBwVDQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIiwiaWQiOiIyaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIiwibmFtZSI6IkpvaG4gQ29sdHJhbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80alhmRnplUDY2Wnk2N0hNMm12SUlGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJpZCI6IjRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJuYW1lIjoiQmlsbCBFdmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0alhmRnplUDY2Wnk2N0hNMm12SUlGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMzNTkzOCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xNTkwMDExNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNmJQNEd5cktOYmNLUE1EcVdKcXB4SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZiUDRHeXJLTmJjS1BNRHFXSnFweEkiLCJpZCI6IjZiUDRHeXJLTmJjS1BNRHFXSnFweEkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmx1ZSBpbiBHcmVlbiAoZmVhdC4gSm9obiBDb2x0cmFuZSAmIEJpbGwgRXZhbnMpIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZiUDRHeXJLTmJjS1BNRHFXSnFweEkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80alhmRnplUDY2Wnk2N0hNMg==", + "bXZJSUYiLCJpZCI6IjRqWGZGemVQNjZaeTY3SE0ybXZJSUYiLCJuYW1lIjoiQmlsbCBFdmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0alhmRnplUDY2Wnk2N0hNMm12SUlGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM0dBN1pDM2oydHA0M1VBdU12U0FyTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNHQTdaQzNqMnRwNDNVQXVNdlNBckwiLCJpZCI6IjNHQTdaQzNqMnRwNDNVQXVNdlNBckwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjdkNjlmNzEyZDc2Y2U2YWI0MjdhY2FhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI3ZDY5ZjcxMmQ3NmNlNmFiNDI3YWNhYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjdkNjlmNzEyZDc2Y2U2YWI0MjdhY2FhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bmRheSBpbiBTcHJpbmciLCJyZWxlYXNlX2RhdGUiOiIyMDEwLTAyLTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0dBN1pDM2oydHA0M1VBdU12U0FyTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRqWGZGemVQNjZaeTY3SE0ybXZJSUYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsImlkIjoiNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiIsIm5hbWUiOiJCaWxsIEV2YW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRqWGZGemVQNjZaeTY3SE0ybXZJSUYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGtiWVROUWI0UGIxclBiYmFGMHBUNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwiaWQiOiIwa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwibmFtZSI6Ik1pbGVzIERhdmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBrYllUTlFiNFBiMXJQYmJhRjBwVDQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbg==", + "LnNwb3RpZnkuY29tL2FydGlzdC8yaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYiLCJpZCI6IjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYiLCJuYW1lIjoiSm9obiBDb2x0cmFuZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjMzNjc4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkZSWjMzNTgwMTA5MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM3RsUXpaZlhlZjNqUVg1MVFsbk82VyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzN0bFF6WmZYZWYzalFYNTFRbG5PNlciLCJpZCI6IjN0bFF6WmZYZWYzalFYNTFRbG5PNlciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmx1ZSBJbiBHcmVlbiIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozdGxRelpmWGVmM2pRWDUxUWxuTzZXIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNkZ3Z1czdMRFhnQnc0ZWppNGdzUlEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RndnVzN0xEWGdCdzRlamk0Z3NSUSIsImlkIjoiM2RndnVzN0xEWGdCdzRlamk0Z3NSUSIsIm5hbWUiOiJNaWxlcyBEYXZpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGd2dXM3TERYZ0J3NGVqaTRnc1JRIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNlZzQzZOZm5IVUZNYnNFOE5pZ09heiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZWc0M2TmZuSFVGTWJzRThOaWdPYXoiLCJpZCI6IjZWc0M2TmZuSFVGTWJzRThOaWdPYXoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTA1MzBkZmMyNTQ2N2FlOWIzNTYwMjM3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEwNTMwZGZjMjU0NjdhZTliMzU2MDIzNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovLw==", + "aS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhMDUzMGRmYzI1NDY3YWU5YjM1NjAyMzcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWlsZXMgaW4gdGhlIE1vdmllcyIsInJlbGVhc2VfZGF0ZSI6IjIwMTAtMDYtMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2VnNDNk5mbkhVRk1ic0U4TmlnT2F6In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2RndnVzN0xEWGdCdzRlamk0Z3NSUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zZGd2dXM3TERYZ0J3NGVqaTRnc1JRIiwiaWQiOiIzZGd2dXM3TERYZ0J3NGVqaTRnc1JRIiwibmFtZSI6Ik1pbGVzIERhdmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNkZ3Z1czdMRFhnQnc0ZWppNGdzUlEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzM3MjY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JCTFkxMDAzOTMyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wQ1lYTTVVT3o1WXdlNGVadkNWTnh0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMENZWE01VU96NVl3ZTRlWnZDVk54dCIsImlkIjoiMENZWE01VU96NVl3ZTRlWnZDVk54dCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCbHVlIGluIEdyZWVuIiwidHJhY2tfbnVtYmVyIjoxNCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowQ1lYTTVVT3o1WXdlNGVadkNWTnh0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBrYllUTlFiNFBiMXJQYmJhRjBwVDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsImlkIjoiMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsIm5hbWUiOiJNaWxlcyBEYXZpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa2JZVE5RYjRQYjFyUGJiYUYwcFQ0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNHNiMGVNcERuM3VwQUZmeWk0cTJydyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRzYjBlTQ==", + "cERuM3VwQUZmeWk0cTJydyIsImlkIjoiNHNiMGVNcERuM3VwQUZmeWk0cTJydyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZWJjMTcyMzliNmIxOGJhODhjZmI4Y2EifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGViYzE3MjM5YjZiMThiYTg4Y2ZiOGNhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwZWJjMTcyMzliNmIxOGJhODhjZmI4Y2EifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS2luZCBPZiBCbHVlIChMZWdhY3kgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIxOTU5LTA4LTE3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NHNiMGVNcERuM3VwQUZmeWk0cTJydyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBrYllUTlFiNFBiMXJQYmJhRjBwVDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsImlkIjoiMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsIm5hbWUiOiJNaWxlcyBEYXZpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa2JZVE5RYjRQYjFyUGJiYUYwcFQ0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjExNjkwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDgwMjc2NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFMwSnptQ0NRamFSamJQZklGNkpWMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRTMEp6bUNDUWphUmpiUGZJRjZKVjEiLCJpZCI6IjRTMEp6bUNDUWphUmpiUGZJRjZKVjEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmx1ZSBpbiBHcmVlbiAtIFN0dWRpbyBTZXF1ZW5jZSIsInRyYWNrX251bWJlciI6MTIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFMwSnptQ0NRamFSamJQZklGNkpWMSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xRmF5ckVWMldZVEg4dA==", + "emt4a1daelAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUZheXJFVjJXWVRIOHR6a3hrV1p6UCIsImlkIjoiMUZheXJFVjJXWVRIOHR6a3hrV1p6UCIsIm5hbWUiOiJGdXNlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFGYXlyRVYyV1lUSDh0emt4a1daelAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81R2Zvb0doUHU4RVFmdzIwTDBNTTZDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUdmb29HaFB1OEVRZncyMEwwTU02QyIsImlkIjoiNUdmb29HaFB1OEVRZncyMEwwTU02QyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3NmRmMTZhOTExNzc1NTg4Zjk0YmFjYjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzZkZjE2YTkxMTc3NTU4OGY5NGJhY2I3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3NmRmMTZhOTExNzc1NTg4Zjk0YmFjYjcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3R1ZGlvIDMiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTExLTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUdmb29HaFB1OEVRZncyMEwwTU02QyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBrYllUTlFiNFBiMXJQYmJhRjBwVDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsImlkIjoiMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsIm5hbWUiOiJNaWxlcyBEYXZpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa2JZVE5RYjRQYjFyUGJiYUYwcFQ0In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFGYXlyRVYyV1lUSDh0emt4a1daelAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUZheXJFVjJXWVRIOHR6a3hrV1p6UCIsImlkIjoiMUZheXJFVjJXWVRIOHR6a3hrV1p6UCIsIm5hbWUiOiJGdXNlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFGYXlyRVYyV1lUSDh0eg==", + "a3hrV1p6UCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozNDk4NzksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTE05UjIwMDAwMDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzB6SVJQZ1FldFlMaElMbm9NcEJQZmgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8weklSUGdRZXRZTGhJTG5vTXBCUGZoIiwiaWQiOiIweklSUGdRZXRZTGhJTG5vTXBCUGZoIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJsdWUgaW4gR3JlZW4iLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHpJUlBnUWV0WUxoSUxub01wQlBmaCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80czF2YnZYM3Zac2pBcWhEVnh2OHRFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHMxdmJ2WDN2WnNqQXFoRFZ4djh0RSIsImlkIjoiNHMxdmJ2WDN2WnNqQXFoRFZ4djh0RSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1MzkxNmNkNzAwZWVmNzMxOGQ3OTU0NzkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTM5MTZjZDcwMGVlZjczMThkNzk1NDc5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1MzkxNmNkNzAwZWVmNzMxOGQ3OTU0NzkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEphenogTWFzdGVycyAtIDI3IENsYXNzaWMgUGVyZm9ybWFuY2VzIEZyb20gVGhlIENvbHVtYmlhIE1hc3RlcnBpZWNlcyBTZXJpZXMiLCJyZWxlYXNlX2RhdGUiOiIxOTg5LTAzLTI4IiwicmVsZWFzZV9kYQ==", + "dGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0czF2YnZYM3Zac2pBcWhEVnh2OHRFIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGtiWVROUWI0UGIxclBiYmFGMHBUNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwiaWQiOiIwa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwibmFtZSI6Ik1pbGVzIERhdmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBrYllUTlFiNFBiMXJQYmJhRjBwVDQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI0MTYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEwMDI4MTgxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81bzZQa09BQXdIdmRra09CR1B4aTIwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNW82UGtPQUF3SHZka2tPQkdQeGkyMCIsImlkIjoiNW82UGtPQUF3SHZka2tPQkdQeGkyMCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCbHVlIEluIEdyZWVuIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVvNlBrT0FBd0h2ZGtrT0JHUHhpMjAifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMmxmMU5RUEZNSXBTMndPT2VDb0ZIeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJsZjFOUVBGTUlwUzJ3T09lQ29GSHkiLCJpZCI6IjJsZjFOUVBGTUlwUzJ3T09lQ29GSHkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjczNzVkNQ==", + "ZjM2MTJhODBlYWJhNTcyMTAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjczNzVkNWYzNjEyYTgwZWFiYTU3MjEwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmNzM3NWQ1ZjM2MTJhODBlYWJhNTcyMTAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSmF6eiBMZWdlbmRzOiBTYXhvcGhvbmUiLCJyZWxlYXNlX2RhdGUiOiIyMDAzLTAzLTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MmxmMU5RUEZNSXBTMndPT2VDb0ZIeSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBrYllUTlFiNFBiMXJQYmJhRjBwVDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsImlkIjoiMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsIm5hbWUiOiJNaWxlcyBEYXZpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa2JZVE5RYjRQYjFyUGJiYUYwcFQ0In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsImlkIjoiMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsIm5hbWUiOiJKb2huIENvbHRyYW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80alhmRnplUDY2Wnk2N0hNMm12SUlGIiwiaWQiOiI0alhmRnplUDY2Wnk2N0hNMm12SUlGIiwibmFtZSI6IkJpbGwgRXZhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGpYZkZ6ZVA2Nlp5NjdITTJtdklJRiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMzUyOTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTU5MDAxMTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVuNQ==", + "eEx3VDNaYlh6TG9JY1JkM0dnbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVuNXhMd1QzWmJYekxvSWNSZDNHZ24iLCJpZCI6IjVuNXhMd1QzWmJYekxvSWNSZDNHZ24iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmx1ZSBpbiBHcmVlbiAoZmVhdC4gSm9obiBDb2x0cmFuZSAmIEJpbGwgRXZhbnMpIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVuNXhMd1QzWmJYekxvSWNSZDNHZ24ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzdUdnRKQWlVbHdNOHE0cjdWbmVLTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc3VHZ0SkFpVWx3TThxNHI3Vm5lS0wiLCJpZCI6Ijc3VHZ0SkFpVWx3TThxNHI3Vm5lS0wiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYWY3NjYxZmE0MmI5NDI2ZGRkYjdmODJiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmFmNzY2MWZhNDJiOTQyNmRkZGI3ZjgyYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYWY3NjYxZmE0MmI5NDI2ZGRkYjdmODJiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlB1cmUuLi4gQ2hpbGxvdXQiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTA2LTA2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NjgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzdUdnRKQWlVbHdNOHE0cjdWbmVLTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBrYllUTlFiNFBiMXJQYmJhRjBwVDQifQ==", + "LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwiaWQiOiIwa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwibmFtZSI6Ik1pbGVzIERhdmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBrYllUTlFiNFBiMXJQYmJhRjBwVDQifV0sImRpc2NfbnVtYmVyIjo0LCJkdXJhdGlvbl9tcyI6MzM0MzIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTE1OTAxMTc3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wNk9iemVVbkIydnIzWGx4RUI1a0xSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDZPYnplVW5CMnZyM1hseEVCNWtMUiIsImlkIjoiMDZPYnplVW5CMnZyM1hseEVCNWtMUiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCbHVlIEluIEdyZWVuIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjA2T2J6ZVVuQjJ2cjNYbHhFQjVrTFIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGtiWVROUWI0UGIxclBiYmFGMHBUNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwiaWQiOiIwa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwibmFtZSI6Ik1pbGVzIERhdmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBrYllUTlFiNFBiMXJQYmJhRjBwVDQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xc1IwWW1vNTVVVDJ0a2NPbjA1UXVyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMXNSMFltbzU1VVQydGtjT24wNVF1ciIsImlkIjoiMXNSMFltbzU1VVQydGtjT24wNVF1ciIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0ODcxM2VlYmU0NGE0MzdkOWNiN2E0NTIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDg3MTNlZWJlNDRhNDM3ZDljYjdhNDUyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0ODcxM2VlYg==", + "ZTQ0YTQzN2Q5Y2I3YTQ1MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgQ29tcGxldGUgTWlsZXMgRGF2aXMgRmVhdHVyaW5nIEpvaG4gQ29sdHJhbmUiLCJyZWxlYXNlX2RhdGUiOiIxOTU5LTA4LTE4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NTgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXNSMFltbzU1VVQydGtjT24wNVF1ciJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBrYllUTlFiNFBiMXJQYmJhRjBwVDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsImlkIjoiMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsIm5hbWUiOiJNaWxlcyBEYXZpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa2JZVE5RYjRQYjFyUGJiYUYwcFQ0In1dLCJkaXNjX251bWJlciI6NCwiZHVyYXRpb25fbXMiOjMzNDIyNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xNTkwMTE3NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNjJNN3JkamUwRE1HbFNOMG9DR3o2ayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzYyTTdyZGplMERNR2xTTjBvQ0d6NmsiLCJpZCI6IjYyTTdyZGplMERNR2xTTjBvQ0d6NmsiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmx1ZSBJbiBHcmVlbiIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2Mk03cmRqZTBETUdsU04wb0NHejZrIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Blue+in+Green%22+artist%3A%22Miles+Davis%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22So%20What%22%20artist%3A%22Miles%20Davis%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4sb0eMpDn3upAFfyi4q2rw"},"href":"https://api.spotify.com/v1/albums/4sb0eMpDn3upAFfyi4q2rw","id":"4sb0eMpDn3upAFfyi4q2rw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730ebc17239b6b18ba88cfb8ca"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020ebc17239b6b18ba88cfb8ca"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510ebc17239b6b18ba88cfb8ca"}],"is_playable":true,"name":"Kind Of Blue (Legacy Edition)","release_date":"1959-08-17","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4sb0eMpDn3upAFfyi4q2rw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":562640,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/4vLYewWIvqHfKtJDk8c8tq"},"href":"https://api.spotify.com/v1/tracks/4vLYewWIvqHfKtJDk8c8tq","id":"4vLYewWIvqHfKtJDk8c8tq","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":1,"type":"track","uri":"spotify:track:4vLYewWIvqHfKtJDk8c8tq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/1weenld61qoidwYuZ1GESA"},"href":"https://api.spotify.com/v1/albums/1weenld61qoidwYuZ1GESA","id":"1weenld61qoidwYuZ1GESA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273387a29c90de3b2398c29c34f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02387a29c90de3b2398c29c34f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851387a29c90de3b2398c29c34f"}],"is_playable":true,"name":"Kind Of Blue","release_date":"1959-08-17","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:1weenld61qoidwYuZ1GESA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":547983,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/7q3kkfAVpmcZ8g6JUThi3o"},"href":"https://api.spotify.com/v1/tracks/7q3kkfAVpmcZ8g6JUThi3o","id":"7q3kkfAVpmcZ8g6JUThi3o","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":1,"type":"track","uri":"spotify:track:7q3kkfAVpmcZ8g6JUThi3o"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QofKE2yZcsjKOUw6fyyn3"},"href":"https://api.spotify.com/v1/albums/3QofKE2yZcsjKOUw6fyyn3","id":"3QofKE2yZcsjKOUw6fyyn3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad1c9ca438b5579fb2f9f3f4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad1c9ca438b5579fb2f9f3f4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad1c9ca438b5579fb2f9f3f4"}],"is_playable":true,"name":"Pleasantville -Music From The Motion Picture","release_date":"1998-10-13","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3QofKE2yZcsjKOUw6fyyn3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":544666,"explicit":false,"external_ids":{"isrc":"USSM19805624"},"external_urls":{"spotify":"https://open.spotify.com/track/3mZ33QYHWylbabTz82rHwj"},"href":"https://api.spotify.com/v1/tracks/3mZ33QYHWylbabTz82rHwj","id":"3mZ33QYHWylbabTz82rHwj","is_local":false,"is_playable":true,"name":"So What","track_number":11,"type":"track","uri":"spotify:track:3mZ33QYHWylbabTz82rHwj"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0I9qXNJRGKbSxvEOT9PiaS"},"href":"https://api.spotify.com/v1/albums/0I9qXNJRGKbSxvEOT9PiaS","id":"0I9qXNJRGKbSxvEOT9PiaS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273415146787899e44956a3b512"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02415146787899e44956a3b512"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851415146787899e44956a3b512"}],"is_playable":true,"name":"Essentials Jazz : The Ultimate Best of Jazz","release_date":"2024-12-09","release_date_precision":"day","total_tracks":102,"type":"album","uri":"spotify:album:0I9qXNJRGKbSxvEOT9PiaS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":1,"duration_ms":561065,"explicit":false,"external_ids":{"isrc":"FR6F32352350"},"external_urls":{"spotify":"https://open.spotify.com/track/6J18r0R7rQFuZ4hiRW4P4W"},"href":"https://api.spotify.com/v1/tracks/6J18r0R7rQFuZ4hiRW4P4W","id":"6J18r0R7rQFuZ4hiRW4P4W","is_local":false,"is_playable":true,"name":"So What","track_number":14,"type":"track","uri":"spotify:track:6J18r0R7rQFuZ4hiRW4P4W"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/5t2mbu43eBgynAQg8xir6f"},"href":"https://api.spotify.com/v1/albums/5t2mbu43eBgynAQg8xir6f","id":"5t2mbu43eBgynAQg8xir6f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f48c0a7e3c905a484ea119c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f48c0a7e3c905a484ea119c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f48c0a7e3c905a484ea119c"}],"is_playable":true,"name":"The Best Of Miles Davis & John Coltrane - Le Best Of Des Deux G\u00e9ants Du Jazz ! - The Two Greatest Jazz Legends !","release_date":"2016-09-16","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:5t2mbu43eBgynAQg8xir6f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":544080,"explicit":false,"external_ids":{"isrc":"GBBXS1156592"},"external_urls":{"spotify":"https://open.spotify.com/track/5ikjjAnrZWbOojRFRosxpC"},"href":"https://api.spotify.com/v1/tracks/5ikjjAnrZWbOojRFRosxpC","id":"5ikjjAnrZWbOojRFRosxpC","is_local":false,"is_playable":true,"name":"So What","track_number":12,"type":"track","uri":"spotify:track:5ikjjAnrZWbOojRFRosxpC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/69IMyjpYKbsVfVWJXQDYRo"},"href":"https://api.spotify.com/v1/albums/69IMyjpYKbsVfVWJXQDYRo","id":"69IMyjpYKbsVfVWJXQDYRo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27366a1f9bd3eac851160c27194"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0266a1f9bd3eac851160c27194"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485166a1f9bd3eac851160c27194"}],"is_playable":true,"name":"Miles in France 1963 & 1964 - Miles Davis Quintet: The Bootleg Series, Vol. 8","release_date":"2024-11-08","release_date_precision":"day","total_tracks":35,"type":"album","uri":"spotify:album:69IMyjpYKbsVfVWJXQDYRo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":586291,"explicit":false,"external_ids":{"isrc":"USSM12405128"},"external_urls":{"spotify":"https://open.spotify.com/track/0c1STsGbexkNA8CrUoLj5E"},"href":"https://api.spotify.com/v1/tracks/0c1STsGbexkNA8CrUoLj5E","id":"0c1STsGbexkNA8CrUoLj5E","is_local":false,"is_playable":true,"name":"So What - Live at Festival Mondial Du Jazz Antibes/Juan-Les-Pins, France - July 26, 1963","track_number":2,"type":"track","uri":"spotify:track:0c1STsGbexkNA8CrUoLj5E"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/2NJ0qZ1UNsiESTmFSQDkT1"},"href":"https://api.spotify.com/v1/albums/2NJ0qZ1UNsiESTmFSQDkT1","id":"2NJ0qZ1UNsiESTmFSQDkT1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730cc53cc7fe5127cecef51c0c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020cc53cc7fe5127cecef51c0c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510cc53cc7fe5127cecef51c0c"}],"is_playable":true,"name":"Miles Ahead (Original Motion Picture Soundtrack)","release_date":"2016-04-01","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:2NJ0qZ1UNsiESTmFSQDkT1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":562927,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/3xkesQd7SbPFZimKdRgIaJ"},"href":"https://api.spotify.com/v1/tracks/3xkesQd7SbPFZimKdRgIaJ","id":"3xkesQd7SbPFZimKdRgIaJ","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":3,"type":"track","uri":"spotify:track:3xkesQd7SbPFZimKdRgIaJ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/14Gdsp33387vOEIskmNYUy"},"href":"https://api.spotify.com/v1/albums/14Gdsp33387vOEIskmNYUy","id":"14Gdsp33387vOEIskmNYUy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27359d0e1884eb9df006b900208"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0259d0e1884eb9df006b900208"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485159d0e1884eb9df006b900208"}],"is_playable":true,"name":"The Best Of Miles Davis","release_date":"2002-09-03","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:14Gdsp33387vOEIskmNYUy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":561973,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/1wWjGtAEF1vORxpDeq4zDO"},"href":"https://api.spotify.com/v1/tracks/1wWjGtAEF1vORxpDeq4zDO","id":"1wWjGtAEF1vORxpDeq4zDO","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":3,"type":"track","uri":"spotify:track:1wWjGtAEF1vORxpDeq4zDO"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/23CsInPSHn88bjLSPIFVh9"},"href":"https://api.spotify.com/v1/albums/23CsInPSHn88bjLSPIFVh9","id":"23CsInPSHn88bjLSPIFVh9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27317a82c928f107503bb7b2cab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0217a82c928f107503bb7b2cab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485117a82c928f107503bb7b2cab"}],"is_playable":true,"name":"The Essential Miles Davis","release_date":"2001-05-15","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:23CsInPSHn88bjLSPIFVh9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":561533,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/3CQPWR7DWrvtICoCKlz0aO"},"href":"https://api.spotify.com/v1/tracks/3CQPWR7DWrvtICoCKlz0aO","id":"3CQPWR7DWrvtICoCKlz0aO","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":11,"type":"track","uri":"spotify:track:3CQPWR7DWrvtICoCKlz0aO"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22So%20What%22%20artist%3A%22Miles%20Davis%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4sb0eMpDn3upAFfyi4q2rw"},"href":"https://api.spotify.com/v1/albums/4sb0eMpDn3upAFfyi4q2rw","id":"4sb0eMpDn3upAFfyi4q2rw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730ebc17239b6b18ba88cfb8ca"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020ebc17239b6b18ba88cfb8ca"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510ebc17239b6b18ba88cfb8ca"}],"is_playable":true,"name":"Kind Of Blue (Legacy Edition)","release_date":"1959-08-17","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4sb0eMpDn3upAFfyi4q2rw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":562640,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/4vLYewWIvqHfKtJDk8c8tq"},"href":"https://api.spotify.com/v1/tracks/4vLYewWIvqHfKtJDk8c8tq","id":"4vLYewWIvqHfKtJDk8c8tq","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":1,"type":"track","uri":"spotify:track:4vLYewWIvqHfKtJDk8c8tq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/1weenld61qoidwYuZ1GESA"},"href":"https://api.spotify.com/v1/albums/1weenld61qoidwYuZ1GESA","id":"1weenld61qoidwYuZ1GESA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273387a29c90de3b2398c29c34f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02387a29c90de3b2398c29c34f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851387a29c90de3b2398c29c34f"}],"is_playable":true,"name":"Kind Of Blue","release_date":"1959-08-17","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:1weenld61qoidwYuZ1GESA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":547983,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/7q3kkfAVpmcZ8g6JUThi3o"},"href":"https://api.spotify.com/v1/tracks/7q3kkfAVpmcZ8g6JUThi3o","id":"7q3kkfAVpmcZ8g6JUThi3o","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":1,"type":"track","uri":"spotify:track:7q3kkfAVpmcZ8g6JUThi3o"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QofKE2yZcsjKOUw6fyyn3"},"href":"https://api.spotify.com/v1/albums/3QofKE2yZcsjKOUw6fyyn3","id":"3QofKE2yZcsjKOUw6fyyn3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad1c9ca438b5579fb2f9f3f4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad1c9ca438b5579fb2f9f3f4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad1c9ca438b5579fb2f9f3f4"}],"is_playable":true,"name":"Pleasantville -Music From The Motion Picture","release_date":"1998-10-13","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3QofKE2yZcsjKOUw6fyyn3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":544666,"explicit":false,"external_ids":{"isrc":"USSM19805624"},"external_urls":{"spotify":"https://open.spotify.com/track/3mZ33QYHWylbabTz82rHwj"},"href":"https://api.spotify.com/v1/tracks/3mZ33QYHWylbabTz82rHwj","id":"3mZ33QYHWylbabTz82rHwj","is_local":false,"is_playable":true,"name":"So What","track_number":11,"type":"track","uri":"spotify:track:3mZ33QYHWylbabTz82rHwj"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0I9qXNJRGKbSxvEOT9PiaS"},"href":"https://api.spotify.com/v1/albums/0I9qXNJRGKbSxvEOT9PiaS","id":"0I9qXNJRGKbSxvEOT9PiaS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273415146787899e44956a3b512"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02415146787899e44956a3b512"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851415146787899e44956a3b512"}],"is_playable":true,"name":"Essentials Jazz : The Ultimate Best of Jazz","release_date":"2024-12-09","release_date_precision":"day","total_tracks":102,"type":"album","uri":"spotify:album:0I9qXNJRGKbSxvEOT9PiaS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":1,"duration_ms":561065,"explicit":false,"external_ids":{"isrc":"FR6F32352350"},"external_urls":{"spotify":"https://open.spotify.com/track/6J18r0R7rQFuZ4hiRW4P4W"},"href":"https://api.spotify.com/v1/tracks/6J18r0R7rQFuZ4hiRW4P4W","id":"6J18r0R7rQFuZ4hiRW4P4W","is_local":false,"is_playable":true,"name":"So What","track_number":14,"type":"track","uri":"spotify:track:6J18r0R7rQFuZ4hiRW4P4W"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/5t2mbu43eBgynAQg8xir6f"},"href":"https://api.spotify.com/v1/albums/5t2mbu43eBgynAQg8xir6f","id":"5t2mbu43eBgynAQg8xir6f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f48c0a7e3c905a484ea119c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f48c0a7e3c905a484ea119c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f48c0a7e3c905a484ea119c"}],"is_playable":true,"name":"The Best Of Miles Davis & John Coltrane - Le Best Of Des Deux G\u00e9ants Du Jazz ! - The Two Greatest Jazz Legends !","release_date":"2016-09-16","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:5t2mbu43eBgynAQg8xir6f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":544080,"explicit":false,"external_ids":{"isrc":"GBBXS1156592"},"external_urls":{"spotify":"https://open.spotify.com/track/5ikjjAnrZWbOojRFRosxpC"},"href":"https://api.spotify.com/v1/tracks/5ikjjAnrZWbOojRFRosxpC","id":"5ikjjAnrZWbOojRFRosxpC","is_local":false,"is_playable":true,"name":"So What","track_number":12,"type":"track","uri":"spotify:track:5ikjjAnrZWbOojRFRosxpC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/69IMyjpYKbsVfVWJXQDYRo"},"href":"https://api.spotify.com/v1/albums/69IMyjpYKbsVfVWJXQDYRo","id":"69IMyjpYKbsVfVWJXQDYRo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27366a1f9bd3eac851160c27194"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0266a1f9bd3eac851160c27194"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485166a1f9bd3eac851160c27194"}],"is_playable":true,"name":"Miles in France 1963 & 1964 - Miles Davis Quintet: The Bootleg Series, Vol. 8","release_date":"2024-11-08","release_date_precision":"day","total_tracks":35,"type":"album","uri":"spotify:album:69IMyjpYKbsVfVWJXQDYRo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":586291,"explicit":false,"external_ids":{"isrc":"USSM12405128"},"external_urls":{"spotify":"https://open.spotify.com/track/0c1STsGbexkNA8CrUoLj5E"},"href":"https://api.spotify.com/v1/tracks/0c1STsGbexkNA8CrUoLj5E","id":"0c1STsGbexkNA8CrUoLj5E","is_local":false,"is_playable":true,"name":"So What - Live at Festival Mondial Du Jazz Antibes/Juan-Les-Pins, France - July 26, 1963","track_number":2,"type":"track","uri":"spotify:track:0c1STsGbexkNA8CrUoLj5E"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/2NJ0qZ1UNsiESTmFSQDkT1"},"href":"https://api.spotify.com/v1/albums/2NJ0qZ1UNsiESTmFSQDkT1","id":"2NJ0qZ1UNsiESTmFSQDkT1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730cc53cc7fe5127cecef51c0c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020cc53cc7fe5127cecef51c0c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510cc53cc7fe5127cecef51c0c"}],"is_playable":true,"name":"Miles Ahead (Original Motion Picture Soundtrack)","release_date":"2016-04-01","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:2NJ0qZ1UNsiESTmFSQDkT1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":562927,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/3xkesQd7SbPFZimKdRgIaJ"},"href":"https://api.spotify.com/v1/tracks/3xkesQd7SbPFZimKdRgIaJ","id":"3xkesQd7SbPFZimKdRgIaJ","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":3,"type":"track","uri":"spotify:track:3xkesQd7SbPFZimKdRgIaJ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/14Gdsp33387vOEIskmNYUy"},"href":"https://api.spotify.com/v1/albums/14Gdsp33387vOEIskmNYUy","id":"14Gdsp33387vOEIskmNYUy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27359d0e1884eb9df006b900208"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0259d0e1884eb9df006b900208"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485159d0e1884eb9df006b900208"}],"is_playable":true,"name":"The Best Of Miles Davis","release_date":"2002-09-03","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:14Gdsp33387vOEIskmNYUy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":561973,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/1wWjGtAEF1vORxpDeq4zDO"},"href":"https://api.spotify.com/v1/tracks/1wWjGtAEF1vORxpDeq4zDO","id":"1wWjGtAEF1vORxpDeq4zDO","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":3,"type":"track","uri":"spotify:track:1wWjGtAEF1vORxpDeq4zDO"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/23CsInPSHn88bjLSPIFVh9"},"href":"https://api.spotify.com/v1/albums/23CsInPSHn88bjLSPIFVh9","id":"23CsInPSHn88bjLSPIFVh9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27317a82c928f107503bb7b2cab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0217a82c928f107503bb7b2cab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485117a82c928f107503bb7b2cab"}],"is_playable":true,"name":"The Essential Miles Davis","release_date":"2001-05-15","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:23CsInPSHn88bjLSPIFVh9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v74mT11KGJqadf9sLw4dA"},"href":"https://api.spotify.com/v1/artists/5v74mT11KGJqadf9sLw4dA","id":"5v74mT11KGJqadf9sLw4dA","name":"Cannonball Adderley","type":"artist","uri":"spotify:artist:5v74mT11KGJqadf9sLw4dA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":561533,"explicit":false,"external_ids":{"isrc":"USSM15900113"},"external_urls":{"spotify":"https://open.spotify.com/track/3CQPWR7DWrvtICoCKlz0aO"},"href":"https://api.spotify.com/v1/tracks/3CQPWR7DWrvtICoCKlz0aO","id":"3CQPWR7DWrvtICoCKlz0aO","is_local":false,"is_playable":true,"name":"So What (feat. John Coltrane, Cannonball Adderley & Bill Evans)","track_number":11,"type":"track","uri":"spotify:track:3CQPWR7DWrvtICoCKlz0aO"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22So+What%22+artist%3A%22Miles+Davis%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Corcovado%22%20artist%3A%22Jo%C3%A3o%20Gilberto%22&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=track%3A%22Corcovado%22%20artist%3A%22Jo%C3%A3o%20Gilberto%22&type=track","offset":0,"previous":null,"total":100,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":139986,"explicit":false,"external_ids":{"isrc":"USPR36312116"},"external_urls":{"spotify":"https://open.spotify.com/track/5nU7dvOfzYs9QVVL7YVNPE"},"href":"https://api.spotify.com/v1/tracks/5nU7dvOfzYs9QVVL7YVNPE","id":"5nU7dvOfzYs9QVVL7YVNPE","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars) - Single Version","track_number":18,"type":"track","uri":"spotify:track:5nU7dvOfzYs9QVVL7YVNPE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":256560,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/0Wh99eifNTNqDFRtzWhCE2"},"href":"https://api.spotify.com/v1/tracks/0Wh99eifNTNqDFRtzWhCE2","id":"0Wh99eifNTNqDFRtzWhCE2","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":5,"type":"track","uri":"spotify:track:0Wh99eifNTNqDFRtzWhCE2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/73ZRKdD3Ds43IjHrhKgucY"},"href":"https://api.spotify.com/v1/albums/73ZRKdD3Ds43IjHrhKgucY","id":"73ZRKdD3Ds43IjHrhKgucY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bbf35173afc8f6ae9041b6c3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bbf35173afc8f6ae9041b6c3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bbf35173afc8f6ae9041b6c3"}],"is_playable":true,"name":"Getz/Gilberto","release_date":"1964-03-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:73ZRKdD3Ds43IjHrhKgucY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":256580,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/5EaU1o7PQE5vhW5HdDWgdO"},"href":"https://api.spotify.com/v1/tracks/5EaU1o7PQE5vhW5HdDWgdO","id":"5EaU1o7PQE5vhW5HdDWgdO","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":5,"type":"track","uri":"spotify:track:5EaU1o7PQE5vhW5HdDWgdO"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ADBNtjx72fiKAAuoC71W1"},"href":"https://api.spotify.com/v1/albums/4ADBNtjx72fiKAAuoC71W1","id":"4ADBNtjx72fiKAAuoC71W1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739553b10c5bebf51de3cd7870"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029553b10c5bebf51de3cd7870"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519553b10c5bebf51de3cd7870"}],"is_playable":true,"name":"Diva","release_date":"2003-05-20","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4ADBNtjx72fiKAAuoC71W1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"disc_number":1,"duration_ms":253533,"explicit":false,"external_ids":{"isrc":"USPR36386850"},"external_urls":{"spotify":"https://open.spotify.com/track/3FUtFM4GCbrnitRh2t77d9"},"href":"https://api.spotify.com/v1/tracks/3FUtFM4GCbrnitRh2t77d9","id":"3FUtFM4GCbrnitRh2t77d9","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":10,"type":"track","uri":"spotify:track:3FUtFM4GCbrnitRh2t77d9"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/73ZRKdD3Ds43IjHrhKgucY"},"href":"https://api.spotify.com/v1/albums/73ZRKdD3Ds43IjHrhKgucY","id":"73ZRKdD3Ds43IjHrhKgucY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bbf35173afc8f6ae9041b6c3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bbf35173afc8f6ae9041b6c3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bbf35173afc8f6ae9041b6c3"}],"is_playable":true,"name":"Getz/Gilberto","release_date":"1964-03-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:73ZRKdD3Ds43IjHrhKgucY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":140840,"explicit":false,"external_ids":{"isrc":"USPR36312116"},"external_urls":{"spotify":"https://open.spotify.com/track/2NKPemiggukfBMEHRNzOsJ"},"href":"https://api.spotify.com/v1/tracks/2NKPemiggukfBMEHRNzOsJ","id":"2NKPemiggukfBMEHRNzOsJ","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":10,"type":"track","uri":"spotify:track:2NKPemiggukfBMEHRNzOsJ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4I26wT2bckDbv8Xl5iVInQ"},"href":"https://api.spotify.com/v1/albums/4I26wT2bckDbv8Xl5iVInQ","id":"4I26wT2bckDbv8Xl5iVInQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c21e95926400939bba3c8730"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c21e95926400939bba3c8730"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c21e95926400939bba3c8730"}],"is_playable":true,"name":"The Girl From Ipanema - The Bossa Nova Years","release_date":"1989-01-01","release_date_precision":"day","total_tracks":51,"type":"album","uri":"spotify:album:4I26wT2bckDbv8Xl5iVInQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":3,"duration_ms":254666,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/4SrJyRdyHYxxkcVMQ3QkGE"},"href":"https://api.spotify.com/v1/tracks/4SrJyRdyHYxxkcVMQ3QkGE","id":"4SrJyRdyHYxxkcVMQ3QkGE","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":5,"type":"track","uri":"spotify:track:4SrJyRdyHYxxkcVMQ3QkGE"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4gfH6Bco0I18IEHqXClxdG"},"href":"https://api.spotify.com/v1/albums/4gfH6Bco0I18IEHqXClxdG","id":"4gfH6Bco0I18IEHqXClxdG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27389b6f04a1ebd762788cd3d4f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0289b6f04a1ebd762788cd3d4f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485189b6f04a1ebd762788cd3d4f"}],"is_playable":true,"name":"Getz For Lovers","release_date":"2002-01-14","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4gfH6Bco0I18IEHqXClxdG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":253466,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/204tfkWrfEkzlG6H0iF46C"},"href":"https://api.spotify.com/v1/tracks/204tfkWrfEkzlG6H0iF46C","id":"204tfkWrfEkzlG6H0iF46C","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":2,"type":"track","uri":"spotify:track:204tfkWrfEkzlG6H0iF46C"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"}],"external_urls":{"spotify":"https://open.spotify.com/album/29YBpbnbqZSLXpnwwk3Vwm"},"href":"https://api.spotify.com/v1/albums/29YBpbnbqZSLXpnwwk3Vwm","id":"29YBpbnbqZSLXpnwwk3Vwm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfea3913999c25ff8f45d133"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfea3913999c25ff8f45d133"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfea3913999c25ff8f45d133"}],"is_playable":true,"name":"Astrud For Lovers","release_date":"2004-01-27","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:29YBpbnbqZSLXpnwwk3Vwm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":254000,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/3Ji925TUG4cW6S7eyZRdZ6"},"href":"https://api.spotify.com/v1/tracks/3Ji925TUG4cW6S7eyZRdZ6","id":"3Ji925TUG4cW6S7eyZRdZ6","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":6,"type":"track","uri":"spotify:track:3Ji925TUG4cW6S7eyZRdZ6"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"}],"external_urls":{"spotify":"https://open.spotify.com/album/48vcoqHqexZKTSU6QyMCDa"},"href":"https://api.spotify.com/v1/albums/48vcoqHqexZKTSU6QyMCDa","id":"48vcoqHqexZKTSU6QyMCDa","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731cc790def74940f8146044cc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021cc790def74940f8146044cc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511cc790def74940f8146044cc"}],"is_playable":true,"name":"Great Women Of Song: Astrud Gilberto","release_date":"2023-10-27","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:48vcoqHqexZKTSU6QyMCDa"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":257238,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/4ohZp02DS1o0X16ioWIH3k"},"href":"https://api.spotify.com/v1/tracks/4ohZp02DS1o0X16ioWIH3k","id":"4ohZp02DS1o0X16ioWIH3k","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":8,"type":"track","uri":"spotify:track:4ohZp02DS1o0X16ioWIH3k"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"}],"external_urls":{"spotify":"https://open.spotify.com/album/4tMIlEcQHTRdAOLqoNggsO"},"href":"https://api.spotify.com/v1/albums/4tMIlEcQHTRdAOLqoNggsO","id":"4tMIlEcQHTRdAOLqoNggsO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273524032443d58dda500a8fa10"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02524032443d58dda500a8fa10"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851524032443d58dda500a8fa10"}],"is_playable":true,"name":"Astrud Gilberto's Finest Hour","release_date":"2001-12-21","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:4tMIlEcQHTRdAOLqoNggsO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":253706,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/11fnLD3sjlXFJFCQ7EygKo"},"href":"https://api.spotify.com/v1/tracks/11fnLD3sjlXFJFCQ7EygKo","id":"11fnLD3sjlXFJFCQ7EygKo","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":5,"type":"track","uri":"spotify:track:11fnLD3sjlXFJFCQ7EygKo"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Corcovado%22%20artist%3A%22Jo%C3%A3o%20Gilberto%22&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=track%3A%22Corcovado%22%20artist%3A%22Jo%C3%A3o%20Gilberto%22&type=track","offset":0,"previous":null,"total":100,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":139986,"explicit":false,"external_ids":{"isrc":"USPR36312116"},"external_urls":{"spotify":"https://open.spotify.com/track/5nU7dvOfzYs9QVVL7YVNPE"},"href":"https://api.spotify.com/v1/tracks/5nU7dvOfzYs9QVVL7YVNPE","id":"5nU7dvOfzYs9QVVL7YVNPE","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars) - Single Version","track_number":18,"type":"track","uri":"spotify:track:5nU7dvOfzYs9QVVL7YVNPE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":256560,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/0Wh99eifNTNqDFRtzWhCE2"},"href":"https://api.spotify.com/v1/tracks/0Wh99eifNTNqDFRtzWhCE2","id":"0Wh99eifNTNqDFRtzWhCE2","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":5,"type":"track","uri":"spotify:track:0Wh99eifNTNqDFRtzWhCE2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/73ZRKdD3Ds43IjHrhKgucY"},"href":"https://api.spotify.com/v1/albums/73ZRKdD3Ds43IjHrhKgucY","id":"73ZRKdD3Ds43IjHrhKgucY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bbf35173afc8f6ae9041b6c3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bbf35173afc8f6ae9041b6c3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bbf35173afc8f6ae9041b6c3"}],"is_playable":true,"name":"Getz/Gilberto","release_date":"1964-03-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:73ZRKdD3Ds43IjHrhKgucY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":256580,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/5EaU1o7PQE5vhW5HdDWgdO"},"href":"https://api.spotify.com/v1/tracks/5EaU1o7PQE5vhW5HdDWgdO","id":"5EaU1o7PQE5vhW5HdDWgdO","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":5,"type":"track","uri":"spotify:track:5EaU1o7PQE5vhW5HdDWgdO"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ADBNtjx72fiKAAuoC71W1"},"href":"https://api.spotify.com/v1/albums/4ADBNtjx72fiKAAuoC71W1","id":"4ADBNtjx72fiKAAuoC71W1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739553b10c5bebf51de3cd7870"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029553b10c5bebf51de3cd7870"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519553b10c5bebf51de3cd7870"}],"is_playable":true,"name":"Diva","release_date":"2003-05-20","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4ADBNtjx72fiKAAuoC71W1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"disc_number":1,"duration_ms":253533,"explicit":false,"external_ids":{"isrc":"USPR36386850"},"external_urls":{"spotify":"https://open.spotify.com/track/3FUtFM4GCbrnitRh2t77d9"},"href":"https://api.spotify.com/v1/tracks/3FUtFM4GCbrnitRh2t77d9","id":"3FUtFM4GCbrnitRh2t77d9","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":10,"type":"track","uri":"spotify:track:3FUtFM4GCbrnitRh2t77d9"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/73ZRKdD3Ds43IjHrhKgucY"},"href":"https://api.spotify.com/v1/albums/73ZRKdD3Ds43IjHrhKgucY","id":"73ZRKdD3Ds43IjHrhKgucY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bbf35173afc8f6ae9041b6c3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bbf35173afc8f6ae9041b6c3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bbf35173afc8f6ae9041b6c3"}],"is_playable":true,"name":"Getz/Gilberto","release_date":"1964-03-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:73ZRKdD3Ds43IjHrhKgucY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":140840,"explicit":false,"external_ids":{"isrc":"USPR36312116"},"external_urls":{"spotify":"https://open.spotify.com/track/2NKPemiggukfBMEHRNzOsJ"},"href":"https://api.spotify.com/v1/tracks/2NKPemiggukfBMEHRNzOsJ","id":"2NKPemiggukfBMEHRNzOsJ","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":10,"type":"track","uri":"spotify:track:2NKPemiggukfBMEHRNzOsJ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4I26wT2bckDbv8Xl5iVInQ"},"href":"https://api.spotify.com/v1/albums/4I26wT2bckDbv8Xl5iVInQ","id":"4I26wT2bckDbv8Xl5iVInQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c21e95926400939bba3c8730"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c21e95926400939bba3c8730"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c21e95926400939bba3c8730"}],"is_playable":true,"name":"The Girl From Ipanema - The Bossa Nova Years","release_date":"1989-01-01","release_date_precision":"day","total_tracks":51,"type":"album","uri":"spotify:album:4I26wT2bckDbv8Xl5iVInQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":3,"duration_ms":254666,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/4SrJyRdyHYxxkcVMQ3QkGE"},"href":"https://api.spotify.com/v1/tracks/4SrJyRdyHYxxkcVMQ3QkGE","id":"4SrJyRdyHYxxkcVMQ3QkGE","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":5,"type":"track","uri":"spotify:track:4SrJyRdyHYxxkcVMQ3QkGE"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/4gfH6Bco0I18IEHqXClxdG"},"href":"https://api.spotify.com/v1/albums/4gfH6Bco0I18IEHqXClxdG","id":"4gfH6Bco0I18IEHqXClxdG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27389b6f04a1ebd762788cd3d4f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0289b6f04a1ebd762788cd3d4f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485189b6f04a1ebd762788cd3d4f"}],"is_playable":true,"name":"Getz For Lovers","release_date":"2002-01-14","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4gfH6Bco0I18IEHqXClxdG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":253466,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/204tfkWrfEkzlG6H0iF46C"},"href":"https://api.spotify.com/v1/tracks/204tfkWrfEkzlG6H0iF46C","id":"204tfkWrfEkzlG6H0iF46C","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":2,"type":"track","uri":"spotify:track:204tfkWrfEkzlG6H0iF46C"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"}],"external_urls":{"spotify":"https://open.spotify.com/album/29YBpbnbqZSLXpnwwk3Vwm"},"href":"https://api.spotify.com/v1/albums/29YBpbnbqZSLXpnwwk3Vwm","id":"29YBpbnbqZSLXpnwwk3Vwm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfea3913999c25ff8f45d133"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfea3913999c25ff8f45d133"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfea3913999c25ff8f45d133"}],"is_playable":true,"name":"Astrud For Lovers","release_date":"2004-01-27","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:29YBpbnbqZSLXpnwwk3Vwm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":254000,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/3Ji925TUG4cW6S7eyZRdZ6"},"href":"https://api.spotify.com/v1/tracks/3Ji925TUG4cW6S7eyZRdZ6","id":"3Ji925TUG4cW6S7eyZRdZ6","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":6,"type":"track","uri":"spotify:track:3Ji925TUG4cW6S7eyZRdZ6"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"}],"external_urls":{"spotify":"https://open.spotify.com/album/48vcoqHqexZKTSU6QyMCDa"},"href":"https://api.spotify.com/v1/albums/48vcoqHqexZKTSU6QyMCDa","id":"48vcoqHqexZKTSU6QyMCDa","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731cc790def74940f8146044cc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021cc790def74940f8146044cc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511cc790def74940f8146044cc"}],"is_playable":true,"name":"Great Women Of Song: Astrud Gilberto","release_date":"2023-10-27","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:48vcoqHqexZKTSU6QyMCDa"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":257238,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/4ohZp02DS1o0X16ioWIH3k"},"href":"https://api.spotify.com/v1/tracks/4ohZp02DS1o0X16ioWIH3k","id":"4ohZp02DS1o0X16ioWIH3k","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":8,"type":"track","uri":"spotify:track:4ohZp02DS1o0X16ioWIH3k"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"}],"external_urls":{"spotify":"https://open.spotify.com/album/4tMIlEcQHTRdAOLqoNggsO"},"href":"https://api.spotify.com/v1/albums/4tMIlEcQHTRdAOLqoNggsO","id":"4tMIlEcQHTRdAOLqoNggsO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273524032443d58dda500a8fa10"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02524032443d58dda500a8fa10"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851524032443d58dda500a8fa10"}],"is_playable":true,"name":"Astrud Gilberto's Finest Hour","release_date":"2001-12-21","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:4tMIlEcQHTRdAOLqoNggsO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5rX2c1zow6hCph8PnnU3kF"},"href":"https://api.spotify.com/v1/artists/5rX2c1zow6hCph8PnnU3kF","id":"5rX2c1zow6hCph8PnnU3kF","name":"Astrud Gilberto","type":"artist","uri":"spotify:artist:5rX2c1zow6hCph8PnnU3kF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":253706,"explicit":false,"external_ids":{"isrc":"USPR36307074"},"external_urls":{"spotify":"https://open.spotify.com/track/11fnLD3sjlXFJFCQ7EygKo"},"href":"https://api.spotify.com/v1/tracks/11fnLD3sjlXFJFCQ7EygKo","id":"11fnLD3sjlXFJFCQ7EygKo","is_local":false,"is_playable":true,"name":"Corcovado (Quiet Nights Of Quiet Stars)","track_number":5,"type":"track","uri":"spotify:track:11fnLD3sjlXFJFCQ7EygKo"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Corcovado%22+artist%3A%22Jo%C3%A3o+Gilberto%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Con%20Alma%22%20artist%3A%22Dizzy%20Gillespie%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"external_urls":{"spotify":"https://open.spotify.com/album/0trcpUrMlHBGmOHvIvVGYF"},"href":"https://api.spotify.com/v1/albums/0trcpUrMlHBGmOHvIvVGYF","id":"0trcpUrMlHBGmOHvIvVGYF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273548165be0a97b93f5831ab91"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02548165be0a97b93f5831ab91"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851548165be0a97b93f5831ab91"}],"is_playable":true,"name":"Afro","release_date":"1954-01-26","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:0trcpUrMlHBGmOHvIvVGYF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"disc_number":1,"duration_ms":305066,"explicit":false,"external_ids":{"isrc":"USGR10111113"},"external_urls":{"spotify":"https://open.spotify.com/track/79dhjqvk5LOW1Ah1dQDGgU"},"href":"https://api.spotify.com/v1/tracks/79dhjqvk5LOW1Ah1dQDGgU","id":"79dhjqvk5LOW1Ah1dQDGgU","is_local":false,"is_playable":true,"name":"Con Alma","track_number":6,"type":"track","uri":"spotify:track:79dhjqvk5LOW1Ah1dQDGgU"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"external_urls":{"spotify":"https://open.spotify.com/album/5DGcQGe6AvE5LGdYyZlHfn"},"href":"https://api.spotify.com/v1/albums/5DGcQGe6AvE5LGdYyZlHfn","id":"5DGcQGe6AvE5LGdYyZlHfn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732cd31f4139e3886f1f4e863f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022cd31f4139e3886f1f4e863f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512cd31f4139e3886f1f4e863f"}],"is_playable":true,"name":"Dizzy 100","release_date":"2017-09-29","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:5DGcQGe6AvE5LGdYyZlHfn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"disc_number":1,"duration_ms":303522,"explicit":false,"external_ids":{"isrc":"USGR10111113"},"external_urls":{"spotify":"https://open.spotify.com/track/3cJZT2monFlaNCgXvuDQwZ"},"href":"https://api.spotify.com/v1/tracks/3cJZT2monFlaNCgXvuDQwZ","id":"3cJZT2monFlaNCgXvuDQwZ","is_local":false,"is_playable":true,"name":"Con Alma","track_number":15,"type":"track","uri":"spotify:track:3cJZT2monFlaNCgXvuDQwZ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4a3xlqhmr66qoNJ7UyyEVN"},"href":"https://api.spotify.com/v1/artists/4a3xlqhmr66qoNJ7UyyEVN","id":"4a3xlqhmr66qoNJ7UyyEVN","name":"The Double Six Of Paris","type":"artist","uri":"spotify:artist:4a3xlqhmr66qoNJ7UyyEVN"}],"external_urls":{"spotify":"https://open.spotify.com/album/1VdKwlPrM6sC1Rru51dkcm"},"href":"https://api.spotify.com/v1/albums/1VdKwlPrM6sC1Rru51dkcm","id":"1VdKwlPrM6sC1Rru51dkcm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e86edfd4876a22c8063ed654"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e86edfd4876a22c8063ed654"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e86edfd4876a22c8063ed654"}],"is_playable":true,"name":"Dizzy Gillespie & The Double Six Of Paris","release_date":"1963-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1VdKwlPrM6sC1Rru51dkcm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4a3xlqhmr66qoNJ7UyyEVN"},"href":"https://api.spotify.com/v1/artists/4a3xlqhmr66qoNJ7UyyEVN","id":"4a3xlqhmr66qoNJ7UyyEVN","name":"The Double Six Of Paris","type":"artist","uri":"spotify:artist:4a3xlqhmr66qoNJ7UyyEVN"}],"disc_number":1,"duration_ms":215600,"explicit":false,"external_ids":{"isrc":"USUM70601770"},"external_urls":{"spotify":"https://open.spotify.com/track/286Z9e6Z9AtVuPozjmKyTd"},"href":"https://api.spotify.com/v1/tracks/286Z9e6Z9AtVuPozjmKyTd","id":"286Z9e6Z9AtVuPozjmKyTd","is_local":false,"is_playable":true,"name":"Con Alma","track_number":9,"type":"track","uri":"spotify:track:286Z9e6Z9AtVuPozjmKyTd"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"external_urls":{"spotify":"https://open.spotify.com/album/1nhJMRUIhJhSl6vshTJvGH"},"href":"https://api.spotify.com/v1/albums/1nhJMRUIhJhSl6vshTJvGH","id":"1nhJMRUIhJhSl6vshTJvGH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f4745b924ed532fe8a0c61fd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f4745b924ed532fe8a0c61fd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f4745b924ed532fe8a0c61fd"}],"is_playable":true,"name":"Verve Jazz Masters 10: Dizzy Gillespie","release_date":"1994-03-22","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1nhJMRUIhJhSl6vshTJvGH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"disc_number":1,"duration_ms":574333,"explicit":false,"external_ids":{"isrc":"USPR35770348"},"external_urls":{"spotify":"https://open.spotify.com/track/2I4PFHLiZtp1l13M3bfwX7"},"href":"https://api.spotify.com/v1/tracks/2I4PFHLiZtp1l13M3bfwX7","id":"2I4PFHLiZtp1l13M3bfwX7","is_local":false,"is_playable":true,"name":"Con Alma","track_number":6,"type":"track","uri":"spotify:track:2I4PFHLiZtp1l13M3bfwX7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/217b0uqAzsOOhGcnoANZqj"},"href":"https://api.spotify.com/v1/artists/217b0uqAzsOOhGcnoANZqj","id":"217b0uqAzsOOhGcnoANZqj","name":"Sonny Stitt","type":"artist","uri":"spotify:artist:217b0uqAzsOOhGcnoANZqj"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Plg3ZtmUOPA1JYbPnztCe"},"href":"https://api.spotify.com/v1/albums/4Plg3ZtmUOPA1JYbPnztCe","id":"4Plg3ZtmUOPA1JYbPnztCe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738605493b1c3d72c97e40dfc3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028605493b1c3d72c97e40dfc3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518605493b1c3d72c97e40dfc3"}],"is_playable":true,"name":"Dizzy Gillespie with Sonny Rollins & Sonny Stitt: Duets (Remastered)","release_date":"1958","release_date_precision":"year","total_tracks":4,"type":"album","uri":"spotify:album:4Plg3ZtmUOPA1JYbPnztCe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/217b0uqAzsOOhGcnoANZqj"},"href":"https://api.spotify.com/v1/artists/217b0uqAzsOOhGcnoANZqj","id":"217b0uqAzsOOhGcnoANZqj","name":"Sonny Stitt","type":"artist","uri":"spotify:artist:217b0uqAzsOOhGcnoANZqj"}],"disc_number":1,"duration_ms":567893,"explicit":false,"external_ids":{"isrc":"GBBMH0998003"},"external_urls":{"spotify":"https://open.spotify.com/track/1h3RTYoHAYqLaOQ178mkT1"},"href":"https://api.spotify.com/v1/tracks/1h3RTYoHAYqLaOQ178mkT1","id":"1h3RTYoHAYqLaOQ178mkT1","is_local":false,"is_playable":true,"name":"Con Alma (Remastered)","track_number":3,"type":"track","uri":"spotify:track:1h3RTYoHAYqLaOQ178mkT1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6MKWZdLwL9vd3SbNEegcuL"},"href":"https://api.spotify.com/v1/albums/6MKWZdLwL9vd3SbNEegcuL","id":"6MKWZdLwL9vd3SbNEegcuL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732b3e5642c4c7198c845f3414"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022b3e5642c4c7198c845f3414"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512b3e5642c4c7198c845f3414"}],"is_playable":true,"name":"Latin Jazz & Chill","release_date":"2025-06-06","release_date_precision":"day","total_tracks":35,"type":"album","uri":"spotify:album:6MKWZdLwL9vd3SbNEegcuL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"disc_number":1,"duration_ms":305066,"explicit":false,"external_ids":{"isrc":"USGR10111113"},"external_urls":{"spotify":"https://open.spotify.com/track/1pEaMKHCvTGY1BdfRAc9BL"},"href":"https://api.spotify.com/v1/tracks/1pEaMKHCvTGY1BdfRAc9BL","id":"1pEaMKHCvTGY1BdfRAc9BL","is_local":false,"is_playable":true,"name":"Con Alma","track_number":8,"type":"track","uri":"spotify:track:1pEaMKHCvTGY1BdfRAc9BL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pOjIcQ4PGk52L8aGsrO5A"},"href":"https://api.spotify.com/v1/artists/4pOjIcQ4PGk52L8aGsrO5A","id":"4pOjIcQ4PGk52L8aGsrO5A","name":"Dizzy Gillespie Quintet","type":"artist","uri":"spotify:artist:4pOjIcQ4PGk52L8aGsrO5A"}],"external_urls":{"spotify":"https://open.spotify.com/album/6YnZB0uI5o2NcsXzPHuxhl"},"href":"https://api.spotify.com/v1/albums/6YnZB0uI5o2NcsXzPHuxhl","id":"6YnZB0uI5o2NcsXzPHuxhl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f1646787fe3052e206b68dc6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f1646787fe3052e206b68dc6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f1646787fe3052e206b68dc6"}],"is_playable":true,"name":"In Warsaw 1965","release_date":"2016-09-30","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:6YnZB0uI5o2NcsXzPHuxhl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pOjIcQ4PGk52L8aGsrO5A"},"href":"https://api.spotify.com/v1/artists/4pOjIcQ4PGk52L8aGsrO5A","id":"4pOjIcQ4PGk52L8aGsrO5A","name":"Dizzy Gillespie Quintet","type":"artist","uri":"spotify:artist:4pOjIcQ4PGk52L8aGsrO5A"}],"disc_number":1,"duration_ms":685325,"explicit":false,"external_ids":{"isrc":"PLA391605704"},"external_urls":{"spotify":"https://open.spotify.com/track/6M0m8XRh3unhcZXYJB0Zyt"},"href":"https://api.spotify.com/v1/tracks/6M0m8XRh3unhcZXYJB0Zyt","id":"6M0m8XRh3unhcZXYJB0Zyt","is_local":false,"is_playable":true,"name":"Con Alma - Live","track_number":4,"type":"track","uri":"spotify:track:6M0m8XRh3unhcZXYJB0Zyt"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"external_urls":{"spotify":"https://open.spotify.com/album/7z4dtBzA0Hvod3JTkZ7Mkf"},"href":"https://api.spotify.com/v1/albums/7z4dtBzA0Hvod3JTkZ7Mkf","id":"7z4dtBzA0Hvod3JTkZ7Mkf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346f870f698df4618dcb11067"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246f870f698df4618dcb11067"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146f870f698df4618dcb11067"}],"is_playable":true,"name":"Work From Home with Dizzy Gillespie","release_date":"2020-05-08","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:7z4dtBzA0Hvod3JTkZ7Mkf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"disc_number":1,"duration_ms":305066,"explicit":false,"external_ids":{"isrc":"USGR10111113"},"external_urls":{"spotify":"https://open.spotify.com/track/1rgFfw337lPgCwqH5DJWCc"},"href":"https://api.spotify.com/v1/tracks/1rgFfw337lPgCwqH5DJWCc","id":"1rgFfw337lPgCwqH5DJWCc","is_local":false,"is_playable":true,"name":"Con Alma","track_number":5,"type":"track","uri":"spotify:track:1rgFfw337lPgCwqH5DJWCc"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/68cGdXMyPd0a1Cxbcn5Wb6"},"href":"https://api.spotify.com/v1/artists/68cGdXMyPd0a1Cxbcn5Wb6","id":"68cGdXMyPd0a1Cxbcn5Wb6","name":"Anna Carewe","type":"artist","uri":"spotify:artist:68cGdXMyPd0a1Cxbcn5Wb6"},{"external_urls":{"spotify":"https://open.spotify.com/artist/46EcCi38c5cVMVuvVkPDKc"},"href":"https://api.spotify.com/v1/artists/46EcCi38c5cVMVuvVkPDKc","id":"46EcCi38c5cVMVuvVkPDKc","name":"Oli Bott","type":"artist","uri":"spotify:artist:46EcCi38c5cVMVuvVkPDKc"}],"external_urls":{"spotify":"https://open.spotify.com/album/2gHa5kp2nsYjnG29ORaacS"},"href":"https://api.spotify.com/v1/albums/2gHa5kp2nsYjnG29ORaacS","id":"2gHa5kp2nsYjnG29ORaacS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f47da13c7865ec6e5aa99da2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f47da13c7865ec6e5aa99da2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f47da13c7865ec6e5aa99da2"}],"is_playable":true,"name":"Trance & Rhythm","release_date":"2024-11-15","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:2gHa5kp2nsYjnG29ORaacS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/68cGdXMyPd0a1Cxbcn5Wb6"},"href":"https://api.spotify.com/v1/artists/68cGdXMyPd0a1Cxbcn5Wb6","id":"68cGdXMyPd0a1Cxbcn5Wb6","name":"Anna Carewe","type":"artist","uri":"spotify:artist:68cGdXMyPd0a1Cxbcn5Wb6"},{"external_urls":{"spotify":"https://open.spotify.com/artist/46EcCi38c5cVMVuvVkPDKc"},"href":"https://api.spotify.com/v1/artists/46EcCi38c5cVMVuvVkPDKc","id":"46EcCi38c5cVMVuvVkPDKc","name":"Oli Bott","type":"artist","uri":"spotify:artist:46EcCi38c5cVMVuvVkPDKc"}],"disc_number":1,"duration_ms":143733,"explicit":false,"external_ids":{"isrc":"DEAD62403314"},"external_urls":{"spotify":"https://open.spotify.com/track/1Mka2IXj1rgwXUCDZx4M2F"},"href":"https://api.spotify.com/v1/tracks/1Mka2IXj1rgwXUCDZx4M2F","id":"1Mka2IXj1rgwXUCDZx4M2F","is_local":false,"is_playable":true,"name":"Con alma (Arr. for Violoncello and Vibraphone by Anna Carewe and Oli Bott)","track_number":14,"type":"track","uri":"spotify:track:1Mka2IXj1rgwXUCDZx4M2F"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"external_urls":{"spotify":"https://open.spotify.com/album/2D9ZjInIhpIiv91xMQYeA5"},"href":"https://api.spotify.com/v1/albums/2D9ZjInIhpIiv91xMQYeA5","id":"2D9ZjInIhpIiv91xMQYeA5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27337091b4680cb56de0d0423f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0237091b4680cb56de0d0423f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485137091b4680cb56de0d0423f5"}],"is_playable":true,"name":"Bird Songs: The Final Recordings (Live At The Blue Note, New York City, NY / January 23-25, 1992)","release_date":"1997-08-26","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:2D9ZjInIhpIiv91xMQYeA5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RzjqfPS0Bu4bUMkyNNDpn"},"href":"https://api.spotify.com/v1/artists/5RzjqfPS0Bu4bUMkyNNDpn","id":"5RzjqfPS0Bu4bUMkyNNDpn","name":"Dizzy Gillespie","type":"artist","uri":"spotify:artist:5RzjqfPS0Bu4bUMkyNNDpn"}],"disc_number":1,"duration_ms":567360,"explicit":false,"external_ids":{"isrc":"USTE10442101"},"external_urls":{"spotify":"https://open.spotify.com/track/6yqToafdVzXvMO7dLp0VeR"},"href":"https://api.spotify.com/v1/tracks/6yqToafdVzXvMO7dLp0VeR","id":"6yqToafdVzXvMO7dLp0VeR","is_local":false,"is_playable":true,"name":"Con Alma - Live At The Blue Note, New York City, NY / January 23, 1992","track_number":2,"type":"track","uri":"spotify:track:6yqToafdVzXvMO7dLp0VeR"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNvbiUyMEFsbWElMjIlMjBhcnRpc3QlM0ElMjJEaXp6eSUyMEdpbGxlc3BpZSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwiaWQiOiI1UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwibmFtZSI6IkRpenp5IEdpbGxlc3BpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1UnpqcWZQUzBCdTRiVU1reU5ORHBuIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMHRyY3BVck1sSEJHbU9Idkl2VkdZRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzB0cmNwVXJNbEhCR21PSHZJdlZHWUYiLCJpZCI6IjB0cmNwVXJNbEhCR21PSHZJdlZHWUYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTQ4MTY1YmUwYTk3YjkzZjU4MzFhYjkxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjU0ODE2NWJlMGE5N2I5M2Y1ODMxYWI5MSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTQ4MTY1YmUwYTk3YjkzZjU4MzFhYjkxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFmcm8iLCJyZWxlYXNlX2RhdGUiOiIxOTU0LTAxLTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowdHJjcFVyTWxIQkdtT0h2SXZWR1lGIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwiaWQiOiI1UnpqcWZQUzBCdTRiVU1reQ==", + "Tk5EcG4iLCJuYW1lIjoiRGl6enkgR2lsbGVzcGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzA1MDY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNHUjEwMTExMTEzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83OWRoanF2azVMT1cxQWgxZFFER2dVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNzlkaGpxdms1TE9XMUFoMWRRREdnVSIsImlkIjoiNzlkaGpxdms1TE9XMUFoMWRRREdnVSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDb24gQWxtYSIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3OWRoanF2azVMT1cxQWgxZFFER2dVIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsImlkIjoiNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsIm5hbWUiOiJEaXp6eSBHaWxsZXNwaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVER2NRR2U2QXZFNUxHZFl5WmxIZm4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81REdjUUdlNkF2RTVMR2RZeVpsSGZuIiwiaWQiOiI1REdjUUdlNkF2RTVMR2RZeVpsSGZuIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzJjZDMxZjQxMzllMzg4NmYxZjRlODYzZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyY2QzMWY0MTM5ZTM4ODZmMWY0ZTg2M2YifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJjZDMxZjQxMzllMzg4NmYxZjRlODYzZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaXp6eSAxMDAiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA5LTI5Iiwicg==", + "ZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NURHY1FHZTZBdkU1TEdkWXlabEhmbiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsImlkIjoiNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsIm5hbWUiOiJEaXp6eSBHaWxsZXNwaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDM1MjIsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0dSMTAxMTExMTMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNjSlpUMm1vbkZsYU5DZ1h2dURRd1oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zY0paVDJtb25GbGFOQ2dYdnVEUXdaIiwiaWQiOiIzY0paVDJtb25GbGFOQ2dYdnVEUXdaIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbiBBbG1hIiwidHJhY2tfbnVtYmVyIjoxNSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozY0paVDJtb25GbGFOQ2dYdnVEUXdaIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsImlkIjoiNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsIm5hbWUiOiJEaXp6eSBHaWxsZXNwaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80YTN4bHFobXI2NnFvTko3VXl5RVZOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRhM3hscWhtcjY2cW9OSjdVeXlFVk4iLCJpZCI6IjRhM3hscWhtcjY2cW9OSjdVeXlFVk4iLCJuYW1lIjoiVGhlIERvdWJsZSBTaXggT2YgUGFyaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGEzeGxxaG1yNjZxbw==", + "Tko3VXl5RVZOIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMVZkS3dsUHJNNnNDMVJydTUxZGtjbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFWZEt3bFByTTZzQzFScnU1MWRrY20iLCJpZCI6IjFWZEt3bFByTTZzQzFScnU1MWRrY20iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZTg2ZWRmZDQ4NzZhMjJjODA2M2VkNjU0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmU4NmVkZmQ0ODc2YTIyYzgwNjNlZDY1NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZTg2ZWRmZDQ4NzZhMjJjODA2M2VkNjU0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpenp5IEdpbGxlc3BpZSAmIFRoZSBEb3VibGUgU2l4IE9mIFBhcmlzIiwicmVsZWFzZV9kYXRlIjoiMTk2My0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFWZEt3bFByTTZzQzFScnU1MWRrY20ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81UnpqcWZQUzBCdTRiVU1reU5ORHBuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVSempxZlBTMEJ1NGJVTWt5Tk5EcG4iLCJpZCI6IjVSempxZlBTMEJ1NGJVTWt5Tk5EcG4iLCJuYW1lIjoiRGl6enkgR2lsbGVzcGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGEzeGxxaG1yNjZxb05KN1V5eUVWTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80YTN4bHFobXI2NnFvTko3VXl5RVZOIiwiaWQiOiI0YTN4bHFobXI2NnFvTko3VXl5RVZOIiwibmFtZSI6IlRoZSBEb3VibGUgU2l4IE9mIFBhcmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRhM3hscWhtcjY2cW9OSjdVeXlFVk4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE1NjAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcwNjAxNzcwIn0sImV4dGVybmFsX3VybA==", + "cyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzI4Nlo5ZTZaOUF0VnVQb3pqbUt5VGQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yODZaOWU2WjlBdFZ1UG96am1LeVRkIiwiaWQiOiIyODZaOWU2WjlBdFZ1UG96am1LeVRkIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbiBBbG1hIiwidHJhY2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjI4Nlo5ZTZaOUF0VnVQb3pqbUt5VGQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwiaWQiOiI1UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwibmFtZSI6IkRpenp5IEdpbGxlc3BpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1UnpqcWZQUzBCdTRiVU1reU5ORHBuIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMW5oSk1SVUloSmhTbDZ2c2hUSnZHSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFuaEpNUlVJaEpoU2w2dnNoVEp2R0giLCJpZCI6IjFuaEpNUlVJaEpoU2w2dnNoVEp2R0giLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjQ3NDViOTI0ZWQ1MzJmZThhMGM2MWZkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY0NzQ1YjkyNGVkNTMyZmU4YTBjNjFmZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjQ3NDViOTI0ZWQ1MzJmZThhMGM2MWZkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZlcnZlIEphenogTWFzdGVycyAxMDogRGl6enkgR2lsbGVzcGllIiwicmVsZWFzZV9kYXRlIjoiMTk5NC0wMy0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFuaEpNUlVJaEpoU2w2dnNoVEp2R0gifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tLw==", + "YXJ0aXN0LzVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsImlkIjoiNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsIm5hbWUiOiJEaXp6eSBHaWxsZXNwaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo1NzQzMzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1BSMzU3NzAzNDgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJJNFBGSExpWnRwMWwxM00zYmZ3WDcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8ySTRQRkhMaVp0cDFsMTNNM2Jmd1g3IiwiaWQiOiIySTRQRkhMaVp0cDFsMTNNM2Jmd1g3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbiBBbG1hIiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJJNFBGSExpWnRwMWwxM00zYmZ3WDcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwiaWQiOiI1UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwibmFtZSI6IkRpenp5IEdpbGxlc3BpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1UnpqcWZQUzBCdTRiVU1reU5ORHBuIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsImlkIjoiMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsIm5hbWUiOiJTb25ueSBSb2xsaW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjE3YjB1cUF6c09PaEdjbm9BTlpxaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yMTdiMHVxQXpzT09oR2Nub0FOWnFqIiwiaWQiOiIyMTdiMHVxQXpzT09oRw==", + "Y25vQU5acWoiLCJuYW1lIjoiU29ubnkgU3RpdHQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjE3YjB1cUF6c09PaEdjbm9BTlpxaiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRQbGczWnRtVU9QQTFKWWJQbnp0Q2UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80UGxnM1p0bVVPUEExSlliUG56dENlIiwiaWQiOiI0UGxnM1p0bVVPUEExSlliUG56dENlIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzg2MDU0OTNiMWMzZDcyYzk3ZTQwZGZjMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4NjA1NDkzYjFjM2Q3MmM5N2U0MGRmYzMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTg2MDU0OTNiMWMzZDcyYzk3ZTQwZGZjMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaXp6eSBHaWxsZXNwaWUgd2l0aCBTb25ueSBSb2xsaW5zICYgU29ubnkgU3RpdHQ6IER1ZXRzIChSZW1hc3RlcmVkKSIsInJlbGVhc2VfZGF0ZSI6IjE5NTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0UGxnM1p0bVVPUEExSlliUG56dENlIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwiaWQiOiI1UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwibmFtZSI6IkRpenp5IEdpbGxlc3BpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1UnpqcWZQUzBCdTRiVU1reU5ORHBuIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsImlkIjoiMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsIm5hbWUiOiJTb25ueSBSb2xsaW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSx7ImV4dGVybmFsX3VybA==", + "cyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yMTdiMHVxQXpzT09oR2Nub0FOWnFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzIxN2IwdXFBenNPT2hHY25vQU5acWoiLCJpZCI6IjIxN2IwdXFBenNPT2hHY25vQU5acWoiLCJuYW1lIjoiU29ubnkgU3RpdHQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjE3YjB1cUF6c09PaEdjbm9BTlpxaiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo1Njc4OTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkJNSDA5OTgwMDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFoM1JUWW9IQVlxTGFPUTE3OG1rVDEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xaDNSVFlvSEFZcUxhT1ExNzhta1QxIiwiaWQiOiIxaDNSVFlvSEFZcUxhT1ExNzhta1QxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbiBBbG1hIChSZW1hc3RlcmVkKSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxaDNSVFlvSEFZcUxhT1ExNzhta1QxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZNS1daZEx3TDl2ZDNTYk5FZWdjdUwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82TUtXWmRMd0w5dmQzU2JORWVnY3VMIiwiaWQiOiI2TUtXWmRMd0w5dmQzU2JORWVnY3VMIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzJiM2U1NjQyYzRjNzE5OGM4NDVmMzQxNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyYjNlNTY0MmM0YzcxOThjODQ1ZjM0MQ==", + "NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMmIzZTU2NDJjNGM3MTk4Yzg0NWYzNDE0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxhdGluIEphenogJiBDaGlsbCIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDYtMDYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2TUtXWmRMd0w5dmQzU2JORWVnY3VMIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwiaWQiOiI1UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwibmFtZSI6IkRpenp5IEdpbGxlc3BpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1UnpqcWZQUzBCdTRiVU1reU5ORHBuIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwNTA2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTR1IxMDExMTExMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXBFYU1LSEN2VEdZMUJkZlJBYzlCTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFwRWFNS0hDdlRHWTFCZGZSQWM5QkwiLCJpZCI6IjFwRWFNS0hDdlRHWTFCZGZSQWM5QkwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29uIEFsbWEiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXBFYU1LSEN2VEdZMUJkZlJBYzlCTCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80cE9qSWNRNFBHazUyTDhhR3NyTzVBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRwT2pJY1E0UEdrNTJMOGFHc3JPNUEiLCJpZCI6IjRwT2pJY1E0UEdrNTJMOGFHc3JPNUEiLCJuYW1lIjoiRGl6enkgR2lsbGVzcGllIFF1aW50ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHBPakljUTRQR2s1Mkw4YUdzck81QSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZZblpCMHVJNW8yTmNzWHpQSHV4aA==", + "bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZZblpCMHVJNW8yTmNzWHpQSHV4aGwiLCJpZCI6IjZZblpCMHVJNW8yTmNzWHpQSHV4aGwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjE2NDY3ODdmZTMwNTJlMjA2YjY4ZGM2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmYxNjQ2Nzg3ZmUzMDUyZTIwNmI2OGRjNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjE2NDY3ODdmZTMwNTJlMjA2YjY4ZGM2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkluIFdhcnNhdyAxOTY1IiwicmVsZWFzZV9kYXRlIjoiMjAxNi0wOS0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlluWkIwdUk1bzJOY3NYelBIdXhobCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRwT2pJY1E0UEdrNTJMOGFHc3JPNUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHBPakljUTRQR2s1Mkw4YUdzck81QSIsImlkIjoiNHBPakljUTRQR2s1Mkw4YUdzck81QSIsIm5hbWUiOiJEaXp6eSBHaWxsZXNwaWUgUXVpbnRldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0cE9qSWNRNFBHazUyTDhhR3NyTzVBIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjY4NTMyNSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlBMQTM5MTYwNTcwNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNk0wbThYUmgzdW5oY1pYWUpCMFp5dCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZNMG04WFJoM3VuaGNaWFlKQjBaeXQiLCJpZCI6IjZNMG04WFJoM3VuaGNaWFlKQjBaeXQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29uIEFsbWEgLSBMaXZlIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZNMG04WFJoM3VuaGNaWFlKQjBaeXQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vbw==", + "cGVuLnNwb3RpZnkuY29tL2FydGlzdC81UnpqcWZQUzBCdTRiVU1reU5ORHBuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVSempxZlBTMEJ1NGJVTWt5Tk5EcG4iLCJpZCI6IjVSempxZlBTMEJ1NGJVTWt5Tk5EcG4iLCJuYW1lIjoiRGl6enkgR2lsbGVzcGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83ejRkdEJ6QTBIdm9kM0pUa1o3TWtmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3o0ZHRCekEwSHZvZDNKVGtaN01rZiIsImlkIjoiN3o0ZHRCekEwSHZvZDNKVGtaN01rZiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0NmY4NzBmNjk4ZGY0NjE4ZGNiMTEwNjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDZmODcwZjY5OGRmNDYxOGRjYjExMDY3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0NmY4NzBmNjk4ZGY0NjE4ZGNiMTEwNjcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV29yayBGcm9tIEhvbWUgd2l0aCBEaXp6eSBHaWxsZXNwaWUiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTA1LTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N3o0ZHRCekEwSHZvZDNKVGtaN01rZiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsImlkIjoiNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiIsIm5hbWUiOiJEaXp6eSBHaWxsZXNwaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDUwNjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0dSMTAxMTExMTMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFyZ0ZmdzMzN2xQZ0N3cUg1RA==", + "SldDYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFyZ0ZmdzMzN2xQZ0N3cUg1REpXQ2MiLCJpZCI6IjFyZ0ZmdzMzN2xQZ0N3cUg1REpXQ2MiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29uIEFsbWEiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXJnRmZ3MzM3bFBnQ3dxSDVESldDYyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82OGNHZFhNeVBkMGExQ3hiY241V2I2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY4Y0dkWE15UGQwYTFDeGJjbjVXYjYiLCJpZCI6IjY4Y0dkWE15UGQwYTFDeGJjbjVXYjYiLCJuYW1lIjoiQW5uYSBDYXJld2UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjhjR2RYTXlQZDBhMUN4YmNuNVdiNiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80NkVjQ2kzOGM1Y1ZNVnV2VmtQREtjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzQ2RWNDaTM4YzVjVk1WdXZWa1BES2MiLCJpZCI6IjQ2RWNDaTM4YzVjVk1WdXZWa1BES2MiLCJuYW1lIjoiT2xpIEJvdHQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDZFY0NpMzhjNWNWTVZ1dlZrUERLYyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJnSGE1a3AybnNZam5HMjlPUmFhY1MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yZ0hhNWtwMm5zWWpuRzI5T1JhYWNTIiwiaWQiOiIyZ0hhNWtwMm5zWWpuRzI5T1JhYWNTIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2Y0N2RhMTNjNzg2NWVjNmU1YWE5OWRhMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmNDdkYTEzYzc4NjVlYzZlNWFhOTlkYTIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWY0N2RhMTNjNzg2NWVjNmU1YWE5OWRhMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUcmFuY2UgJiBSaHl0aG0iLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTExLTE1IiwicmVsZWFzZQ==", + "X2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyZ0hhNWtwMm5zWWpuRzI5T1JhYWNTIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVJ6anFmUFMwQnU0YlVNa3lOTkRwbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwiaWQiOiI1UnpqcWZQUzBCdTRiVU1reU5ORHBuIiwibmFtZSI6IkRpenp5IEdpbGxlc3BpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1UnpqcWZQUzBCdTRiVU1reU5ORHBuIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY4Y0dkWE15UGQwYTFDeGJjbjVXYjYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjhjR2RYTXlQZDBhMUN4YmNuNVdiNiIsImlkIjoiNjhjR2RYTXlQZDBhMUN4YmNuNVdiNiIsIm5hbWUiOiJBbm5hIENhcmV3ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2OGNHZFhNeVBkMGExQ3hiY241V2I2In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzQ2RWNDaTM4YzVjVk1WdXZWa1BES2MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNDZFY0NpMzhjNWNWTVZ1dlZrUERLYyIsImlkIjoiNDZFY0NpMzhjNWNWTVZ1dlZrUERLYyIsIm5hbWUiOiJPbGkgQm90dCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0NkVjQ2kzOGM1Y1ZNVnV2VmtQREtjIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0MzczMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkRFQUQ2MjQwMzMxNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMU1rYTJJWGoxcmd3WFVDRFp4NE0yRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFNa2EySVhqMXJnd1hVQ0RaeDRNMkYiLCJpZCI6IjFNa2EySVhqMXJnd1hVQ0RaeDRNMkYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29uIGFsbWEgKEFyci4gZm9yIFZpb2xvbmNlbGxvIGFuZCBWaWJyYXBob25lIGJ5IEFubmEgQ2FyZXdlIGFuZCBPbGkgQm90dCkiLCJ0cmFja19udW1iZXIiOjE0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFNa2EySVhqMXJnd1hVQw==", + "RFp4NE0yRiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81UnpqcWZQUzBCdTRiVU1reU5ORHBuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVSempxZlBTMEJ1NGJVTWt5Tk5EcG4iLCJpZCI6IjVSempxZlBTMEJ1NGJVTWt5Tk5EcG4iLCJuYW1lIjoiRGl6enkgR2lsbGVzcGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yRDlaakluSWhwSWl2OTF4TVFZZUE1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMkQ5WmpJbklocElpdjkxeE1RWWVBNSIsImlkIjoiMkQ5WmpJbklocElpdjkxeE1RWWVBNSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzNzA5MWI0NjgwY2I1NmRlMGQwNDIzZjUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzcwOTFiNDY4MGNiNTZkZTBkMDQyM2Y1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzNzA5MWI0NjgwY2I1NmRlMGQwNDIzZjUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmlyZCBTb25nczogVGhlIEZpbmFsIFJlY29yZGluZ3MgKExpdmUgQXQgVGhlIEJsdWUgTm90ZSwgTmV3IFlvcmsgQ2l0eSwgTlkgLyBKYW51YXJ5IDIzLTI1LCAxOTkyKSIsInJlbGVhc2VfZGF0ZSI6IjE5OTctMDgtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJEOVpqSW5JaHBJaXY5MXhNUVllQTUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81UnpqcWZQUzBCdTRiVU1reU5ORHBuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVSempxZlBTMEJ1NGJVTWt5Tk5EcG4iLCJpZCI6IjVSempxZlBTMEJ1NGJVTWt5Tk5EcG4iLCJuYW1lIjoiRGl6enkgR2lsbGVzcGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVSempxZlBTMEJ1NGJVTWt5Tk5EcG4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdQ==", + "cmF0aW9uX21zIjo1NjczNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1RFMTA0NDIxMDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZ5cVRvYWZkVnpYdk1PN2RMcDBWZVIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82eXFUb2FmZFZ6WHZNTzdkTHAwVmVSIiwiaWQiOiI2eXFUb2FmZFZ6WHZNTzdkTHAwVmVSIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbiBBbG1hIC0gTGl2ZSBBdCBUaGUgQmx1ZSBOb3RlLCBOZXcgWW9yayBDaXR5LCBOWSAvIEphbnVhcnkgMjMsIDE5OTIiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NnlxVG9hZmRWelh2TU83ZExwMFZlUiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Con+Alma%22+artist%3A%22Dizzy+Gillespie%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22My%20Funny%20Valentine%22%20artist%3A%22Chet%20Baker%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"external_urls":{"spotify":"https://open.spotify.com/album/5JJ779nrbHx0KB2lBrMMa4"},"href":"https://api.spotify.com/v1/albums/5JJ779nrbHx0KB2lBrMMa4","id":"5JJ779nrbHx0KB2lBrMMa4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f12f8e33e377ba119ecbd26b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f12f8e33e377ba119ecbd26b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f12f8e33e377ba119ecbd26b"}],"is_playable":true,"name":"Chet Baker Sings","release_date":"1956","release_date_precision":"year","total_tracks":14,"type":"album","uri":"spotify:album:5JJ779nrbHx0KB2lBrMMa4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"disc_number":1,"duration_ms":141133,"explicit":false,"external_ids":{"isrc":"USBN28900073"},"external_urls":{"spotify":"https://open.spotify.com/track/4l9hml2UCnxoNI3yCdL1BW"},"href":"https://api.spotify.com/v1/tracks/4l9hml2UCnxoNI3yCdL1BW","id":"4l9hml2UCnxoNI3yCdL1BW","is_local":false,"is_playable":true,"name":"My Funny Valentine","track_number":10,"type":"track","uri":"spotify:track:4l9hml2UCnxoNI3yCdL1BW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"external_urls":{"spotify":"https://open.spotify.com/album/5rb3LlPlS4L3qPHwxRVUML"},"href":"https://api.spotify.com/v1/albums/5rb3LlPlS4L3qPHwxRVUML","id":"5rb3LlPlS4L3qPHwxRVUML","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a93c280683c39b449e2b2a40"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a93c280683c39b449e2b2a40"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a93c280683c39b449e2b2a40"}],"is_playable":true,"name":"Let's Get Lost: The Best Of Chet Baker Sings","release_date":"1989-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:5rb3LlPlS4L3qPHwxRVUML"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"disc_number":1,"duration_ms":140000,"explicit":false,"external_ids":{"isrc":"USBN28900073"},"external_urls":{"spotify":"https://open.spotify.com/track/0gv1lAG1KH6xezSe20bxoV"},"href":"https://api.spotify.com/v1/tracks/0gv1lAG1KH6xezSe20bxoV","id":"0gv1lAG1KH6xezSe20bxoV","is_local":false,"is_playable":true,"name":"My Funny Valentine","track_number":7,"type":"track","uri":"spotify:track:0gv1lAG1KH6xezSe20bxoV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Bybs5AFT2nP55AlP27d0q"},"href":"https://api.spotify.com/v1/albums/5Bybs5AFT2nP55AlP27d0q","id":"5Bybs5AFT2nP55AlP27d0q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734a3ae19721856208210c1b33"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024a3ae19721856208210c1b33"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514a3ae19721856208210c1b33"}],"is_playable":true,"name":"Chet Baker In Tokyo (The Complete Concert)","release_date":"2019-02-22","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:5Bybs5AFT2nP55AlP27d0q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"disc_number":1,"duration_ms":794520,"explicit":false,"external_ids":{"isrc":"TCACE1507929"},"external_urls":{"spotify":"https://open.spotify.com/track/2HMWjNvAJyV6S6kg365eh2"},"href":"https://api.spotify.com/v1/tracks/2HMWjNvAJyV6S6kg365eh2","id":"2HMWjNvAJyV6S6kg365eh2","is_local":false,"is_playable":true,"name":"My Funny Valentine","track_number":12,"type":"track","uri":"spotify:track:2HMWjNvAJyV6S6kg365eh2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"external_urls":{"spotify":"https://open.spotify.com/album/1WUlOWwCmLevOi6QSkDkOV"},"href":"https://api.spotify.com/v1/albums/1WUlOWwCmLevOi6QSkDkOV","id":"1WUlOWwCmLevOi6QSkDkOV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e6fbbca130b5b305433b5304"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e6fbbca130b5b305433b5304"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e6fbbca130b5b305433b5304"}],"is_playable":true,"name":"Sings Again","release_date":"1986","release_date_precision":"year","total_tracks":8,"type":"album","uri":"spotify:album:1WUlOWwCmLevOi6QSkDkOV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"disc_number":1,"duration_ms":435000,"explicit":false,"external_ids":{"isrc":"NLA410814716"},"external_urls":{"spotify":"https://open.spotify.com/track/5bNL92WdZkSTlEf5rR82xt"},"href":"https://api.spotify.com/v1/tracks/5bNL92WdZkSTlEf5rR82xt","id":"5bNL92WdZkSTlEf5rR82xt","is_local":false,"is_playable":true,"name":"My Funny Valentine","track_number":5,"type":"track","uri":"spotify:track:5bNL92WdZkSTlEf5rR82xt"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"external_urls":{"spotify":"https://open.spotify.com/album/2aRY7rbWKl6qtPIjkXvOsK"},"href":"https://api.spotify.com/v1/albums/2aRY7rbWKl6qtPIjkXvOsK","id":"2aRY7rbWKl6qtPIjkXvOsK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273afa4b18b81794d7211d86035"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02afa4b18b81794d7211d86035"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851afa4b18b81794d7211d86035"}],"is_playable":true,"name":"My Funny Valentine","release_date":"1994-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:2aRY7rbWKl6qtPIjkXvOsK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"disc_number":1,"duration_ms":140360,"explicit":false,"external_ids":{"isrc":"USBN28900073"},"external_urls":{"spotify":"https://open.spotify.com/track/6WGy9WdYWOyyipBW7trp5I"},"href":"https://api.spotify.com/v1/tracks/6WGy9WdYWOyyipBW7trp5I","id":"6WGy9WdYWOyyipBW7trp5I","is_local":false,"is_playable":true,"name":"My Funny Valentine","track_number":1,"type":"track","uri":"spotify:track:6WGy9WdYWOyyipBW7trp5I"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"external_urls":{"spotify":"https://open.spotify.com/album/0wscT2nikUKuIukxJFJ7qv"},"href":"https://api.spotify.com/v1/albums/0wscT2nikUKuIukxJFJ7qv","id":"0wscT2nikUKuIukxJFJ7qv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273238199cd99e2c1a7989c7e22"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02238199cd99e2c1a7989c7e22"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851238199cd99e2c1a7989c7e22"}],"is_playable":true,"name":"My Funny Valentine (Studio Japan '69)","release_date":"2026-02-20","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:0wscT2nikUKuIukxJFJ7qv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6pVkGhtBvjj1P52yn0tNLG"},"href":"https://api.spotify.com/v1/artists/6pVkGhtBvjj1P52yn0tNLG","id":"6pVkGhtBvjj1P52yn0tNLG","name":"Barney Kessel","type":"artist","uri":"spotify:artist:6pVkGhtBvjj1P52yn0tNLG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/29N7WM1A1z6zuJG5Aii8ao"},"href":"https://api.spotify.com/v1/artists/29N7WM1A1z6zuJG5Aii8ao","id":"29N7WM1A1z6zuJG5Aii8ao","name":"Frank Capp","type":"artist","uri":"spotify:artist:29N7WM1A1z6zuJG5Aii8ao"},{"external_urls":{"spotify":"https://open.spotify.com/artist/439h9it2Y3lV0Xf0YasxwF"},"href":"https://api.spotify.com/v1/artists/439h9it2Y3lV0Xf0YasxwF","id":"439h9it2Y3lV0Xf0YasxwF","name":"Paul Smith","type":"artist","uri":"spotify:artist:439h9it2Y3lV0Xf0YasxwF"}],"disc_number":1,"duration_ms":151576,"explicit":false,"external_ids":{"isrc":"USA2P2609266"},"external_urls":{"spotify":"https://open.spotify.com/track/4cUA0vsXM8MGEx7p8jaQ23"},"href":"https://api.spotify.com/v1/tracks/4cUA0vsXM8MGEx7p8jaQ23","id":"4cUA0vsXM8MGEx7p8jaQ23","is_local":false,"is_playable":true,"name":"My Funny Valentine (Studio Japan '69)","track_number":1,"type":"track","uri":"spotify:track:4cUA0vsXM8MGEx7p8jaQ23"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4mb8ZVI5MmAApY7909j5YK"},"href":"https://api.spotify.com/v1/albums/4mb8ZVI5MmAApY7909j5YK","id":"4mb8ZVI5MmAApY7909j5YK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273080bd84d8a74c8e1eaaead6a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02080bd84d8a74c8e1eaaead6a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851080bd84d8a74c8e1eaaead6a"}],"is_playable":true,"name":"De Zwarte Lijst","release_date":"2012-01-01","release_date_precision":"day","total_tracks":54,"type":"album","uri":"spotify:album:4mb8ZVI5MmAApY7909j5YK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"disc_number":1,"duration_ms":136880,"explicit":false,"external_ids":{"isrc":"USBN28900073"},"external_urls":{"spotify":"https://open.spotify.com/track/6j1uMbZbGuiiCmiRrdiMQx"},"href":"https://api.spotify.com/v1/tracks/6j1uMbZbGuiiCmiRrdiMQx","id":"6j1uMbZbGuiiCmiRrdiMQx","is_local":false,"is_playable":true,"name":"My Funny Valentine","track_number":6,"type":"track","uri":"spotify:track:6j1uMbZbGuiiCmiRrdiMQx"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"external_urls":{"spotify":"https://open.spotify.com/album/3bqa61Es7d24madvFCTSBF"},"href":"https://api.spotify.com/v1/albums/3bqa61Es7d24madvFCTSBF","id":"3bqa61Es7d24madvFCTSBF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273030cd4daba05c1c6d6f31702"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02030cd4daba05c1c6d6f31702"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851030cd4daba05c1c6d6f31702"}],"is_playable":true,"name":"Summer Jazz: Chet Baker","release_date":"2026-07-09","release_date_precision":"day","total_tracks":76,"type":"album","uri":"spotify:album:3bqa61Es7d24madvFCTSBF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"disc_number":1,"duration_ms":139586,"explicit":false,"external_ids":{"isrc":"USBN28900073"},"external_urls":{"spotify":"https://open.spotify.com/track/1XBXuRtAjUyO5tuaFLpAGW"},"href":"https://api.spotify.com/v1/tracks/1XBXuRtAjUyO5tuaFLpAGW","id":"1XBXuRtAjUyO5tuaFLpAGW","is_local":false,"is_playable":true,"name":"My Funny Valentine","track_number":2,"type":"track","uri":"spotify:track:1XBXuRtAjUyO5tuaFLpAGW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"external_urls":{"spotify":"https://open.spotify.com/album/21gf3HBlRMM9wzcZepFdS8"},"href":"https://api.spotify.com/v1/albums/21gf3HBlRMM9wzcZepFdS8","id":"21gf3HBlRMM9wzcZepFdS8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732b62c80e5a90f7323b6e6316"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022b62c80e5a90f7323b6e6316"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512b62c80e5a90f7323b6e6316"}],"is_playable":true,"name":"Chet Sings!","release_date":"2013-05-20","release_date_precision":"day","total_tracks":44,"type":"album","uri":"spotify:album:21gf3HBlRMM9wzcZepFdS8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rxeQlsv0Sc2nyYaZ5W71T"},"href":"https://api.spotify.com/v1/artists/3rxeQlsv0Sc2nyYaZ5W71T","id":"3rxeQlsv0Sc2nyYaZ5W71T","name":"Chet Baker","type":"artist","uri":"spotify:artist:3rxeQlsv0Sc2nyYaZ5W71T"}],"disc_number":1,"duration_ms":146080,"explicit":false,"external_ids":{"isrc":"FRZ335419020"},"external_urls":{"spotify":"https://open.spotify.com/track/4km45kiPGKmaooOCgg0z5e"},"href":"https://api.spotify.com/v1/tracks/4km45kiPGKmaooOCgg0z5e","id":"4km45kiPGKmaooOCgg0z5e","is_local":false,"is_playable":true,"name":"My Funny Valentine","track_number":7,"type":"track","uri":"spotify:track:4km45kiPGKmaooOCgg0z5e"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk15JTIwRnVubnklMjBWYWxlbnRpbmUlMjIlMjBhcnRpc3QlM0ElMjJDaGV0JTIwQmFrZXIlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjksIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNyeGVRbHN2MFNjMm55WWFaNVc3MVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCIsImlkIjoiM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCIsIm5hbWUiOiJDaGV0IEJha2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNyeGVRbHN2MFNjMm55WWFaNVc3MVQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81Sko3NzlucmJIeDBLQjJsQnJNTWE0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUpKNzc5bnJiSHgwS0IybEJyTU1hNCIsImlkIjoiNUpKNzc5bnJiSHgwS0IybEJyTU1hNCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmMTJmOGUzM2UzNzdiYTExOWVjYmQyNmIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjEyZjhlMzNlMzc3YmExMTllY2JkMjZiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmMTJmOGUzM2UzNzdiYTExOWVjYmQyNmIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2hldCBCYWtlciBTaW5ncyIsInJlbGVhc2VfZGF0ZSI6IjE5NTYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUpKNzc5bnJiSHgwS0IybEJyTU1hNCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNyeGVRbHN2MFNjMm55WWFaNVc3MVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCIsImlkIjoiM3J4ZVFscw==", + "djBTYzJueVlhWjVXNzFUIiwibmFtZSI6IkNoZXQgQmFrZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDExMzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0JOMjg5MDAwNzMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRsOWhtbDJVQ254b05JM3lDZEwxQlcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80bDlobWwyVUNueG9OSTN5Q2RMMUJXIiwiaWQiOiI0bDlobWwyVUNueG9OSTN5Q2RMMUJXIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik15IEZ1bm55IFZhbGVudGluZSIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGw5aG1sMlVDbnhvTkkzeUNkTDFCVyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJpZCI6IjNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJuYW1lIjoiQ2hldCBCYWtlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozcnhlUWxzdjBTYzJueVlhWjVXNzFUIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNXJiM0xsUGxTNEwzcVBId3hSVlVNTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVyYjNMbFBsUzRMM3FQSHd4UlZVTUwiLCJpZCI6IjVyYjNMbFBsUzRMM3FQSHd4UlZVTUwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTkzYzI4MDY4M2MzOWI0NDllMmIyYTQwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmE5M2MyODA2ODNjMzliNDQ5ZTJiMmE0MCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTkzYzI4MDY4M2MzOWI0NDllMmIyYTQwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxldCdzIEdldCBMb3N0OiBUaGUgQmVzdCBPZiBDaA==", + "ZXQgQmFrZXIgU2luZ3MiLCJyZWxlYXNlX2RhdGUiOiIxOTg5LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NXJiM0xsUGxTNEwzcVBId3hSVlVNTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNyeGVRbHN2MFNjMm55WWFaNVc3MVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCIsImlkIjoiM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCIsIm5hbWUiOiJDaGV0IEJha2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNyeGVRbHN2MFNjMm55WWFaNVc3MVQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQwMDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNCTjI4OTAwMDczIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wZ3YxbEFHMUtINnhlelNlMjBieG9WIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGd2MWxBRzFLSDZ4ZXpTZTIwYnhvViIsImlkIjoiMGd2MWxBRzFLSDZ4ZXpTZTIwYnhvViIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNeSBGdW5ueSBWYWxlbnRpbmUiLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGd2MWxBRzFLSDZ4ZXpTZTIwYnhvViJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJpZCI6IjNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJuYW1lIjoiQ2hldCBCYWtlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozcnhlUWxzdjBTYzJueVlhWjVXNzFUIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUJ5YnM1QUZUMm5QNTVBbFAyN2QwcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVCeWJzNUFGVDJuUDU1QWxQMjdkMHEiLCJpZCI6IjVCeWJzNUFGVDJuUDU1QWxQMjdkMHEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOg==", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0YTNhZTE5NzIxODU2MjA4MjEwYzFiMzMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNGEzYWUxOTcyMTg1NjIwODIxMGMxYjMzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0YTNhZTE5NzIxODU2MjA4MjEwYzFiMzMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2hldCBCYWtlciBJbiBUb2t5byAoVGhlIENvbXBsZXRlIENvbmNlcnQpIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wMi0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVCeWJzNUFGVDJuUDU1QWxQMjdkMHEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJpZCI6IjNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJuYW1lIjoiQ2hldCBCYWtlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozcnhlUWxzdjBTYzJueVlhWjVXNzFUIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjc5NDUyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlRDQUNFMTUwNzkyOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMkhNV2pOdkFKeVY2UzZrZzM2NWVoMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJITVdqTnZBSnlWNlM2a2czNjVlaDIiLCJpZCI6IjJITVdqTnZBSnlWNlM2a2czNjVlaDIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTXkgRnVubnkgVmFsZW50aW5lIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoySE1Xak52QUp5VjZTNmtnMzY1ZWgyIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNyeGVRbHN2MFNjMm55WWFaNVc3MVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCIsImlkIjoiM3J4ZVFscw==", + "djBTYzJueVlhWjVXNzFUIiwibmFtZSI6IkNoZXQgQmFrZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFXVWxPV3dDbUxldk9pNlFTa0RrT1YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xV1VsT1d3Q21MZXZPaTZRU2tEa09WIiwiaWQiOiIxV1VsT1d3Q21MZXZPaTZRU2tEa09WIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2U2ZmJiY2ExMzBiNWIzMDU0MzNiNTMwNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlNmZiYmNhMTMwYjViMzA1NDMzYjUzMDQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWU2ZmJiY2ExMzBiNWIzMDU0MzNiNTMwNCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTaW5ncyBBZ2FpbiIsInJlbGVhc2VfZGF0ZSI6IjE5ODYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6OCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxV1VsT1d3Q21MZXZPaTZRU2tEa09WIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwiaWQiOiIzcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwibmFtZSI6IkNoZXQgQmFrZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MzUwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEE0MTA4MTQ3MTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzViTkw5MldkWmtTVGxFZjVyUjgyeHQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81Yk5MOTJXZFprU1RsRWY1clI4Mnh0IiwiaWQiOiI1Yk5MOTJXZFprU1RsRWY1clI4Mnh0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik15IEZ1bm55IFZhbGVudGluZSIsIg==", + "dHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjViTkw5MldkWmtTVGxFZjVyUjgyeHQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwiaWQiOiIzcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwibmFtZSI6IkNoZXQgQmFrZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJhUlk3cmJXS2w2cXRQSWprWHZPc0sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yYVJZN3JiV0tsNnF0UElqa1h2T3NLIiwiaWQiOiIyYVJZN3JiV0tsNnF0UElqa1h2T3NLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FmYTRiMThiODE3OTRkNzIxMWQ4NjAzNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhZmE0YjE4YjgxNzk0ZDcyMTFkODYwMzUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFmYTRiMThiODE3OTRkNzIxMWQ4NjAzNSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNeSBGdW5ueSBWYWxlbnRpbmUiLCJyZWxlYXNlX2RhdGUiOiIxOTk0LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MmFSWTdyYldLbDZxdFBJamtYdk9zSyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNyeGVRbHN2MFNjMm55WWFaNVc3MVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCIsImlkIjoiM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCIsIm5hbWUiOiJDaGV0IEJha2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNyeGVRbHN2MFNjMm55WWFaNVc3MVQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQwMw==", + "NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0JOMjg5MDAwNzMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZXR3k5V2RZV095eWlwQlc3dHJwNUkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82V0d5OVdkWVdPeXlpcEJXN3RycDVJIiwiaWQiOiI2V0d5OVdkWVdPeXlpcEJXN3RycDVJIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik15IEZ1bm55IFZhbGVudGluZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2V0d5OVdkWVdPeXlpcEJXN3RycDVJIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJpZCI6IjNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJuYW1lIjoiQ2hldCBCYWtlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozcnhlUWxzdjBTYzJueVlhWjVXNzFUIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMHdzY1QybmlrVUt1SXVreEpGSjdxdiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzB3c2NUMm5pa1VLdUl1a3hKRko3cXYiLCJpZCI6IjB3c2NUMm5pa1VLdUl1a3hKRko3cXYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjM4MTk5Y2Q5OWUyYzFhNzk4OWM3ZTIyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjIzODE5OWNkOTllMmMxYTc5ODljN2UyMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjM4MTk5Y2Q5OWUyYzFhNzk4OWM3ZTIyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik15IEZ1bm55IFZhbGVudGluZSAoU3R1ZGlvIEphcGFuICc2OSkiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTAyLTIwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowd3NjVDJuaWtVS3VJdWt4SkZKNw==", + "cXYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJpZCI6IjNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJuYW1lIjoiQ2hldCBCYWtlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozcnhlUWxzdjBTYzJueVlhWjVXNzFUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZwVmtHaHRCdmpqMVA1MnluMHROTEcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnBWa0dodEJ2amoxUDUyeW4wdE5MRyIsImlkIjoiNnBWa0dodEJ2amoxUDUyeW4wdE5MRyIsIm5hbWUiOiJCYXJuZXkgS2Vzc2VsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZwVmtHaHRCdmpqMVA1MnluMHROTEcifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjlON1dNMUExejZ6dUpHNUFpaThhbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yOU43V00xQTF6Nnp1Skc1QWlpOGFvIiwiaWQiOiIyOU43V00xQTF6Nnp1Skc1QWlpOGFvIiwibmFtZSI6IkZyYW5rIENhcHAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjlON1dNMUExejZ6dUpHNUFpaThhbyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80MzloOWl0MlkzbFYwWGYwWWFzeHdGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzQzOWg5aXQyWTNsVjBYZjBZYXN4d0YiLCJpZCI6IjQzOWg5aXQyWTNsVjBYZjBZYXN4d0YiLCJuYW1lIjoiUGF1bCBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0MzloOWl0MlkzbFYwWGYwWWFzeHdGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE1MTU3NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQTJQMjYwOTI2NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGNVQTB2c1hNOE1HRXg3cDhqYVEyMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRjVUEwdnNYTThNR0V4N3A4amFRMjMiLCJpZCI6IjRjVUEwdnNYTThNR0V4N3A4amFRMjMiLCJpc19sb2NhbCI6ZmFsc2UsImlzXw==", + "cGxheWFibGUiOnRydWUsIm5hbWUiOiJNeSBGdW5ueSBWYWxlbnRpbmUgKFN0dWRpbyBKYXBhbiAnNjkpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRjVUEwdnNYTThNR0V4N3A4amFRMjMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNG1iOFpWSTVNbUFBcFk3OTA5ajVZSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRtYjhaVkk1TW1BQXBZNzkwOWo1WUsiLCJpZCI6IjRtYjhaVkk1TW1BQXBZNzkwOWo1WUsiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDgwYmQ4NGQ4YTc0YzhlMWVhYWVhZDZhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA4MGJkODRkOGE3NGM4ZTFlYWFlYWQ2YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDgwYmQ4NGQ4YTc0YzhlMWVhYWVhZDZhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlIFp3YXJ0ZSBMaWpzdCIsInJlbGVhc2VfZGF0ZSI6IjIwMTItMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0bWI4WlZJNU1tQUFwWTc5MDlqNVlLIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwiaWQiOiIzcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwibmFtZSI6IkNoZXQgQmFrZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcg==", + "dGlzdDozcnhlUWxzdjBTYzJueVlhWjVXNzFUIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEzNjg4MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQk4yODkwMDA3MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNmoxdU1iWmJHdWlpQ21pUnJkaU1ReCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZqMXVNYlpiR3VpaUNtaVJyZGlNUXgiLCJpZCI6IjZqMXVNYlpiR3VpaUNtaVJyZGlNUXgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTXkgRnVubnkgVmFsZW50aW5lIiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZqMXVNYlpiR3VpaUNtaVJyZGlNUXgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwiaWQiOiIzcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwibmFtZSI6IkNoZXQgQmFrZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNicWE2MUVzN2QyNG1hZHZGQ1RTQkYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zYnFhNjFFczdkMjRtYWR2RkNUU0JGIiwiaWQiOiIzYnFhNjFFczdkMjRtYWR2RkNUU0JGIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzAzMGNkNGRhYmEwNWMxYzZkNmYzMTcwMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwMzBjZDRkYWJhMDVjMWM2ZDZmMzE3MDIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAzMGNkNGRhYmEwNWMxYzZkNmYzMTcwMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW1tZXIgSmF6ejogQ2hldCBCYWtlciIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDctMDkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3NiwidHlwZQ==", + "IjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNicWE2MUVzN2QyNG1hZHZGQ1RTQkYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJpZCI6IjNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJuYW1lIjoiQ2hldCBCYWtlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozcnhlUWxzdjBTYzJueVlhWjVXNzFUIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEzOTU4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQk4yODkwMDA3MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVhCWHVSdEFqVXlPNXR1YUZMcEFHVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFYQlh1UnRBalV5TzV0dWFGTHBBR1ciLCJpZCI6IjFYQlh1UnRBalV5TzV0dWFGTHBBR1ciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTXkgRnVubnkgVmFsZW50aW5lIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFYQlh1UnRBalV5TzV0dWFGTHBBR1cifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwiaWQiOiIzcnhlUWxzdjBTYzJueVlhWjVXNzFUIiwibmFtZSI6IkNoZXQgQmFrZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3J4ZVFsc3YwU2MybnlZYVo1VzcxVCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzIxZ2YzSEJsUk1NOXd6Y1plcEZkUzgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yMWdmM0hCbFJNTTl3emNaZXBGZFM4IiwiaWQiOiIyMWdmM0hCbFJNTTl3emNaZXBGZFM4IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzJiNjJjODBlNWE5MGY3MzIzYjZlNjMxNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMA==", + "MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjJiNjJjODBlNWE5MGY3MzIzYjZlNjMxNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMmI2MmM4MGU1YTkwZjczMjNiNmU2MzE2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNoZXQgU2luZ3MhIiwicmVsZWFzZV9kYXRlIjoiMjAxMy0wNS0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjIxZ2YzSEJsUk1NOXd6Y1plcEZkUzgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zcnhlUWxzdjBTYzJueVlhWjVXNzFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJpZCI6IjNyeGVRbHN2MFNjMm55WWFaNVc3MVQiLCJuYW1lIjoiQ2hldCBCYWtlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozcnhlUWxzdjBTYzJueVlhWjVXNzFUIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0NjA4MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkZSWjMzNTQxOTAyMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGttNDVraVBHS21hb29PQ2dnMHo1ZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRrbTQ1a2lQR0ttYW9vT0NnZzB6NWUiLCJpZCI6IjRrbTQ1a2lQR0ttYW9vT0NnZzB6NWUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTXkgRnVubnkgVmFsZW50aW5lIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRrbTQ1a2lQR0ttYW9vT0NnZzB6NWUifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22My+Funny+Valentine%22+artist%3A%22Chet+Baker%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Feels%20So%20Good%22%20artist%3A%22Chuck%20Mangione%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"external_urls":{"spotify":"https://open.spotify.com/album/5w0p1F0Q1wBqsX2UiX6CCD"},"href":"https://api.spotify.com/v1/albums/5w0p1F0Q1wBqsX2UiX6CCD","id":"5w0p1F0Q1wBqsX2UiX6CCD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e2c1f7c1ee0ee027f41178fd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e2c1f7c1ee0ee027f41178fd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e2c1f7c1ee0ee027f41178fd"}],"is_playable":true,"name":"Feels So Good","release_date":"1977-12-08","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:5w0p1F0Q1wBqsX2UiX6CCD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"disc_number":1,"duration_ms":582733,"explicit":false,"external_ids":{"isrc":"USAM17700535"},"external_urls":{"spotify":"https://open.spotify.com/track/2M7EflZCPCqqRLB9hy5MDy"},"href":"https://api.spotify.com/v1/tracks/2M7EflZCPCqqRLB9hy5MDy","id":"2M7EflZCPCqqRLB9hy5MDy","is_local":false,"is_playable":true,"name":"Feels So Good","track_number":1,"type":"track","uri":"spotify:track:2M7EflZCPCqqRLB9hy5MDy"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"external_urls":{"spotify":"https://open.spotify.com/album/5XE8vtggnS9ZkYHcozaTkf"},"href":"https://api.spotify.com/v1/albums/5XE8vtggnS9ZkYHcozaTkf","id":"5XE8vtggnS9ZkYHcozaTkf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ec6fb78620ab4ce3226e28c0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ec6fb78620ab4ce3226e28c0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ec6fb78620ab4ce3226e28c0"}],"is_playable":true,"name":"A&M Gold Series","release_date":"1991-02-18","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:5XE8vtggnS9ZkYHcozaTkf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"disc_number":1,"duration_ms":212226,"explicit":false,"external_ids":{"isrc":"USUMG9900628"},"external_urls":{"spotify":"https://open.spotify.com/track/6C2nRgaujO84uuHZkaXcZQ"},"href":"https://api.spotify.com/v1/tracks/6C2nRgaujO84uuHZkaXcZQ","id":"6C2nRgaujO84uuHZkaXcZQ","is_local":false,"is_playable":true,"name":"Feels So Good - Single Version","track_number":1,"type":"track","uri":"spotify:track:6C2nRgaujO84uuHZkaXcZQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"external_urls":{"spotify":"https://open.spotify.com/album/5vW74KuhzOdHWGw1pVbiBJ"},"href":"https://api.spotify.com/v1/albums/5vW74KuhzOdHWGw1pVbiBJ","id":"5vW74KuhzOdHWGw1pVbiBJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27332a3be7acbc3cef13035bcfc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0232a3be7acbc3cef13035bcfc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485132a3be7acbc3cef13035bcfc"}],"is_playable":true,"name":"An Evening Of Magic: Live At The Hollywood Bowl","release_date":"1979-01-01","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:5vW74KuhzOdHWGw1pVbiBJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"disc_number":1,"duration_ms":557493,"explicit":false,"external_ids":{"isrc":"USUMG9900336"},"external_urls":{"spotify":"https://open.spotify.com/track/6XpxQeIkCPYIRQVQYBvQsI"},"href":"https://api.spotify.com/v1/tracks/6XpxQeIkCPYIRQVQYBvQsI","id":"6XpxQeIkCPYIRQVQYBvQsI","is_local":false,"is_playable":true,"name":"Feels So Good - Live (1978/Hollywood Bowl)","track_number":1,"type":"track","uri":"spotify:track:6XpxQeIkCPYIRQVQYBvQsI"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"external_urls":{"spotify":"https://open.spotify.com/album/1LYIjW0R2Ot8qFE4e6lG06"},"href":"https://api.spotify.com/v1/albums/1LYIjW0R2Ot8qFE4e6lG06","id":"1LYIjW0R2Ot8qFE4e6lG06","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b16684b83cfbf8200f4868e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b16684b83cfbf8200f4868e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b16684b83cfbf8200f4868e8"}],"is_playable":true,"name":"Chuck Mangione: Finest Hour","release_date":"2000-01-01","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:1LYIjW0R2Ot8qFE4e6lG06"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"disc_number":1,"duration_ms":576693,"explicit":false,"external_ids":{"isrc":"USAM17700535"},"external_urls":{"spotify":"https://open.spotify.com/track/6fK7yKIMmXbymQyyTw9wWA"},"href":"https://api.spotify.com/v1/tracks/6fK7yKIMmXbymQyyTw9wWA","id":"6fK7yKIMmXbymQyyTw9wWA","is_local":false,"is_playable":true,"name":"Feels So Good","track_number":1,"type":"track","uri":"spotify:track:6fK7yKIMmXbymQyyTw9wWA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"external_urls":{"spotify":"https://open.spotify.com/album/66TlfKsV44SEGSUz2Z944h"},"href":"https://api.spotify.com/v1/albums/66TlfKsV44SEGSUz2Z944h","id":"66TlfKsV44SEGSUz2Z944h","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738c954364d63746b4a8f1a9fc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028c954364d63746b4a8f1a9fc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518c954364d63746b4a8f1a9fc"}],"is_playable":true,"name":"70 Miles Young","release_date":"1982-01-01","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:66TlfKsV44SEGSUz2Z944h"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"disc_number":1,"duration_ms":253706,"explicit":false,"external_ids":{"isrc":"USUM71302212"},"external_urls":{"spotify":"https://open.spotify.com/track/4VNGgj7yspzXGFUAYytO4R"},"href":"https://api.spotify.com/v1/tracks/4VNGgj7yspzXGFUAYytO4R","id":"4VNGgj7yspzXGFUAYytO4R","is_local":false,"is_playable":true,"name":"Feels So Good - Vocal","track_number":5,"type":"track","uri":"spotify:track:4VNGgj7yspzXGFUAYytO4R"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"external_urls":{"spotify":"https://open.spotify.com/album/5vW74KuhzOdHWGw1pVbiBJ"},"href":"https://api.spotify.com/v1/albums/5vW74KuhzOdHWGw1pVbiBJ","id":"5vW74KuhzOdHWGw1pVbiBJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27332a3be7acbc3cef13035bcfc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0232a3be7acbc3cef13035bcfc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485132a3be7acbc3cef13035bcfc"}],"is_playable":true,"name":"An Evening Of Magic: Live At The Hollywood Bowl","release_date":"1979-01-01","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:5vW74KuhzOdHWGw1pVbiBJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"disc_number":2,"duration_ms":194040,"explicit":false,"external_ids":{"isrc":"USUMG9900350"},"external_urls":{"spotify":"https://open.spotify.com/track/2bfpqDZ4ALZT9CvQ3gEFeV"},"href":"https://api.spotify.com/v1/tracks/2bfpqDZ4ALZT9CvQ3gEFeV","id":"2bfpqDZ4ALZT9CvQ3gEFeV","is_local":false,"is_playable":true,"name":"Feels So Good - Encore-Live (1978/Hollywood Bowl)","track_number":8,"type":"track","uri":"spotify:track:2bfpqDZ4ALZT9CvQ3gEFeV"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"external_urls":{"spotify":"https://open.spotify.com/album/6rowBxfbNlzD7fEWPVdODl"},"href":"https://api.spotify.com/v1/albums/6rowBxfbNlzD7fEWPVdODl","id":"6rowBxfbNlzD7fEWPVdODl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739a448dcf5cc0826495d3a38b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029a448dcf5cc0826495d3a38b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519a448dcf5cc0826495d3a38b"}],"is_playable":true,"name":"Greatest Hits","release_date":"1987-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:6rowBxfbNlzD7fEWPVdODl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"disc_number":1,"duration_ms":577546,"explicit":false,"external_ids":{"isrc":"USAM17700535"},"external_urls":{"spotify":"https://open.spotify.com/track/78q4M572uVVGupDBUePFZ2"},"href":"https://api.spotify.com/v1/tracks/78q4M572uVVGupDBUePFZ2","id":"78q4M572uVVGupDBUePFZ2","is_local":false,"is_playable":true,"name":"Feels So Good","track_number":1,"type":"track","uri":"spotify:track:78q4M572uVVGupDBUePFZ2"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1T7Z7CUlMsaRJtnLeOvlDj"},"href":"https://api.spotify.com/v1/albums/1T7Z7CUlMsaRJtnLeOvlDj","id":"1T7Z7CUlMsaRJtnLeOvlDj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27377d52e9d0c6a2fc8b6983241"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0277d52e9d0c6a2fc8b6983241"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485177d52e9d0c6a2fc8b6983241"}],"is_playable":true,"name":"Smooth Jazz","release_date":"2020-02-21","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:1T7Z7CUlMsaRJtnLeOvlDj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"disc_number":1,"duration_ms":576693,"explicit":false,"external_ids":{"isrc":"USAM17700535"},"external_urls":{"spotify":"https://open.spotify.com/track/41rXP0kqfKLGCs4roasGIL"},"href":"https://api.spotify.com/v1/tracks/41rXP0kqfKLGCs4roasGIL","id":"41rXP0kqfKLGCs4roasGIL","is_local":false,"is_playable":true,"name":"Feels So Good","track_number":15,"type":"track","uri":"spotify:track:41rXP0kqfKLGCs4roasGIL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2ohcAAeqSLEC2JrPTxlLFW"},"href":"https://api.spotify.com/v1/albums/2ohcAAeqSLEC2JrPTxlLFW","id":"2ohcAAeqSLEC2JrPTxlLFW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737bb3479a7f8bb26b1bc19d98"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027bb3479a7f8bb26b1bc19d98"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517bb3479a7f8bb26b1bc19d98"}],"is_playable":true,"name":"Music Therapy","release_date":"2021-03-12","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:2ohcAAeqSLEC2JrPTxlLFW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2MMaIlHd8UvDW0mVRAncD6"},"href":"https://api.spotify.com/v1/artists/2MMaIlHd8UvDW0mVRAncD6","id":"2MMaIlHd8UvDW0mVRAncD6","name":"Chuck Mangione","type":"artist","uri":"spotify:artist:2MMaIlHd8UvDW0mVRAncD6"}],"disc_number":1,"duration_ms":576693,"explicit":false,"external_ids":{"isrc":"USAM17700535"},"external_urls":{"spotify":"https://open.spotify.com/track/5OqidDorx8sLbGwCApjtfk"},"href":"https://api.spotify.com/v1/tracks/5OqidDorx8sLbGwCApjtfk","id":"5OqidDorx8sLbGwCApjtfk","is_local":false,"is_playable":true,"name":"Feels So Good","track_number":20,"type":"track","uri":"spotify:track:5OqidDorx8sLbGwCApjtfk"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZlZWxzJTIwU28lMjBHb29kJTIyJTIwYXJ0aXN0JTNBJTIyQ2h1Y2slMjBNYW5naW9uZSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwiaWQiOiIyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwibmFtZSI6IkNodWNrIE1hbmdpb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81dzBwMUYwUTF3QnFzWDJVaVg2Q0NEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNXcwcDFGMFExd0Jxc1gyVWlYNkNDRCIsImlkIjoiNXcwcDFGMFExd0Jxc1gyVWlYNkNDRCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlMmMxZjdjMWVlMGVlMDI3ZjQxMTc4ZmQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTJjMWY3YzFlZTBlZTAyN2Y0MTE3OGZkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlMmMxZjdjMWVlMGVlMDI3ZjQxMTc4ZmQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmVlbHMgU28gR29vZCIsInJlbGVhc2VfZGF0ZSI6IjE5NzctMTItMDgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjV3MHAxRjBRMXdCcXNYMlVpWDZDQ0QifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJNTWFJbEhkOFV2RFcwbVZSQW5jRDYiLCJpZCI6IjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYiLCJuYW1lIjoiQ2h1Y2sgTWFuZ2lvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo1ODI3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FNMTc3MDA1MzUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJNN0VmbFpDUENxcVJMQjloeTVNRHkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yTTdFZmxaQ1BDcXFSTEI5aHk1TUR5IiwiaWQiOiIyTTdFZmxaQ1BDcXFSTEI5aHk1TUR5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZlZWxzIFNvIEdvb2QiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mk03RWZsWkNQQ3FxUkxCOWh5NU1EeSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJNTWFJbEhkOFV2RFcwbVZSQW5jRDYiLCJpZCI6IjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYiLCJuYW1lIjoiQw==", + "aHVjayBNYW5naW9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVhFOHZ0Z2duUzlaa1lIY296YVRrZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVYRTh2dGdnblM5WmtZSGNvemFUa2YiLCJpZCI6IjVYRTh2dGdnblM5WmtZSGNvemFUa2YiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZWM2ZmI3ODYyMGFiNGNlMzIyNmUyOGMwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmVjNmZiNzg2MjBhYjRjZTMyMjZlMjhjMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZWM2ZmI3ODYyMGFiNGNlMzIyNmUyOGMwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkEmTSBHb2xkIFNlcmllcyIsInJlbGVhc2VfZGF0ZSI6IjE5OTEtMDItMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1WEU4dnRnZ25TOVprWUhjb3phVGtmIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwiaWQiOiIyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwibmFtZSI6IkNodWNrIE1hbmdpb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjEyMjI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTUc5OTAwNjI4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82QzJuUmdhdWpPODR1dUhaa2FYY1pRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNkMyblJnYXVqTzg0dXVIWmthWGNaUSIsImlkIjoiNkMyblJnYXVqTzg0dXVIWmthWGNaUSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGZWVscyBTbyBHb29kIC0gU2luZ2xlIFZlcnNpbw==", + "biIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2QzJuUmdhdWpPODR1dUhaa2FYY1pRIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiIsImlkIjoiMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiIsIm5hbWUiOiJDaHVjayBNYW5naW9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNXZXNzRLdWh6T2RIV0d3MXBWYmlCSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzV2Vzc0S3Voek9kSFdHdzFwVmJpQkoiLCJpZCI6IjV2Vzc0S3Voek9kSFdHdzFwVmJpQkoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzJhM2JlN2FjYmMzY2VmMTMwMzViY2ZjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjMyYTNiZTdhY2JjM2NlZjEzMDM1YmNmYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzJhM2JlN2FjYmMzY2VmMTMwMzViY2ZjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFuIEV2ZW5pbmcgT2YgTWFnaWM6IExpdmUgQXQgVGhlIEhvbGx5d29vZCBCb3dsIiwicmVsZWFzZV9kYXRlIjoiMTk3OS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjV2Vzc0S3Voek9kSFdHdzFwVmJpQkoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJNTWFJbEhkOFV2RFcwbVZSQW5jRDYiLCJpZCI6IjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYiLCJuYW1lIjoiQ2h1Y2sgTWFuZ2lvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9XQ==", + "LCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjU1NzQ5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU1HOTkwMDMzNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNlhweFFlSWtDUFlJUlFWUVlCdlFzSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZYcHhRZUlrQ1BZSVJRVlFZQnZRc0kiLCJpZCI6IjZYcHhRZUlrQ1BZSVJRVlFZQnZRc0kiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmVlbHMgU28gR29vZCAtIExpdmUgKDE5NzgvSG9sbHl3b29kIEJvd2wpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZYcHhRZUlrQ1BZSVJRVlFZQnZRc0kifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwiaWQiOiIyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwibmFtZSI6IkNodWNrIE1hbmdpb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xTFlJalcwUjJPdDhxRkU0ZTZsRzA2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUxZSWpXMFIyT3Q4cUZFNGU2bEcwNiIsImlkIjoiMUxZSWpXMFIyT3Q4cUZFNGU2bEcwNiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiMTY2ODRiODNjZmJmODIwMGY0ODY4ZTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjE2Njg0YjgzY2ZiZjgyMDBmNDg2OGU4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiMTY2ODRiODNjZmJmODIwMGY0ODY4ZTgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2h1Y2sgTWFuZ2lvbmU6IEZpbmVzdCBIb3VyIiwicmVsZWFzZV9kYXRlIjoiMjAwMC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOg==", + "NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxTFlJalcwUjJPdDhxRkU0ZTZsRzA2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwiaWQiOiIyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwibmFtZSI6IkNodWNrIE1hbmdpb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NTc2NjkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBTTE3NzAwNTM1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82Zks3eUtJTW1YYnltUXl5VHc5d1dBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmZLN3lLSU1tWGJ5bVF5eVR3OXdXQSIsImlkIjoiNmZLN3lLSU1tWGJ5bVF5eVR3OXdXQSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGZWVscyBTbyBHb29kIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZmSzd5S0lNbVhieW1ReXlUdzl3V0EifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwiaWQiOiIyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwibmFtZSI6IkNodWNrIE1hbmdpb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82NlRsZktzVjQ0U0VHU1V6Mlo5NDRoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjZUbGZLc1Y0NFNFR1NVejJaOTQ0aCIsImlkIjoiNjZUbGZLc1Y0NFNFR1NVejJaOTQ0aCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4Yzk1NDM2NGQ2Mzc0NmI0YThmMWE5ZmMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aA==", + "IjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4Yzk1NDM2NGQ2Mzc0NmI0YThmMWE5ZmMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MThjOTU0MzY0ZDYzNzQ2YjRhOGYxYTlmYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiI3MCBNaWxlcyBZb3VuZyIsInJlbGVhc2VfZGF0ZSI6IjE5ODItMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjY2VGxmS3NWNDRTRUdTVXoyWjk0NGgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJNTWFJbEhkOFV2RFcwbVZSQW5jRDYiLCJpZCI6IjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYiLCJuYW1lIjoiQ2h1Y2sgTWFuZ2lvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTM3MDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzEzMDIyMTIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRWTkdnajd5c3B6WEdGVUFZeXRPNFIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80Vk5HZ2o3eXNwelhHRlVBWXl0TzRSIiwiaWQiOiI0Vk5HZ2o3eXNwelhHRlVBWXl0TzRSIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZlZWxzIFNvIEdvb2QgLSBWb2NhbCIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0Vk5HZ2o3eXNwelhHRlVBWXl0TzRSIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiIsImlkIjoiMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiIsIm5hbWUiOiJDaHVjayBNYW5naW9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2In1dLCJleHRlcg==", + "bmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81dlc3NEt1aHpPZEhXR3cxcFZiaUJKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNXZXNzRLdWh6T2RIV0d3MXBWYmlCSiIsImlkIjoiNXZXNzRLdWh6T2RIV0d3MXBWYmlCSiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzMmEzYmU3YWNiYzNjZWYxMzAzNWJjZmMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzJhM2JlN2FjYmMzY2VmMTMwMzViY2ZjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzMmEzYmU3YWNiYzNjZWYxMzAzNWJjZmMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQW4gRXZlbmluZyBPZiBNYWdpYzogTGl2ZSBBdCBUaGUgSG9sbHl3b29kIEJvd2wiLCJyZWxlYXNlX2RhdGUiOiIxOTc5LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NXZXNzRLdWh6T2RIV0d3MXBWYmlCSiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiIsImlkIjoiMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiIsIm5hbWUiOiJDaHVjayBNYW5naW9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2In1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjE5NDA0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU1HOTkwMDM1MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMmJmcHFEWjRBTFpUOUN2UTNnRUZlViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJiZnBxRFo0QUxaVDlDdlEzZ0VGZVYiLCJpZCI6IjJiZnBxRFo0QUxaVDlDdlEzZ0VGZVYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmVlbHMgU28gR29vZCAtIEVuY29yZS1MaXZlICgxOTc4L0hvbGx5d29vZCBCb3dsKSIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIg==", + "LCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJiZnBxRFo0QUxaVDlDdlEzZ0VGZVYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwiaWQiOiIyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwibmFtZSI6IkNodWNrIE1hbmdpb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82cm93QnhmYk5sekQ3ZkVXUFZkT0RsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnJvd0J4ZmJObHpEN2ZFV1BWZE9EbCIsImlkIjoiNnJvd0J4ZmJObHpEN2ZFV1BWZE9EbCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5YTQ0OGRjZjVjYzA4MjY0OTVkM2EzOGIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOWE0NDhkY2Y1Y2MwODI2NDk1ZDNhMzhiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5YTQ0OGRjZjVjYzA4MjY0OTVkM2EzOGIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3JlYXRlc3QgSGl0cyIsInJlbGVhc2VfZGF0ZSI6IjE5ODctMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2cm93QnhmYk5sekQ3ZkVXUFZkT0RsIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwiaWQiOiIyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwibmFtZSI6IkNodWNrIE1hbmdpb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NTc3NTQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybg==", + "YWxfaWRzIjp7ImlzcmMiOiJVU0FNMTc3MDA1MzUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzc4cTRNNTcydVZWR3VwREJVZVBGWjIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83OHE0TTU3MnVWVkd1cERCVWVQRloyIiwiaWQiOiI3OHE0TTU3MnVWVkd1cERCVWVQRloyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZlZWxzIFNvIEdvb2QiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NzhxNE01NzJ1VlZHdXBEQlVlUEZaMiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xVDdaN0NVbE1zYVJKdG5MZU92bERqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVQ3WjdDVWxNc2FSSnRuTGVPdmxEaiIsImlkIjoiMVQ3WjdDVWxNc2FSSnRuTGVPdmxEaiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3N2Q1MmU5ZDBjNmEyZmM4YjY5ODMyNDEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzdkNTJlOWQwYzZhMmZjOGI2OTgzMjQxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3N2Q1MmU5ZDBjNmEyZmM4YjY5ODMyNDEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU21vb3RoIEphenoiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTAyLTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVQ3WjdDVWxNc2FSSnRuTGVPdmxEaiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodA==", + "dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwiaWQiOiIyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2IiwibmFtZSI6IkNodWNrIE1hbmdpb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NTc2NjkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBTTE3NzAwNTM1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80MXJYUDBrcWZLTEdDczRyb2FzR0lMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDFyWFAwa3FmS0xHQ3M0cm9hc0dJTCIsImlkIjoiNDFyWFAwa3FmS0xHQ3M0cm9hc0dJTCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGZWVscyBTbyBHb29kIiwidHJhY2tfbnVtYmVyIjoxNSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0MXJYUDBrcWZLTEdDczRyb2FzR0lMIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJvaGNBQWVxU0xFQzJKclBUeGxMRlcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yb2hjQUFlcVNMRUMySnJQVHhsTEZXIiwiaWQiOiIyb2hjQUFlcVNMRUMySnJQVHhsTEZXIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzdiYjM0NzlhN2Y4YmIyNmIxYmMxOWQ5OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3YmIzNDc5YTdmOGJiMjZiMWJjMTlkOTgifSx7ImhlaWdodCI6NjQsIndpZA==", + "dGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2JiMzQ3OWE3ZjhiYjI2YjFiYzE5ZDk4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik11c2ljIFRoZXJhcHkiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTAzLTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Mm9oY0FBZXFTTEVDMkpyUFR4bExGVyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJNTWFJbEhkOFV2RFcwbVZSQW5jRDYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiIsImlkIjoiMk1NYUlsSGQ4VXZEVzBtVlJBbmNENiIsIm5hbWUiOiJDaHVjayBNYW5naW9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTU1hSWxIZDhVdkRXMG1WUkFuY0Q2In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjU3NjY5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQU0xNzcwMDUzNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNU9xaWREb3J4OHNMYkd3Q0FwanRmayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVPcWlkRG9yeDhzTGJHd0NBcGp0ZmsiLCJpZCI6IjVPcWlkRG9yeDhzTGJHd0NBcGp0ZmsiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmVlbHMgU28gR29vZCIsInRyYWNrX251bWJlciI6MjAsInR5cGUiOiJ0cmFjaw==", + "IiwidXJpIjoic3BvdGlmeTp0cmFjazo1T3FpZERvcng4c0xiR3dDQXBqdGZrIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Feels+So+Good%22+artist%3A%22Chuck+Mangione%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhdGNoJTIwV2hhdCUyMEhhcHBlbnMlMjIlMjBhcnRpc3QlM0ElMjJXZXMlMjBNb250Z29tZXJ5JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wM1loY002Znh5cGZ3Y2tQQ1FWOHBRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzAzWWhjTTZmeHlwZndja1BDUVY4cFEiLCJpZCI6IjAzWWhjTTZmeHlwZndja1BDUVY4cFEiLCJuYW1lIjoiV2VzIE1vbnRnb21lcnkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDNZaGNNNmZ4eXBmd2NrUENRVjhwUSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVaNkRRTU9qckM1REsxcFEzUkJkWjUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81WjZEUU1PanJDNURLMXBRM1JCZFo1IiwiaWQiOiI1WjZEUU1PanJDNURLMXBRM1JCZFo1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaA==", + "dHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmM2OTBkYWY5ODU0ZjNiOTI2N2M5YWViIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZjNjkwZGFmOTg1NGYzYjkyNjdjOWFlYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmM2OTBkYWY5ODU0ZjNiOTI2N2M5YWViIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkEgRGF5IEluIFRoZSBMaWZlIiwicmVsZWFzZV9kYXRlIjoiMTk2Ny0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVaNkRRTU9qckM1REsxcFEzUkJkWjUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wM1loY002Znh5cGZ3Y2tQQ1FWOHBRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzAzWWhjTTZmeHlwZndja1BDUVY4cFEiLCJpZCI6IjAzWWhjTTZmeHlwZndja1BDUVY4cFEiLCJuYW1lIjoiV2VzIE1vbnRnb21lcnkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDNZaGNNNmZ4eXBmd2NrUENRVjhwUSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjQ5NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1dXVzAxMjg5MjYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVtaGY3SktkV2VENzVyRnJ0Vm9IOUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81bWhmN0pLZFdlRDc1ckZydFZvSDlHIiwiaWQiOiI1bWhmN0pLZFdlRDc1ckZydFZvSDlHIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhdGNoIFdoYXQgSGFwcGVucyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1bWhmN0pLZFdlRDc1ckZydFZvSDlHIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzAzWWhjTTZmeHlwZndja1BDUVY4cFEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDNZaGNNNmZ4eXBmd2NrUENRVjhwUSIsImlkIjoiMDNZaGNNNmZ4eXBmd2NrUENRVjhwUSIsIg==", + "bmFtZSI6IldlcyBNb250Z29tZXJ5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjAzWWhjTTZmeHlwZndja1BDUVY4cFEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80UzJjNXB1QmVoN0p4U0NyUTN2VTVkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNFMyYzVwdUJlaDdKeFNDclEzdlU1ZCIsImlkIjoiNFMyYzVwdUJlaDdKeFNDclEzdlU1ZCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5OGI2ODkxYTVjOTY0Y2M0MWExMzY5ZmEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOThiNjg5MWE1Yzk2NGNjNDFhMTM2OWZhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5OGI2ODkxYTVjOTY0Y2M0MWExMzY5ZmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2VzIE1vbnRnb21lcnkncyBGaW5lc3QgSG91ciIsInJlbGVhc2VfZGF0ZSI6IjIwMDAtMDYtMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0UzJjNXB1QmVoN0p4U0NyUTN2VTVkIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDNZaGNNNmZ4eXBmd2NrUENRVjhwUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wM1loY002Znh5cGZ3Y2tQQ1FWOHBRIiwiaWQiOiIwM1loY002Znh5cGZ3Y2tQQ1FWOHBRIiwibmFtZSI6IldlcyBNb250Z29tZXJ5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjAzWWhjTTZmeHlwZndja1BDUVY4cFEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTY1ODAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBTTEwMDAwMDYxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80QzM3b1RzMVZmMXJPRXZZWHNTVHI1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNEMzN29UczFWZjFyT0V2WVhzU1RyNSIsImlkIjoiNEMzN29UczFWZjFyT0V2WVhzU1RyNSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYXRjaCBXaA==", + "YXQgSGFwcGVucyAtIEluc3RydW1lbnRhbCIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0QzM3b1RzMVZmMXJPRXZZWHNTVHI1In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Watch+What+Happens%22+artist%3A%22Wes+Montgomery%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22In%20a%20Sentimental%20Mood%22%20artist%3A%22Duke%20Ellington%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/1OvmilWKtrabJGEpPRlgK5"},"href":"https://api.spotify.com/v1/albums/1OvmilWKtrabJGEpPRlgK5","id":"1OvmilWKtrabJGEpPRlgK5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732def9ef3f6a82c8d6fd8c143"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022def9ef3f6a82c8d6fd8c143"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512def9ef3f6a82c8d6fd8c143"}],"is_playable":true,"name":"Duke Ellington & John Coltrane","release_date":"1963-02","release_date_precision":"month","total_tracks":7,"type":"album","uri":"spotify:album:1OvmilWKtrabJGEpPRlgK5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":1,"duration_ms":255226,"explicit":false,"external_ids":{"isrc":"USMC16351954"},"external_urls":{"spotify":"https://open.spotify.com/track/0E8q2Fx2XuzXCO2NSAppkR"},"href":"https://api.spotify.com/v1/tracks/0E8q2Fx2XuzXCO2NSAppkR","id":"0E8q2Fx2XuzXCO2NSAppkR","is_local":false,"is_playable":true,"name":"In A Sentimental Mood","track_number":1,"type":"track","uri":"spotify:track:0E8q2Fx2XuzXCO2NSAppkR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/1OdEfzojDfuaAKJYu00W0V"},"href":"https://api.spotify.com/v1/albums/1OdEfzojDfuaAKJYu00W0V","id":"1OdEfzojDfuaAKJYu00W0V","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27333fe47ac6297acfb96cd5ef9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0233fe47ac6297acfb96cd5ef9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485133fe47ac6297acfb96cd5ef9"}],"is_playable":true,"name":"Coltrane For Lovers","release_date":"2001-01-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:1OdEfzojDfuaAKJYu00W0V"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":1,"duration_ms":255360,"explicit":false,"external_ids":{"isrc":"USMC16351954"},"external_urls":{"spotify":"https://open.spotify.com/track/44vfx8GSuXfW7Plb8znCPW"},"href":"https://api.spotify.com/v1/tracks/44vfx8GSuXfW7Plb8znCPW","id":"44vfx8GSuXfW7Plb8znCPW","is_local":false,"is_playable":true,"name":"In A Sentimental Mood","track_number":3,"type":"track","uri":"spotify:track:44vfx8GSuXfW7Plb8znCPW"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"}],"external_urls":{"spotify":"https://open.spotify.com/album/16DFutmQC0e4V8etsg5ZGG"},"href":"https://api.spotify.com/v1/albums/16DFutmQC0e4V8etsg5ZGG","id":"16DFutmQC0e4V8etsg5ZGG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736e3dc7a0cd84651f04c4d7e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026e3dc7a0cd84651f04c4d7e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516e3dc7a0cd84651f04c4d7e7"}],"is_playable":true,"name":"The Duke Plays Ellington","release_date":"1954-04-05","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:16DFutmQC0e4V8etsg5ZGG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"}],"disc_number":1,"duration_ms":152886,"explicit":false,"external_ids":{"isrc":"USCA28800757"},"external_urls":{"spotify":"https://open.spotify.com/track/484SnsU9yGBsaHh9byM0AU"},"href":"https://api.spotify.com/v1/tracks/484SnsU9yGBsaHh9byM0AU","id":"484SnsU9yGBsaHh9byM0AU","is_local":false,"is_playable":true,"name":"In A Sentimental Mood","track_number":1,"type":"track","uri":"spotify:track:484SnsU9yGBsaHh9byM0AU"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"}],"external_urls":{"spotify":"https://open.spotify.com/album/69IqSADNlVFMl5KRQsLyvS"},"href":"https://api.spotify.com/v1/albums/69IqSADNlVFMl5KRQsLyvS","id":"69IqSADNlVFMl5KRQsLyvS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c7e16bc025b15a5e5ea8ada9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c7e16bc025b15a5e5ea8ada9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c7e16bc025b15a5e5ea8ada9"}],"is_playable":true,"name":"The Essential Duke Ellington","release_date":"2007-09-04","release_date_precision":"day","total_tracks":37,"type":"album","uri":"spotify:album:69IqSADNlVFMl5KRQsLyvS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"}],"disc_number":1,"duration_ms":196400,"explicit":false,"external_ids":{"isrc":"USSM13500061"},"external_urls":{"spotify":"https://open.spotify.com/track/6znBoYNR3qwvUUqxLg1bzC"},"href":"https://api.spotify.com/v1/tracks/6znBoYNR3qwvUUqxLg1bzC","id":"6znBoYNR3qwvUUqxLg1bzC","is_local":false,"is_playable":true,"name":"In a Sentimental Mood","track_number":13,"type":"track","uri":"spotify:track:6znBoYNR3qwvUUqxLg1bzC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"}],"external_urls":{"spotify":"https://open.spotify.com/album/38NufhOhCETUhjBqZa5w7e"},"href":"https://api.spotify.com/v1/albums/38NufhOhCETUhjBqZa5w7e","id":"38NufhOhCETUhjBqZa5w7e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dcfeabbedc08a581d70f91b8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dcfeabbedc08a581d70f91b8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dcfeabbedc08a581d70f91b8"}],"is_playable":true,"name":"In a Sentimental Mood","release_date":"2018-03-02","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:38NufhOhCETUhjBqZa5w7e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"}],"disc_number":1,"duration_ms":196400,"explicit":false,"external_ids":{"isrc":"USSM13500061"},"external_urls":{"spotify":"https://open.spotify.com/track/1I5qQVVfDx51SogQGm4iKY"},"href":"https://api.spotify.com/v1/tracks/1I5qQVVfDx51SogQGm4iKY","id":"1I5qQVVfDx51SogQGm4iKY","is_local":false,"is_playable":true,"name":"In a Sentimental Mood","track_number":12,"type":"track","uri":"spotify:track:1I5qQVVfDx51SogQGm4iKY"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"}],"external_urls":{"spotify":"https://open.spotify.com/album/5opJBYX9iBcThP1y6RiZUo"},"href":"https://api.spotify.com/v1/albums/5opJBYX9iBcThP1y6RiZUo","id":"5opJBYX9iBcThP1y6RiZUo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27355a4f3698db2fd52ade28f80"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0255a4f3698db2fd52ade28f80"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485155a4f3698db2fd52ade28f80"}],"is_playable":true,"name":"Duke Ellington Essentials","release_date":"2020-02-11","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:5opJBYX9iBcThP1y6RiZUo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"}],"disc_number":1,"duration_ms":150933,"explicit":false,"external_ids":{"isrc":"USCA29900951"},"external_urls":{"spotify":"https://open.spotify.com/track/2Peg8ooJa61fDNNUCdK0eT"},"href":"https://api.spotify.com/v1/tracks/2Peg8ooJa61fDNNUCdK0eT","id":"2Peg8ooJa61fDNNUCdK0eT","is_local":false,"is_playable":true,"name":"In A Sentimental Mood","track_number":1,"type":"track","uri":"spotify:track:2Peg8ooJa61fDNNUCdK0eT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/0hc0DLxQyod6p5UdCjNOJS"},"href":"https://api.spotify.com/v1/albums/0hc0DLxQyod6p5UdCjNOJS","id":"0hc0DLxQyod6p5UdCjNOJS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737b8dba20a2bb033c8ec5adcb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027b8dba20a2bb033c8ec5adcb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517b8dba20a2bb033c8ec5adcb"}],"is_playable":true,"name":"The Gentle Side Of John Coltrane","release_date":"1975-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:0hc0DLxQyod6p5UdCjNOJS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":1,"duration_ms":255560,"explicit":false,"external_ids":{"isrc":"USMC16351954"},"external_urls":{"spotify":"https://open.spotify.com/track/7fal59UR6Y1m62CPMlr1xH"},"href":"https://api.spotify.com/v1/tracks/7fal59UR6Y1m62CPMlr1xH","id":"7fal59UR6Y1m62CPMlr1xH","is_local":false,"is_playable":true,"name":"In A Sentimental Mood","track_number":11,"type":"track","uri":"spotify:track:7fal59UR6Y1m62CPMlr1xH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7nSS8VKmoybBNCGTzUAbYp"},"href":"https://api.spotify.com/v1/albums/7nSS8VKmoybBNCGTzUAbYp","id":"7nSS8VKmoybBNCGTzUAbYp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b5244771e8bfed2ddd75e443"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b5244771e8bfed2ddd75e443"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b5244771e8bfed2ddd75e443"}],"is_playable":true,"name":"Jazz","release_date":"2017-05-26","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:7nSS8VKmoybBNCGTzUAbYp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":1,"duration_ms":255478,"explicit":false,"external_ids":{"isrc":"USMC16351954"},"external_urls":{"spotify":"https://open.spotify.com/track/0CC3ygyCuwysYcvyhkHUiS"},"href":"https://api.spotify.com/v1/tracks/0CC3ygyCuwysYcvyhkHUiS","id":"0CC3ygyCuwysYcvyhkHUiS","is_local":false,"is_playable":true,"name":"In A Sentimental Mood","track_number":19,"type":"track","uri":"spotify:track:0CC3ygyCuwysYcvyhkHUiS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/512DYgzyJJoTQ4tK21BroO"},"href":"https://api.spotify.com/v1/albums/512DYgzyJJoTQ4tK21BroO","id":"512DYgzyJJoTQ4tK21BroO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27381138079e1fd470f0d5073a1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0281138079e1fd470f0d5073a1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485181138079e1fd470f0d5073a1"}],"is_playable":true,"name":"John Coltrane: Ken Burns's Jazz","release_date":"2000-11-07","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:512DYgzyJJoTQ4tK21BroO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":1,"duration_ms":256959,"explicit":false,"external_ids":{"isrc":"USMC16351954"},"external_urls":{"spotify":"https://open.spotify.com/track/3b55AxIlDNOwZu2xCsp6U0"},"href":"https://api.spotify.com/v1/tracks/3b55AxIlDNOwZu2xCsp6U0","id":"3b55AxIlDNOwZu2xCsp6U0","is_local":false,"is_playable":true,"name":"In A Sentimental Mood","track_number":6,"type":"track","uri":"spotify:track:3b55AxIlDNOwZu2xCsp6U0"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2d3wFSFKQX89CZvE3vOuvf"},"href":"https://api.spotify.com/v1/albums/2d3wFSFKQX89CZvE3vOuvf","id":"2d3wFSFKQX89CZvE3vOuvf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737da2b1c416b9e85909ff6af0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027da2b1c416b9e85909ff6af0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517da2b1c416b9e85909ff6af0"}],"is_playable":true,"name":"Carice's Choice","release_date":"2010-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:2d3wFSFKQX89CZvE3vOuvf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4F7Q5NV6h5TSwCainz8S5A"},"href":"https://api.spotify.com/v1/artists/4F7Q5NV6h5TSwCainz8S5A","id":"4F7Q5NV6h5TSwCainz8S5A","name":"Duke Ellington","type":"artist","uri":"spotify:artist:4F7Q5NV6h5TSwCainz8S5A"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":2,"duration_ms":257786,"explicit":false,"external_ids":{"isrc":"USMC16351954"},"external_urls":{"spotify":"https://open.spotify.com/track/185OKuVhBmPVhdufisIS0Z"},"href":"https://api.spotify.com/v1/tracks/185OKuVhBmPVhdufisIS0Z","id":"185OKuVhBmPVhdufisIS0Z","is_local":false,"is_playable":true,"name":"In A Sentimental Mood","track_number":8,"type":"track","uri":"spotify:track:185OKuVhBmPVhdufisIS0Z"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkluJTIwYSUyMFNlbnRpbWVudGFsJTIwTW9vZCUyMiUyMGFydGlzdCUzQSUyMkR1a2UlMjBFbGxpbmd0b24lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRGN1E1TlY2aDVUU3dDYWluejhTNUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsImlkIjoiNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsIm5hbWUiOiJEdWtlIEVsbGluZ3RvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsImlkIjoiMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsIm5hbWUiOiJKb2huIENvbHRyYW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xT3ZtaWxXS3RyYWJKR0VwUFJsZ0s1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMU92bWlsV0t0cmFiSkdFcFBSbGdLNSIsImlkIjoiMU92bWlsV0t0cmFiSkdFcFBSbGdLNSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyZGVmOWVmM2Y2YTgyYzhkNmZkOGMxNDMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmRlZjllZjNmNmE4MmM4ZDZmZDhjMTQzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyZGVmOWVmM2Y2YTgyYzhkNmZkOGMxNDMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRHVrZSBFbGxpbmd0b24gJiBKb2huIENvbHRyYW5lIiwicmVsZWFzZV9kYXRlIg==", + "OiIxOTYzLTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6Im1vbnRoIiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFPdm1pbFdLdHJhYkpHRXBQUmxnSzUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRGN1E1TlY2aDVUU3dDYWluejhTNUEiLCJpZCI6IjRGN1E1TlY2aDVUU3dDYWluejhTNUEiLCJuYW1lIjoiRHVrZSBFbGxpbmd0b24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEY3UTVOVjZoNVRTd0NhaW56OFM1QSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYiLCJpZCI6IjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYiLCJuYW1lIjoiSm9obiBDb2x0cmFuZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1NTIyNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTTUMxNjM1MTk1NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMEU4cTJGeDJYdXpYQ08yTlNBcHBrUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBFOHEyRngyWHV6WENPMk5TQXBwa1IiLCJpZCI6IjBFOHEyRngyWHV6WENPMk5TQXBwa1IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW4gQSBTZW50aW1lbnRhbCBNb29kIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBFOHEyRngyWHV6WENPMk5TQXBwa1IifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIiwiaWQiOiIyaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIiwibmFtZSI6IkpvaG4gQ29sdHJhbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcg==", + "dGlzdDoyaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMU9kRWZ6b2pEZnVhQUtKWXUwMFcwViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFPZEVmem9qRGZ1YUFLSll1MDBXMFYiLCJpZCI6IjFPZEVmem9qRGZ1YUFLSll1MDBXMFYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzNmZTQ3YWM2Mjk3YWNmYjk2Y2Q1ZWY5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjMzZmU0N2FjNjI5N2FjZmI5NmNkNWVmOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzNmZTQ3YWM2Mjk3YWNmYjk2Y2Q1ZWY5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbHRyYW5lIEZvciBMb3ZlcnMiLCJyZWxlYXNlX2RhdGUiOiIyMDAxLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MU9kRWZ6b2pEZnVhQUtKWXUwMFcwViJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRGN1E1TlY2aDVUU3dDYWluejhTNUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsImlkIjoiNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsIm5hbWUiOiJEdWtlIEVsbGluZ3RvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsImlkIjoiMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsIm5hbWUiOiJKb2huIENvbHRyYW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjU1MzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNQzE2MzUxOTU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Ig==", + "aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzQ0dmZ4OEdTdVhmVzdQbGI4em5DUFcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80NHZmeDhHU3VYZlc3UGxiOHpuQ1BXIiwiaWQiOiI0NHZmeDhHU3VYZlc3UGxiOHpuQ1BXIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkluIEEgU2VudGltZW50YWwgTW9vZCIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0NHZmeDhHU3VYZlc3UGxiOHpuQ1BXIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRGN1E1TlY2aDVUU3dDYWluejhTNUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsImlkIjoiNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsIm5hbWUiOiJEdWtlIEVsbGluZ3RvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMTZERnV0bVFDMGU0VjhldHNnNVpHRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzE2REZ1dG1RQzBlNFY4ZXRzZzVaR0ciLCJpZCI6IjE2REZ1dG1RQzBlNFY4ZXRzZzVaR0ciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmUzZGM3YTBjZDg0NjUxZjA0YzRkN2U3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZlM2RjN2EwY2Q4NDY1MWYwNGM0ZDdlNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmUzZGM3YTBjZDg0NjUxZjA0YzRkN2U3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBEdWtlIFBsYXlzIEVsbGluZ3RvbiIsInJlbGVhc2VfZGF0ZSI6IjE5NTQtMDQtMDUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxNkRGdXRtUUMwZTRWOGV0c2c1WkdHIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEY3UTVOVjZoNVRTd0NhaQ==", + "bno4UzVBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRGN1E1TlY2aDVUU3dDYWluejhTNUEiLCJpZCI6IjRGN1E1TlY2aDVUU3dDYWluejhTNUEiLCJuYW1lIjoiRHVrZSBFbGxpbmd0b24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEY3UTVOVjZoNVRTd0NhaW56OFM1QSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTI4ODYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0NBMjg4MDA3NTcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzQ4NFNuc1U5eUdCc2FIaDlieU0wQVUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80ODRTbnNVOXlHQnNhSGg5YnlNMEFVIiwiaWQiOiI0ODRTbnNVOXlHQnNhSGg5YnlNMEFVIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkluIEEgU2VudGltZW50YWwgTW9vZCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0ODRTbnNVOXlHQnNhSGg5YnlNMEFVIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRGN1E1TlY2aDVUU3dDYWluejhTNUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsImlkIjoiNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsIm5hbWUiOiJEdWtlIEVsbGluZ3RvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNjlJcVNBRE5sVkZNbDVLUlFzTHl2UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzY5SXFTQURObFZGTWw1S1JRc0x5dlMiLCJpZCI6IjY5SXFTQURObFZGTWw1S1JRc0x5dlMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzdlMTZiYzAyNWIxNWE1ZTVlYThhZGE5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM3ZTE2YmMwMjViMTVhNWU1ZWE4YWRhOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYg==", + "Njc2MTZkMDAwMDQ4NTFjN2UxNmJjMDI1YjE1YTVlNWVhOGFkYTkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEVzc2VudGlhbCBEdWtlIEVsbGluZ3RvbiIsInJlbGVhc2VfZGF0ZSI6IjIwMDctMDktMDQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2OUlxU0FETmxWRk1sNUtSUXNMeXZTIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIiwiaWQiOiI0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIiwibmFtZSI6IkR1a2UgRWxsaW5ndG9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRGN1E1TlY2aDVUU3dDYWluejhTNUEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk2NDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEzNTAwMDYxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82em5Cb1lOUjNxd3ZVVXF4TGcxYnpDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNnpuQm9ZTlIzcXd2VVVxeExnMWJ6QyIsImlkIjoiNnpuQm9ZTlIzcXd2VVVxeExnMWJ6QyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbiBhIFNlbnRpbWVudGFsIE1vb2QiLCJ0cmFja19udW1iZXIiOjEzLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZ6bkJvWU5SM3F3dlVVcXhMZzFiekMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIiwiaWQiOiI0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIiwibmFtZSI6IkR1a2UgRWxsaW5ndG9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRGN1E1TlY2aDVUU3dDYWluejhTNUEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zOE51ZmhPaENFVFVoakJxWmE1dzdlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMw==", + "OE51ZmhPaENFVFVoakJxWmE1dzdlIiwiaWQiOiIzOE51ZmhPaENFVFVoakJxWmE1dzdlIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2RjZmVhYmJlZGMwOGE1ODFkNzBmOTFiOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkY2ZlYWJiZWRjMDhhNTgxZDcwZjkxYjgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWRjZmVhYmJlZGMwOGE1ODFkNzBmOTFiOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbiBhIFNlbnRpbWVudGFsIE1vb2QiLCJyZWxlYXNlX2RhdGUiOiIyMDE4LTAzLTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MzhOdWZoT2hDRVRVaGpCcVphNXc3ZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRGN1E1TlY2aDVUU3dDYWluejhTNUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsImlkIjoiNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsIm5hbWUiOiJEdWtlIEVsbGluZ3RvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NjQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMzUwMDA2MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUk1cVFWVmZEeDUxU29nUUdtNGlLWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFJNXFRVlZmRHg1MVNvZ1FHbTRpS1kiLCJpZCI6IjFJNXFRVlZmRHg1MVNvZ1FHbTRpS1kiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW4gYSBTZW50aW1lbnRhbCBNb29kIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxSTVxUVZWZkR4NTFTb2dRR200aUtZIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRGN1E1TlY2aDVUU3dDYWlueg==", + "OFM1QSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIiwiaWQiOiI0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIiwibmFtZSI6IkR1a2UgRWxsaW5ndG9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRGN1E1TlY2aDVUU3dDYWluejhTNUEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81b3BKQllYOWlCY1RoUDF5NlJpWlVvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNW9wSkJZWDlpQmNUaFAxeTZSaVpVbyIsImlkIjoiNW9wSkJZWDlpQmNUaFAxeTZSaVpVbyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1NWE0ZjM2OThkYjJmZDUyYWRlMjhmODAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTVhNGYzNjk4ZGIyZmQ1MmFkZTI4ZjgwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1NWE0ZjM2OThkYjJmZDUyYWRlMjhmODAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRHVrZSBFbGxpbmd0b24gRXNzZW50aWFscyIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDItMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1b3BKQllYOWlCY1RoUDF5NlJpWlVvIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIiwiaWQiOiI0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIiwibmFtZSI6IkR1a2UgRWxsaW5ndG9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRGN1E1TlY2aDVUU3dDYWluejhTNUEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTUwOTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNDQTI5OTAwOTUxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yUGVnOG9vSmE2MWZETk5VQ2RLMGVUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMlBlZw==", + "OG9vSmE2MWZETk5VQ2RLMGVUIiwiaWQiOiIyUGVnOG9vSmE2MWZETk5VQ2RLMGVUIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkluIEEgU2VudGltZW50YWwgTW9vZCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyUGVnOG9vSmE2MWZETk5VQ2RLMGVUIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsImlkIjoiMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsIm5hbWUiOiJKb2huIENvbHRyYW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8waGMwREx4UXlvZDZwNVVkQ2pOT0pTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMGhjMERMeFF5b2Q2cDVVZENqTk9KUyIsImlkIjoiMGhjMERMeFF5b2Q2cDVVZENqTk9KUyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3YjhkYmEyMGEyYmIwMzNjOGVjNWFkY2IifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyN2I4ZGJhMjBhMmJiMDMzYzhlYzVhZGNiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3YjhkYmEyMGEyYmIwMzNjOGVjNWFkY2IifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEdlbnRsZSBTaWRlIE9mIEpvaG4gQ29sdHJhbmUiLCJyZWxlYXNlX2RhdGUiOiIxOTc1LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MGhjMERMeFF5b2Q2cDVVZENqTk9KUyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRGN1E1TlY2aDVUU3dDYWluejhTNUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsImlkIjoiNEY3UTVOVg==", + "Nmg1VFN3Q2Fpbno4UzVBIiwibmFtZSI6IkR1a2UgRWxsaW5ndG9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRGN1E1TlY2aDVUU3dDYWluejhTNUEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIiwiaWQiOiIyaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIiwibmFtZSI6IkpvaG4gQ29sdHJhbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTU1NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU01DMTYzNTE5NTQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdmYWw1OVVSNlkxbTYyQ1BNbHIxeEgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83ZmFsNTlVUjZZMW02MkNQTWxyMXhIIiwiaWQiOiI3ZmFsNTlVUjZZMW02MkNQTWxyMXhIIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkluIEEgU2VudGltZW50YWwgTW9vZCIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2ZhbDU5VVI2WTFtNjJDUE1scjF4SCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83blNTOFZLbW95YkJOQ0dUelVBYllwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN25TUzhWS21veWJCTkNHVHpVQWJZcCIsImlkIjoiN25TUzhWS21veWJCTkNHVHpVQWJZcCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiNQ==", + "MjQ0NzcxZThiZmVkMmRkZDc1ZTQ0MyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiNTI0NDc3MWU4YmZlZDJkZGQ3NWU0NDMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI1MjQ0NzcxZThiZmVkMmRkZDc1ZTQ0MyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJKYXp6IiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wNS0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjduU1M4Vkttb3liQk5DR1R6VUFiWXAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRGN1E1TlY2aDVUU3dDYWluejhTNUEiLCJpZCI6IjRGN1E1TlY2aDVUU3dDYWluejhTNUEiLCJuYW1lIjoiRHVrZSBFbGxpbmd0b24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEY3UTVOVjZoNVRTd0NhaW56OFM1QSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYiLCJpZCI6IjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYiLCJuYW1lIjoiSm9obiBDb2x0cmFuZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1NTQ3OCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTTUMxNjM1MTk1NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMENDM3lneUN1d3lzWWN2eWhrSFVpUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBDQzN5Z3lDdXd5c1ljdnloa0hVaVMiLCJpZCI6IjBDQzN5Z3lDdXd5c1ljdnloa0hVaVMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW4gQSBTZW50aW1lbnRhbCBNb29kIiwidHJhY2tfbnVtYmVyIjoxOSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowQ0MzeWd5Q3V3eXNZY3Z5aGtIVWlTIn0seyJhbGJ1bSI6eyJhbA==", + "YnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIiwiaWQiOiIyaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIiwibmFtZSI6IkpvaG4gQ29sdHJhbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzUxMkRZZ3p5SkpvVFE0dEsyMUJyb08ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81MTJEWWd6eUpKb1RRNHRLMjFCcm9PIiwiaWQiOiI1MTJEWWd6eUpKb1RRNHRLMjFCcm9PIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzgxMTM4MDc5ZTFmZDQ3MGYwZDUwNzNhMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4MTEzODA3OWUxZmQ0NzBmMGQ1MDczYTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTgxMTM4MDc5ZTFmZDQ3MGYwZDUwNzNhMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJKb2huIENvbHRyYW5lOiBLZW4gQnVybnMncyBKYXp6IiwicmVsZWFzZV9kYXRlIjoiMjAwMC0xMS0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjUxMkRZZ3p5SkpvVFE0dEsyMUJyb08ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRGN1E1TlY2aDVUU3dDYWluejhTNUEiLCJpZCI6IjRGN1E1TlY2aDVUU3dDYWluejhTNUEiLCJuYW1lIjoiRHVrZSBFbGxpbmd0b24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEY3UTVOVjZoNVRTd0NhaW56OFM1QSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yaEdoNVZPZWVxaW1RRnhxWHZmQ1VmIn0sImhyZWYiOiJodHRwczovL2FwaQ==", + "LnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsImlkIjoiMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsIm5hbWUiOiJKb2huIENvbHRyYW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjU2OTU5LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNQzE2MzUxOTU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zYjU1QXhJbEROT3dadTJ4Q3NwNlUwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM2I1NUF4SWxETk93WnUyeENzcDZVMCIsImlkIjoiM2I1NUF4SWxETk93WnUyeENzcDZVMCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbiBBIFNlbnRpbWVudGFsIE1vb2QiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2I1NUF4SWxETk93WnUyeENzcDZVMCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yZDN3RlNGS1FYODlDWnZFM3ZPdXZmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMmQzd0ZTRktRWDg5Q1p2RTN2T3V2ZiIsImlkIjoiMmQzd0ZTRktRWDg5Q1p2RTN2T3V2ZiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3ZGEyYjFjNDE2YjllODU5MDlmZjZhZjAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyN2RhMmIxYzQxNmI5ZTg1OTA5ZmY2YWYwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3ZGEyYjFjNDE2YjllOA==", + "NTkwOWZmNmFmMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYXJpY2UncyBDaG9pY2UiLCJyZWxlYXNlX2RhdGUiOiIyMDEwLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MmQzd0ZTRktRWDg5Q1p2RTN2T3V2ZiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRGN1E1TlY2aDVUU3dDYWluejhTNUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsImlkIjoiNEY3UTVOVjZoNVRTd0NhaW56OFM1QSIsIm5hbWUiOiJEdWtlIEVsbGluZ3RvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0RjdRNU5WNmg1VFN3Q2Fpbno4UzVBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsImlkIjoiMmhHaDVWT2VlcWltUUZ4cVh2ZkNVZiIsIm5hbWUiOiJKb2huIENvbHRyYW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJoR2g1Vk9lZXFpbVFGeHFYdmZDVWYifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MjU3Nzg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNQzE2MzUxOTU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xODVPS3VWaEJtUFZoZHVmaXNJUzBaIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMTg1T0t1VmhCbVBWaGR1ZmlzSVMwWiIsImlkIjoiMTg1T0t1VmhCbVBWaGR1ZmlzSVMwWiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbiBBIFNlbnRpbWVudGFsIE1vb2QiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MTg1T0t1VmhCbVBWaGR1ZmlzSVMwWiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22In+a+Sentimental+Mood%22+artist%3A%22Duke+Ellington%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Round%20Midnight%22%20artist%3A%22Thelonious%20Monk%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"external_urls":{"spotify":"https://open.spotify.com/album/6DRjwkPa8kT9vifu7tH3PL"},"href":"https://api.spotify.com/v1/albums/6DRjwkPa8kT9vifu7tH3PL","id":"6DRjwkPa8kT9vifu7tH3PL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c4c99d6b212f741ba28c5a61"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c4c99d6b212f741ba28c5a61"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c4c99d6b212f741ba28c5a61"}],"is_playable":true,"name":"Genius Of Modern Music (Vol.1, Expanded Edition)","release_date":"1951","release_date_precision":"year","total_tracks":21,"type":"album","uri":"spotify:album:6DRjwkPa8kT9vifu7tH3PL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"disc_number":1,"duration_ms":193840,"explicit":false,"external_ids":{"isrc":"USBN29801360"},"external_urls":{"spotify":"https://open.spotify.com/track/1wl5b2lw3YagQtZiYZbQWP"},"href":"https://api.spotify.com/v1/tracks/1wl5b2lw3YagQtZiYZbQWP","id":"1wl5b2lw3YagQtZiYZbQWP","is_local":false,"is_playable":true,"name":"'Round Midnight","track_number":20,"type":"track","uri":"spotify:track:1wl5b2lw3YagQtZiYZbQWP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"external_urls":{"spotify":"https://open.spotify.com/album/3dw9k0UHKn25TfksiJuNGE"},"href":"https://api.spotify.com/v1/albums/3dw9k0UHKn25TfksiJuNGE","id":"3dw9k0UHKn25TfksiJuNGE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d866291dd41a5aa5ff644167"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d866291dd41a5aa5ff644167"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d866291dd41a5aa5ff644167"}],"is_playable":true,"name":"Genius Of Modern Music Volume One","release_date":"1951","release_date_precision":"year","total_tracks":12,"type":"album","uri":"spotify:album:3dw9k0UHKn25TfksiJuNGE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"disc_number":1,"duration_ms":189740,"explicit":false,"external_ids":{"isrc":"USBN21300022"},"external_urls":{"spotify":"https://open.spotify.com/track/132laFkfrF8gqV0QiZp8hS"},"href":"https://api.spotify.com/v1/tracks/132laFkfrF8gqV0QiZp8hS","id":"132laFkfrF8gqV0QiZp8hS","is_local":false,"is_playable":true,"name":"'Round Midnight","track_number":1,"type":"track","uri":"spotify:track:132laFkfrF8gqV0QiZp8hS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"external_urls":{"spotify":"https://open.spotify.com/album/7gSw9l9zbzMRK1REupS9M8"},"href":"https://api.spotify.com/v1/albums/7gSw9l9zbzMRK1REupS9M8","id":"7gSw9l9zbzMRK1REupS9M8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b4fbf9bb5c13e22636ae2919"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b4fbf9bb5c13e22636ae2919"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b4fbf9bb5c13e22636ae2919"}],"is_playable":true,"name":"The Best Of Thelonious Monk","release_date":"1991-01-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:7gSw9l9zbzMRK1REupS9M8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"disc_number":1,"duration_ms":191866,"explicit":false,"external_ids":{"isrc":"USBN28900042"},"external_urls":{"spotify":"https://open.spotify.com/track/6RchGVTBAzIHhbWaWjN5vY"},"href":"https://api.spotify.com/v1/tracks/6RchGVTBAzIHhbWaWjN5vY","id":"6RchGVTBAzIHhbWaWjN5vY","is_local":false,"is_playable":true,"name":"'Round Midnight","track_number":7,"type":"track","uri":"spotify:track:6RchGVTBAzIHhbWaWjN5vY"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7nSS8VKmoybBNCGTzUAbYp"},"href":"https://api.spotify.com/v1/albums/7nSS8VKmoybBNCGTzUAbYp","id":"7nSS8VKmoybBNCGTzUAbYp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b5244771e8bfed2ddd75e443"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b5244771e8bfed2ddd75e443"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b5244771e8bfed2ddd75e443"}],"is_playable":true,"name":"Jazz","release_date":"2017-05-26","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:7nSS8VKmoybBNCGTzUAbYp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"disc_number":1,"duration_ms":191716,"explicit":false,"external_ids":{"isrc":"USBN29801360"},"external_urls":{"spotify":"https://open.spotify.com/track/0Ozdo5UxK8iBYzOavPKJ5Q"},"href":"https://api.spotify.com/v1/tracks/0Ozdo5UxK8iBYzOavPKJ5Q","id":"0Ozdo5UxK8iBYzOavPKJ5Q","is_local":false,"is_playable":true,"name":"'Round Midnight","track_number":8,"type":"track","uri":"spotify:track:0Ozdo5UxK8iBYzOavPKJ5Q"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4VUawqEDCHHfrUe77ScQ2K"},"href":"https://api.spotify.com/v1/albums/4VUawqEDCHHfrUe77ScQ2K","id":"4VUawqEDCHHfrUe77ScQ2K","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cb6f92683ff9ad65f27a3f9f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cb6f92683ff9ad65f27a3f9f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cb6f92683ff9ad65f27a3f9f"}],"is_playable":true,"name":"'Round About Midnight","release_date":"1957-03-18","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:4VUawqEDCHHfrUe77ScQ2K"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1pwr5rTWLVfqhvHfB7Reap"},"href":"https://api.spotify.com/v1/artists/1pwr5rTWLVfqhvHfB7Reap","id":"1pwr5rTWLVfqhvHfB7Reap","name":"Zoot Sims","type":"artist","uri":"spotify:artist:1pwr5rTWLVfqhvHfB7Reap"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6l40OFJhuTbHQ9V12evc9K"},"href":"https://api.spotify.com/v1/artists/6l40OFJhuTbHQ9V12evc9K","id":"6l40OFJhuTbHQ9V12evc9K","name":"Gerry Mulligan","type":"artist","uri":"spotify:artist:6l40OFJhuTbHQ9V12evc9K"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0vKbTTNdtagd8xiERj6Szb"},"href":"https://api.spotify.com/v1/artists/0vKbTTNdtagd8xiERj6Szb","id":"0vKbTTNdtagd8xiERj6Szb","name":"Percy Heath","type":"artist","uri":"spotify:artist:0vKbTTNdtagd8xiERj6Szb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7txdgV9R0IGjkZ8R6rPake"},"href":"https://api.spotify.com/v1/artists/7txdgV9R0IGjkZ8R6rPake","id":"7txdgV9R0IGjkZ8R6rPake","name":"Connie Kay","type":"artist","uri":"spotify:artist:7txdgV9R0IGjkZ8R6rPake"}],"disc_number":2,"duration_ms":359106,"explicit":false,"external_ids":{"isrc":"USSM10502074"},"external_urls":{"spotify":"https://open.spotify.com/track/5Hhxu8Y9jIu3IqaFsbQZ6D"},"href":"https://api.spotify.com/v1/tracks/5Hhxu8Y9jIu3IqaFsbQZ6D","id":"5Hhxu8Y9jIu3IqaFsbQZ6D","is_local":false,"is_playable":true,"name":"'Round Midnight (feat. Thelonious Monk, Zoot Sims, Gerry Mulligan, Percy Heath & Connie Kay) - Live at the Newport Jazz Festival, Newport, RI - July 1955","track_number":1,"type":"track","uri":"spotify:track:5Hhxu8Y9jIu3IqaFsbQZ6D"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"external_urls":{"spotify":"https://open.spotify.com/album/1XRoD5NjmaXWvueB9DWGwx"},"href":"https://api.spotify.com/v1/albums/1XRoD5NjmaXWvueB9DWGwx","id":"1XRoD5NjmaXWvueB9DWGwx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273535d1c735a6bba4b097a2756"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02535d1c735a6bba4b097a2756"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851535d1c735a6bba4b097a2756"}],"is_playable":true,"name":"The Complete Columbia Studio Solo Recordings of Thelonious Monk: 1962-1968","release_date":"2017-03-03","release_date_precision":"day","total_tracks":37,"type":"album","uri":"spotify:album:1XRoD5NjmaXWvueB9DWGwx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"disc_number":2,"duration_ms":228333,"explicit":false,"external_ids":{"isrc":"USSM16800396"},"external_urls":{"spotify":"https://open.spotify.com/track/2h33iqW8QVkXpdWRRiC5qc"},"href":"https://api.spotify.com/v1/tracks/2h33iqW8QVkXpdWRRiC5qc","id":"2h33iqW8QVkXpdWRRiC5qc","is_local":false,"is_playable":true,"name":"'Round Midnight","track_number":1,"type":"track","uri":"spotify:track:2h33iqW8QVkXpdWRRiC5qc"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2sW17OE7ZF5JSDCNexcQlX"},"href":"https://api.spotify.com/v1/albums/2sW17OE7ZF5JSDCNexcQlX","id":"2sW17OE7ZF5JSDCNexcQlX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ba498c57466f09be5715f52b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ba498c57466f09be5715f52b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ba498c57466f09be5715f52b"}],"is_playable":true,"name":"Old Jazz Classics","release_date":"2019-12-13","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:2sW17OE7ZF5JSDCNexcQlX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"disc_number":1,"duration_ms":193840,"explicit":false,"external_ids":{"isrc":"USBN29801360"},"external_urls":{"spotify":"https://open.spotify.com/track/0ojMtRRTAuEcBRVGrkaJsH"},"href":"https://api.spotify.com/v1/tracks/0ojMtRRTAuEcBRVGrkaJsH","id":"0ojMtRRTAuEcBRVGrkaJsH","is_local":false,"is_playable":true,"name":"'Round Midnight","track_number":13,"type":"track","uri":"spotify:track:0ojMtRRTAuEcBRVGrkaJsH"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"external_urls":{"spotify":"https://open.spotify.com/album/3NdDvZ47hsduOiAS8rXPM3"},"href":"https://api.spotify.com/v1/albums/3NdDvZ47hsduOiAS8rXPM3","id":"3NdDvZ47hsduOiAS8rXPM3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734cc3b5fbf6701fae13a53f51"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024cc3b5fbf6701fae13a53f51"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514cc3b5fbf6701fae13a53f51"}],"is_playable":true,"name":"Thelonious Himself (Remastered 2025)","release_date":"1957","release_date_precision":"year","total_tracks":8,"type":"album","uri":"spotify:album:3NdDvZ47hsduOiAS8rXPM3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"disc_number":1,"duration_ms":403638,"explicit":false,"external_ids":{"isrc":"USC4R2449267"},"external_urls":{"spotify":"https://open.spotify.com/track/00bQO06q9wNrEkKCvPla47"},"href":"https://api.spotify.com/v1/tracks/00bQO06q9wNrEkKCvPla47","id":"00bQO06q9wNrEkKCvPla47","is_local":false,"is_playable":true,"name":"Round Midnight - Remastered 2025","track_number":6,"type":"track","uri":"spotify:track:00bQO06q9wNrEkKCvPla47"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"external_urls":{"spotify":"https://open.spotify.com/album/6S9YHarnp7XRWKAu7CNVpo"},"href":"https://api.spotify.com/v1/albums/6S9YHarnp7XRWKAu7CNVpo","id":"6S9YHarnp7XRWKAu7CNVpo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739ca8f14f8e54866208e4e2c6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029ca8f14f8e54866208e4e2c6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519ca8f14f8e54866208e4e2c6"}],"is_playable":true,"name":"Piano Solo","release_date":"1954-05-26","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:6S9YHarnp7XRWKAu7CNVpo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"disc_number":1,"duration_ms":314333,"explicit":false,"external_ids":{"isrc":"FRZ195400920"},"external_urls":{"spotify":"https://open.spotify.com/track/0hfmpQdKoSy8wDXj3YYcWY"},"href":"https://api.spotify.com/v1/tracks/0hfmpQdKoSy8wDXj3YYcWY","id":"0hfmpQdKoSy8wDXj3YYcWY","is_local":false,"is_playable":true,"name":"'Round About Midnight","track_number":1,"type":"track","uri":"spotify:track:0hfmpQdKoSy8wDXj3YYcWY"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"external_urls":{"spotify":"https://open.spotify.com/album/5D4yHQLojVj4IwOV0rlpBl"},"href":"https://api.spotify.com/v1/albums/5D4yHQLojVj4IwOV0rlpBl","id":"5D4yHQLojVj4IwOV0rlpBl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335c44d366c835ffb7a573afa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235c44d366c835ffb7a573afa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135c44d366c835ffb7a573afa"}],"is_playable":true,"name":"Round About Monk","release_date":"1989-04-11","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5D4yHQLojVj4IwOV0rlpBl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PDpGtF16XpqvXxsrFwQnN"},"href":"https://api.spotify.com/v1/artists/4PDpGtF16XpqvXxsrFwQnN","id":"4PDpGtF16XpqvXxsrFwQnN","name":"Thelonious Monk","type":"artist","uri":"spotify:artist:4PDpGtF16XpqvXxsrFwQnN"}],"disc_number":1,"duration_ms":189733,"explicit":false,"external_ids":{"isrc":"QM6MZ2132594"},"external_urls":{"spotify":"https://open.spotify.com/track/6Zt6oXUs80aPUqEBwcMdLz"},"href":"https://api.spotify.com/v1/tracks/6Zt6oXUs80aPUqEBwcMdLz","id":"6Zt6oXUs80aPUqEBwcMdLz","is_local":false,"is_playable":true,"name":"'Round Midnight","track_number":6,"type":"track","uri":"spotify:track:6Zt6oXUs80aPUqEBwcMdLz"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJvdW5kJTIwTWlkbmlnaHQlMjIlMjBhcnRpc3QlM0ElMjJUaGVsb25pb3VzJTIwTW9uayUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwiaWQiOiI0UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwibmFtZSI6IlRoZWxvbmlvdXMgTW9uayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0UERwR3RGMTZYcHF2WHhzckZ3UW5OIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkRSandrUGE4a1Q5dmlmdTd0SDNQTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZEUmp3a1BhOGtUOXZpZnU3dEgzUEwiLCJpZCI6IjZEUmp3a1BhOGtUOXZpZnU3dEgzUEwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRw", + "czovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzRjOTlkNmIyMTJmNzQxYmEyOGM1YTYxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM0Yzk5ZDZiMjEyZjc0MWJhMjhjNWE2MSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzRjOTlkNmIyMTJmNzQxYmEyOGM1YTYxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikdlbml1cyBPZiBNb2Rlcm4gTXVzaWMgKFZvbC4xLCBFeHBhbmRlZCBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjE5NTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkRSandrUGE4a1Q5dmlmdTd0SDNQTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsImlkIjoiNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsIm5hbWUiOiJUaGVsb25pb3VzIE1vbmsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTM4NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0JOMjk4MDEzNjAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzF3bDViMmx3M1lhZ1F0WmlZWmJRV1AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xd2w1YjJsdzNZYWdRdFppWVpiUVdQIiwiaWQiOiIxd2w1YjJsdzNZYWdRdFppWVpiUVdQIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IidSb3VuZCBNaWRuaWdodCIsInRyYWNrX251bWJlciI6MjAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXdsNWIybHczWWFnUXRaaVlaYlFXUCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80UERwR3RGMTZYcHF2WHhzckZ3UW5OIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRQRHBHdEYxNlhwcXZYeHNyRndRbk4iLCJpZCI6IjRQRHBHdEYxNg==", + "WHBxdlh4c3JGd1FuTiIsIm5hbWUiOiJUaGVsb25pb3VzIE1vbmsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNkdzlrMFVIS24yNVRma3NpSnVOR0UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zZHc5azBVSEtuMjVUZmtzaUp1TkdFIiwiaWQiOiIzZHc5azBVSEtuMjVUZmtzaUp1TkdFIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2Q4NjYyOTFkZDQxYTVhYTVmZjY0NDE2NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkODY2MjkxZGQ0MWE1YWE1ZmY2NDQxNjcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWQ4NjYyOTFkZDQxYTVhYTVmZjY0NDE2NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHZW5pdXMgT2YgTW9kZXJuIE11c2ljIFZvbHVtZSBPbmUiLCJyZWxlYXNlX2RhdGUiOiIxOTUxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNkdzlrMFVIS24yNVRma3NpSnVOR0UifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80UERwR3RGMTZYcHF2WHhzckZ3UW5OIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRQRHBHdEYxNlhwcXZYeHNyRndRbk4iLCJpZCI6IjRQRHBHdEYxNlhwcXZYeHNyRndRbk4iLCJuYW1lIjoiVGhlbG9uaW91cyBNb25rIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg5NzQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNCTjIxMzAwMDIyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xMzJsYUZrZnJGOGdxVjBRaVpwOGhTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMTMybGFGa2ZyRjhncVYwUWlacDhoUyIsImlkIjoiMTMybGFGa2ZyRjhncVYwUWlacDhoUyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydQ==", + "ZSwibmFtZSI6IidSb3VuZCBNaWRuaWdodCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxMzJsYUZrZnJGOGdxVjBRaVpwOGhTIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsImlkIjoiNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsIm5hbWUiOiJUaGVsb25pb3VzIE1vbmsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdnU3c5bDl6YnpNUksxUkV1cFM5TTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83Z1N3OWw5emJ6TVJLMVJFdXBTOU04IiwiaWQiOiI3Z1N3OWw5emJ6TVJLMVJFdXBTOU04IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I0ZmJmOWJiNWMxM2UyMjYzNmFlMjkxOSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiNGZiZjliYjVjMTNlMjI2MzZhZTI5MTkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI0ZmJmOWJiNWMxM2UyMjYzNmFlMjkxOSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgQmVzdCBPZiBUaGVsb25pb3VzIE1vbmsiLCJyZWxlYXNlX2RhdGUiOiIxOTkxLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N2dTdzlsOXpiek1SSzFSRXVwUzlNOCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsImlkIjoiNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsIm5hbWUiOiJUaGVsb25pb3VzIE1vbmsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFBEcEd0RjE2WHBxdg==", + "WHhzckZ3UW5OIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5MTg2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQk4yODkwMDA0MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNlJjaEdWVEJBeklIaGJXYVdqTjV2WSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZSY2hHVlRCQXpJSGhiV2FXak41dlkiLCJpZCI6IjZSY2hHVlRCQXpJSGhiV2FXak41dlkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiJ1JvdW5kIE1pZG5pZ2h0IiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZSY2hHVlRCQXpJSGhiV2FXak41dlkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN25TUzhWS21veWJCTkNHVHpVQWJZcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzduU1M4Vkttb3liQk5DR1R6VUFiWXAiLCJpZCI6IjduU1M4Vkttb3liQk5DR1R6VUFiWXAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjUyNDQ3NzFlOGJmZWQyZGRkNzVlNDQzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmI1MjQ0NzcxZThiZmVkMmRkZDc1ZTQ0MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjUyNDQ3NzFlOGJmZWQyZGRkNzVlNDQzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkphenoiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA1LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidQ==", + "bTo3blNTOFZLbW95YkJOQ0dUelVBYllwIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwiaWQiOiI0UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwibmFtZSI6IlRoZWxvbmlvdXMgTW9uayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0UERwR3RGMTZYcHF2WHhzckZ3UW5OIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5MTcxNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQk4yOTgwMTM2MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svME96ZG81VXhLOGlCWXpPYXZQS0o1USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBPemRvNVV4SzhpQll6T2F2UEtKNVEiLCJpZCI6IjBPemRvNVV4SzhpQll6T2F2UEtKNVEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiJ1JvdW5kIE1pZG5pZ2h0IiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBPemRvNVV4SzhpQll6T2F2UEtKNVEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGtiWVROUWI0UGIxclBiYmFGMHBUNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwiaWQiOiIwa2JZVE5RYjRQYjFyUGJiYUYwcFQ0IiwibmFtZSI6Ik1pbGVzIERhdmlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBrYllUTlFiNFBiMXJQYmJhRjBwVDQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80VlVhd3FFRENISGZyVWU3N1NjUTJLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNFZVYXdxRURDSEhmclVlNzdTY1EySyIsImlkIjoiNFZVYXdxRURDSEhmclVlNzdTY1EySyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjYjZmOTI2ODNmZjlhZDY1ZjI3YTNmOWYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZQ==", + "L2FiNjc2MTZkMDAwMDFlMDJjYjZmOTI2ODNmZjlhZDY1ZjI3YTNmOWYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWNiNmY5MjY4M2ZmOWFkNjVmMjdhM2Y5ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiInUm91bmQgQWJvdXQgTWlkbmlnaHQiLCJyZWxlYXNlX2RhdGUiOiIxOTU3LTAzLTE4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFZVYXdxRURDSEhmclVlNzdTY1EySyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBrYllUTlFiNFBiMXJQYmJhRjBwVDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsImlkIjoiMGtiWVROUWI0UGIxclBiYmFGMHBUNCIsIm5hbWUiOiJNaWxlcyBEYXZpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa2JZVE5RYjRQYjFyUGJiYUYwcFQ0In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsImlkIjoiNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsIm5hbWUiOiJUaGVsb25pb3VzIE1vbmsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xcHdyNXJUV0xWZnFodkhmQjdSZWFwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFwd3I1clRXTFZmcWh2SGZCN1JlYXAiLCJpZCI6IjFwd3I1clRXTFZmcWh2SGZCN1JlYXAiLCJuYW1lIjoiWm9vdCBTaW1zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFwd3I1clRXTFZmcWh2SGZCN1JlYXAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmw0ME9GSmh1VGJIUTlWMTJldmM5SyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bDQwT0ZKaHVUYkhROVYxMmV2YzlLIiwiaWQiOiI2bDQwT0ZKaHVUYkhROVYxMmV2YzlLIiwibmFtZSI6IkdlcnJ5IE11bGxpZ2FuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwbw==", + "dGlmeTphcnRpc3Q6Nmw0ME9GSmh1VGJIUTlWMTJldmM5SyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdktiVFROZHRhZ2Q4eGlFUmo2U3piIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB2S2JUVE5kdGFnZDh4aUVSajZTemIiLCJpZCI6IjB2S2JUVE5kdGFnZDh4aUVSajZTemIiLCJuYW1lIjoiUGVyY3kgSGVhdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHZLYlRUTmR0YWdkOHhpRVJqNlN6YiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83dHhkZ1Y5UjBJR2prWjhSNnJQYWtlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd0eGRnVjlSMElHamtaOFI2clBha2UiLCJpZCI6Ijd0eGRnVjlSMElHamtaOFI2clBha2UiLCJuYW1lIjoiQ29ubmllIEtheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3dHhkZ1Y5UjBJR2prWjhSNnJQYWtlIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjM1OTEwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDUwMjA3NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNUhoeHU4WTlqSXUzSXFhRnNiUVo2RCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVIaHh1OFk5akl1M0lxYUZzYlFaNkQiLCJpZCI6IjVIaHh1OFk5akl1M0lxYUZzYlFaNkQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiJ1JvdW5kIE1pZG5pZ2h0IChmZWF0LiBUaGVsb25pb3VzIE1vbmssIFpvb3QgU2ltcywgR2VycnkgTXVsbGlnYW4sIFBlcmN5IEhlYXRoICYgQ29ubmllIEtheSkgLSBMaXZlIGF0IHRoZSBOZXdwb3J0IEphenogRmVzdGl2YWwsIE5ld3BvcnQsIFJJIC0gSnVseSAxOTU1IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVIaHh1OFk5akl1M0lxYUZzYlFaNkQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwiaWQiOiI0UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwibmFtZSI6IlRoZWxvbmlvdXMgTW9uayIsIg==", + "dHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xWFJvRDVOam1hWFd2dWVCOURXR3d4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVhSb0Q1TmptYVhXdnVlQjlEV0d3eCIsImlkIjoiMVhSb0Q1TmptYVhXdnVlQjlEV0d3eCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1MzVkMWM3MzVhNmJiYTRiMDk3YTI3NTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTM1ZDFjNzM1YTZiYmE0YjA5N2EyNzU2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1MzVkMWM3MzVhNmJiYTRiMDk3YTI3NTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIENvbXBsZXRlIENvbHVtYmlhIFN0dWRpbyBTb2xvIFJlY29yZGluZ3Mgb2YgVGhlbG9uaW91cyBNb25rOiAxOTYyLTE5NjgiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTAzLTAzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVhSb0Q1TmptYVhXdnVlQjlEV0d3eCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsImlkIjoiNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsIm5hbWUiOiJUaGVsb25pb3VzIE1vbmsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjoyMjgzMzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTY4MDAzOTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJoMzNpcVc4UVZrWHBkV1JSaUM1cWMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yaDMzaXFXOFFWa1hwZFdSUmlDNXFjIiwiaWQiOiIyaDMzaXFXOFFWa1hwZFdSUmlDNXFjIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZQ==", + "Ijp0cnVlLCJuYW1lIjoiJ1JvdW5kIE1pZG5pZ2h0IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJoMzNpcVc4UVZrWHBkV1JSaUM1cWMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMnNXMTdPRTdaRjVKU0RDTmV4Y1FsWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJzVzE3T0U3WkY1SlNEQ05leGNRbFgiLCJpZCI6IjJzVzE3T0U3WkY1SlNEQ05leGNRbFgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYmE0OThjNTc0NjZmMDliZTU3MTVmNTJiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJhNDk4YzU3NDY2ZjA5YmU1NzE1ZjUyYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYmE0OThjNTc0NjZmMDliZTU3MTVmNTJiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik9sZCBKYXp6IENsYXNzaWNzIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0xMi0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJzVzE3T0U3WkY1SlNEQ05leGNRbFgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80UERwR3RGMTZYcHF2WHhzckZ3UW5OIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRQRHBHdEYxNlhwcXZYeHNyRndRbk4iLCJpZCI6IjRQRHBHdEYxNlhwcXZYeHNyRndRbk4iLCJuYW1lIjoiVGhlbG9uaW91cyBNb25rIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRQRHBHdEYxNlhwcXZYeHNyRg==", + "d1FuTiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTM4NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0JOMjk4MDEzNjAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBvak10UlJUQXVFY0JSVkdya2FKc0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wb2pNdFJSVEF1RWNCUlZHcmthSnNIIiwiaWQiOiIwb2pNdFJSVEF1RWNCUlZHcmthSnNIIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IidSb3VuZCBNaWRuaWdodCIsInRyYWNrX251bWJlciI6MTMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MG9qTXRSUlRBdUVjQlJWR3JrYUpzSCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80UERwR3RGMTZYcHF2WHhzckZ3UW5OIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRQRHBHdEYxNlhwcXZYeHNyRndRbk4iLCJpZCI6IjRQRHBHdEYxNlhwcXZYeHNyRndRbk4iLCJuYW1lIjoiVGhlbG9uaW91cyBNb25rIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zTmREdlo0N2hzZHVPaUFTOHJYUE0zIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM05kRHZaNDdoc2R1T2lBUzhyWFBNMyIsImlkIjoiM05kRHZaNDdoc2R1T2lBUzhyWFBNMyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0Y2MzYjVmYmY2NzAxZmFlMTNhNTNmNTEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNGNjM2I1ZmJmNjcwMWZhZTEzYTUzZjUxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0Y2MzYjVmYmY2NzAxZmFlMTNhNTNmNTEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlbG9uaW91cyBIaW1zZWxmIChSZW1hc3RlcmVkIDIwMjUpIiwicmVsZWFzZV9kYXRlIjoiMTk1NyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjo4LCJ0eXBlIjoiYWxidW0iLCJ1cg==", + "aSI6InNwb3RpZnk6YWxidW06M05kRHZaNDdoc2R1T2lBUzhyWFBNMyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsImlkIjoiNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiIsIm5hbWUiOiJUaGVsb25pb3VzIE1vbmsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MDM2MzgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0M0UjI0NDkyNjcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzAwYlFPMDZxOXdOckVrS0N2UGxhNDcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wMGJRTzA2cTl3TnJFa0tDdlBsYTQ3IiwiaWQiOiIwMGJRTzA2cTl3TnJFa0tDdlBsYTQ3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvdW5kIE1pZG5pZ2h0IC0gUmVtYXN0ZXJlZCAyMDI1IiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjAwYlFPMDZxOXdOckVrS0N2UGxhNDcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwiaWQiOiI0UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwibmFtZSI6IlRoZWxvbmlvdXMgTW9u", + "ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0UERwR3RGMTZYcHF2WHhzckZ3UW5OIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNlM5WUhhcm5wN1hSV0tBdTdDTlZwbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZTOVlIYXJucDdYUldLQXU3Q05WcG8iLCJpZCI6IjZTOVlIYXJucDdYUldLQXU3Q05WcG8iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWNhOGYxNGY4ZTU0ODY2MjA4ZTRlMmM2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjljYThmMTRmOGU1NDg2NjIwOGU0ZTJjNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWNhOGYxNGY4ZTU0ODY2MjA4ZTRlMmM2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBpYW5vIFNvbG8iLCJyZWxlYXNlX2RhdGUiOiIxOTU0LTA1LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2UzlZSGFybnA3WFJXS0F1N0NOVnBvIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwiaWQiOiI0UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwibmFtZSI6IlRoZWxvbmlvdXMgTW9uayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0UERwR3RGMTZYcHF2WHhzckZ3UW5OIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMxNDMzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkZSWjE5NTQwMDkyMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMGhmbXBRZEtvU3k4d0RYajNZWWNXWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBoZm1wUWRLb1N5OHdEWGozWVljV1kiLCJpZCI6IjBoZm1wUWRLb1N5OHdEWGozWVljV1kiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiJ1JvdW5kIEFib3V0IE1pZG5pZ2h0IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIg==", + "OiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGhmbXBRZEtvU3k4d0RYajNZWWNXWSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80UERwR3RGMTZYcHF2WHhzckZ3UW5OIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRQRHBHdEYxNlhwcXZYeHNyRndRbk4iLCJpZCI6IjRQRHBHdEYxNlhwcXZYeHNyRndRbk4iLCJuYW1lIjoiVGhlbG9uaW91cyBNb25rIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRQRHBHdEYxNlhwcXZYeHNyRndRbk4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81RDR5SFFMb2pWajRJd09WMHJscEJsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUQ0eUhRTG9qVmo0SXdPVjBybHBCbCIsImlkIjoiNUQ0eUhRTG9qVmo0SXdPVjBybHBCbCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzNWM0NGQzNjZjODM1ZmZiN2E1NzNhZmEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzVjNDRkMzY2YzgzNWZmYjdhNTczYWZhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzNWM0NGQzNjZjODM1ZmZiN2E1NzNhZmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm91bmQgQWJvdXQgTW9uayIsInJlbGVhc2VfZGF0ZSI6IjE5ODktMDQtMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1RDR5SFFMb2pWajRJd09WMHJscEJsIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFBEcEd0RjE2WHBxdlh4c3JGd1FuTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwiaWQiOiI0UERwR3RGMTZYcHF2WHhzckZ3UW5OIiwibmFtZSI6IlRoZWxvbmlvdXMgTW9uayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0UERwR3RGMTZYcHF2WHhzckZ3UW5OIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4OTczMywiZXhwbGljaXQiOg==", + "ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU02TVoyMTMyNTk0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82WnQ2b1hVczgwYVBVcUVCd2NNZEx6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNlp0Nm9YVXM4MGFQVXFFQndjTWRMeiIsImlkIjoiNlp0Nm9YVXM4MGFQVXFFQndjTWRMeiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiInUm91bmQgTWlkbmlnaHQiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Nlp0Nm9YVXM4MGFQVXFFQndjTWRMeiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Round+Midnight%22+artist%3A%22Thelonious+Monk%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN3YXklMjIlMjBhcnRpc3QlM0ElMjJOb3JhaCUyMEpvbmVzJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN3YXklMjIlMjBhcnRpc3QlM0ElMjJOb3JhaCUyMEpvbmVzJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Sway%22+artist%3A%22Norah+Jones%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Desafinado%22%20artist%3A%22Ant%C3%B4nio%20Carlos%20Jobim%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/7LAyThhW5nCJbjSRbQX0U1"},"href":"https://api.spotify.com/v1/albums/7LAyThhW5nCJbjSRbQX0U1","id":"7LAyThhW5nCJbjSRbQX0U1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fc4d8adbbae5be280e0cb43a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fc4d8adbbae5be280e0cb43a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fc4d8adbbae5be280e0cb43a"}],"is_playable":true,"name":"Jazz 'Round Midnight","release_date":"1988-01-27","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:7LAyThhW5nCJbjSRbQX0U1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":254000,"explicit":false,"external_ids":{"isrc":"BRMCA6400217"},"external_urls":{"spotify":"https://open.spotify.com/track/7oxwhQxkGegjlMf3k9sWgm"},"href":"https://api.spotify.com/v1/tracks/7oxwhQxkGegjlMf3k9sWgm","id":"7oxwhQxkGegjlMf3k9sWgm","is_local":false,"is_playable":true,"name":"Desafinado","track_number":6,"type":"track","uri":"spotify:track:7oxwhQxkGegjlMf3k9sWgm"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":250280,"explicit":false,"external_ids":{"isrc":"USUM71405437"},"external_urls":{"spotify":"https://open.spotify.com/track/3kkAzEqJeLv61hCb7Mrmak"},"href":"https://api.spotify.com/v1/tracks/3kkAzEqJeLv61hCb7Mrmak","id":"3kkAzEqJeLv61hCb7Mrmak","is_local":false,"is_playable":true,"name":"Desafinado - Mono Version","track_number":12,"type":"track","uri":"spotify:track:3kkAzEqJeLv61hCb7Mrmak"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/174ThXFgQg2VCq9r3m8ceb"},"href":"https://api.spotify.com/v1/artists/174ThXFgQg2VCq9r3m8ceb","id":"174ThXFgQg2VCq9r3m8ceb","name":"Luiz Bonf\u00e1","type":"artist","uri":"spotify:artist:174ThXFgQg2VCq9r3m8ceb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5V0MlUE1Bft0mbLlND7FJz"},"href":"https://api.spotify.com/v1/artists/5V0MlUE1Bft0mbLlND7FJz","id":"5V0MlUE1Bft0mbLlND7FJz","name":"Ella Fitzgerald","type":"artist","uri":"spotify:artist:5V0MlUE1Bft0mbLlND7FJz"}],"external_urls":{"spotify":"https://open.spotify.com/album/04DUrFW9BaCSFn8w7gKbAc"},"href":"https://api.spotify.com/v1/albums/04DUrFW9BaCSFn8w7gKbAc","id":"04DUrFW9BaCSFn8w7gKbAc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee6147f1f0e0279efbe743df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee6147f1f0e0279efbe743df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee6147f1f0e0279efbe743df"}],"is_playable":true,"name":"Summer Samba","release_date":"2026-07-18","release_date_precision":"day","total_tracks":80,"type":"album","uri":"spotify:album:04DUrFW9BaCSFn8w7gKbAc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/18jpL1sDsJKYn1UvSDvr3Z"},"href":"https://api.spotify.com/v1/artists/18jpL1sDsJKYn1UvSDvr3Z","id":"18jpL1sDsJKYn1UvSDvr3Z","name":"Newton Ferreira de Mendon\u00e7a","type":"artist","uri":"spotify:artist:18jpL1sDsJKYn1UvSDvr3Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"disc_number":1,"duration_ms":352866,"explicit":false,"external_ids":{"isrc":"USMG16490004"},"external_urls":{"spotify":"https://open.spotify.com/track/1GS9esYcucwCDEwiZ6aOdF"},"href":"https://api.spotify.com/v1/tracks/1GS9esYcucwCDEwiZ6aOdF","id":"1GS9esYcucwCDEwiZ6aOdF","is_local":false,"is_playable":true,"name":"Desafinado","track_number":13,"type":"track","uri":"spotify:track:1GS9esYcucwCDEwiZ6aOdF"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/2A8A15YTJJEXGUNAJRKMPW"},"href":"https://api.spotify.com/v1/albums/2A8A15YTJJEXGUNAJRKMPW","id":"2A8A15YTJJEXGUNAJRKMPW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dbf19f504476a6d8fcacb604"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dbf19f504476a6d8fcacb604"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dbf19f504476a6d8fcacb604"}],"is_playable":true,"name":"In\u00e9dito","release_date":"2007-06-20","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:2A8A15YTJJEXGUNAJRKMPW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":175093,"explicit":false,"external_ids":{"isrc":"BRJ9B0500023"},"external_urls":{"spotify":"https://open.spotify.com/track/03uzQMPYLmH848VDbgvSkg"},"href":"https://api.spotify.com/v1/tracks/03uzQMPYLmH848VDbgvSkg","id":"03uzQMPYLmH848VDbgvSkg","is_local":false,"is_playable":true,"name":"Desafinado","track_number":23,"type":"track","uri":"spotify:track:03uzQMPYLmH848VDbgvSkg"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/4BPCMvUseTVsYIlmrFhaTM"},"href":"https://api.spotify.com/v1/albums/4BPCMvUseTVsYIlmrFhaTM","id":"4BPCMvUseTVsYIlmrFhaTM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739eee3849773bacd379cb5d7e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029eee3849773bacd379cb5d7e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519eee3849773bacd379cb5d7e"}],"is_playable":true,"name":"Terra Brasilis","release_date":"1980-03-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:4BPCMvUseTVsYIlmrFhaTM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":204133,"explicit":false,"external_ids":{"isrc":"USWB17900029"},"external_urls":{"spotify":"https://open.spotify.com/track/0TNYerVOpEweIZBsXfQpRV"},"href":"https://api.spotify.com/v1/tracks/0TNYerVOpEweIZBsXfQpRV","id":"0TNYerVOpEweIZBsXfQpRV","is_local":false,"is_playable":true,"name":"Desafinado","track_number":8,"type":"track","uri":"spotify:track:0TNYerVOpEweIZBsXfQpRV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/1sWqA3SOsxbVzN1gC4QrZ3"},"href":"https://api.spotify.com/v1/albums/1sWqA3SOsxbVzN1gC4QrZ3","id":"1sWqA3SOsxbVzN1gC4QrZ3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734993f10d473c7971d065d823"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024993f10d473c7971d065d823"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514993f10d473c7971d065d823"}],"is_playable":true,"name":"The Composer Of Desafinado, Plays","release_date":"1963-08-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1sWqA3SOsxbVzN1gC4QrZ3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":165020,"explicit":false,"external_ids":{"isrc":"BRMCA6400217"},"external_urls":{"spotify":"https://open.spotify.com/track/6zIKxGau9LUGBBYTvinFuX"},"href":"https://api.spotify.com/v1/tracks/6zIKxGau9LUGBBYTvinFuX","id":"6zIKxGau9LUGBBYTvinFuX","is_local":false,"is_playable":true,"name":"Desafinado","track_number":12,"type":"track","uri":"spotify:track:6zIKxGau9LUGBBYTvinFuX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Mxqyy3pSjf8kZZL4QVxS0"},"href":"https://api.spotify.com/v1/artists/1Mxqyy3pSjf8kZZL4QVxS0","id":"1Mxqyy3pSjf8kZZL4QVxS0","name":"Frank Sinatra","type":"artist","uri":"spotify:artist:1Mxqyy3pSjf8kZZL4QVxS0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/5280NkLzxe2w7K1JW9I8jX"},"href":"https://api.spotify.com/v1/albums/5280NkLzxe2w7K1JW9I8jX","id":"5280NkLzxe2w7K1JW9I8jX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737d6f106efadd36f7779383c7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027d6f106efadd36f7779383c7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517d6f106efadd36f7779383c7"}],"is_playable":true,"name":"Sinatra/Jobim: The Complete Reprise Recordings","release_date":"1967-03","release_date_precision":"month","total_tracks":20,"type":"album","uri":"spotify:album:5280NkLzxe2w7K1JW9I8jX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Mxqyy3pSjf8kZZL4QVxS0"},"href":"https://api.spotify.com/v1/artists/1Mxqyy3pSjf8kZZL4QVxS0","id":"1Mxqyy3pSjf8kZZL4QVxS0","name":"Frank Sinatra","type":"artist","uri":"spotify:artist:1Mxqyy3pSjf8kZZL4QVxS0"}],"disc_number":1,"duration_ms":189146,"explicit":false,"external_ids":{"isrc":"USRH11000340"},"external_urls":{"spotify":"https://open.spotify.com/track/46vkomL5vTShPCg1Jib22j"},"href":"https://api.spotify.com/v1/tracks/46vkomL5vTShPCg1Jib22j","id":"46vkomL5vTShPCg1Jib22j","is_local":false,"is_playable":true,"name":"Off Key (Desafinado)","track_number":19,"type":"track","uri":"spotify:track:46vkomL5vTShPCg1Jib22j"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/174ThXFgQg2VCq9r3m8ceb"},"href":"https://api.spotify.com/v1/artists/174ThXFgQg2VCq9r3m8ceb","id":"174ThXFgQg2VCq9r3m8ceb","name":"Luiz Bonf\u00e1","type":"artist","uri":"spotify:artist:174ThXFgQg2VCq9r3m8ceb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5V0MlUE1Bft0mbLlND7FJz"},"href":"https://api.spotify.com/v1/artists/5V0MlUE1Bft0mbLlND7FJz","id":"5V0MlUE1Bft0mbLlND7FJz","name":"Ella Fitzgerald","type":"artist","uri":"spotify:artist:5V0MlUE1Bft0mbLlND7FJz"}],"external_urls":{"spotify":"https://open.spotify.com/album/04DUrFW9BaCSFn8w7gKbAc"},"href":"https://api.spotify.com/v1/albums/04DUrFW9BaCSFn8w7gKbAc","id":"04DUrFW9BaCSFn8w7gKbAc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee6147f1f0e0279efbe743df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee6147f1f0e0279efbe743df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee6147f1f0e0279efbe743df"}],"is_playable":true,"name":"Summer Samba","release_date":"2026-07-18","release_date_precision":"day","total_tracks":80,"type":"album","uri":"spotify:album:04DUrFW9BaCSFn8w7gKbAc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5yS1gOuYkYFFmSejT6ugiV"},"href":"https://api.spotify.com/v1/artists/5yS1gOuYkYFFmSejT6ugiV","id":"5yS1gOuYkYFFmSejT6ugiV","name":"Newton Mendon\u00e7a","type":"artist","uri":"spotify:artist:5yS1gOuYkYFFmSejT6ugiV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0i5yrKtlP4URcRBXQQwnik"},"href":"https://api.spotify.com/v1/artists/0i5yrKtlP4URcRBXQQwnik","id":"0i5yrKtlP4URcRBXQQwnik","name":"Charlie Byrd","type":"artist","uri":"spotify:artist:0i5yrKtlP4URcRBXQQwnik"}],"disc_number":1,"duration_ms":350000,"explicit":false,"external_ids":{"isrc":"USPR36200025"},"external_urls":{"spotify":"https://open.spotify.com/track/10MNOqBfQ8yiKVcfiStHfx"},"href":"https://api.spotify.com/v1/tracks/10MNOqBfQ8yiKVcfiStHfx","id":"10MNOqBfQ8yiKVcfiStHfx","is_local":false,"is_playable":true,"name":"Desafinado","track_number":46,"type":"track","uri":"spotify:track:10MNOqBfQ8yiKVcfiStHfx"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/5fxCwduFydtcmLFrEkePFE"},"href":"https://api.spotify.com/v1/albums/5fxCwduFydtcmLFrEkePFE","id":"5fxCwduFydtcmLFrEkePFE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27321355492508451d92c107984"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0221355492508451d92c107984"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485121355492508451d92c107984"}],"is_playable":true,"name":"Compact Jazz: Antonio Carlos Jobim","release_date":"1990-08-21","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5fxCwduFydtcmLFrEkePFE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":164333,"explicit":false,"external_ids":{"isrc":"BRMCA6400217"},"external_urls":{"spotify":"https://open.spotify.com/track/6ULNlWwIq1whu1FHkRdwQa"},"href":"https://api.spotify.com/v1/tracks/6ULNlWwIq1whu1FHkRdwQa","id":"6ULNlWwIq1whu1FHkRdwQa","is_local":false,"is_playable":true,"name":"Desafinado","track_number":3,"type":"track","uri":"spotify:track:6ULNlWwIq1whu1FHkRdwQa"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/174ThXFgQg2VCq9r3m8ceb"},"href":"https://api.spotify.com/v1/artists/174ThXFgQg2VCq9r3m8ceb","id":"174ThXFgQg2VCq9r3m8ceb","name":"Luiz Bonf\u00e1","type":"artist","uri":"spotify:artist:174ThXFgQg2VCq9r3m8ceb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5V0MlUE1Bft0mbLlND7FJz"},"href":"https://api.spotify.com/v1/artists/5V0MlUE1Bft0mbLlND7FJz","id":"5V0MlUE1Bft0mbLlND7FJz","name":"Ella Fitzgerald","type":"artist","uri":"spotify:artist:5V0MlUE1Bft0mbLlND7FJz"}],"external_urls":{"spotify":"https://open.spotify.com/album/04DUrFW9BaCSFn8w7gKbAc"},"href":"https://api.spotify.com/v1/albums/04DUrFW9BaCSFn8w7gKbAc","id":"04DUrFW9BaCSFn8w7gKbAc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee6147f1f0e0279efbe743df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee6147f1f0e0279efbe743df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee6147f1f0e0279efbe743df"}],"is_playable":true,"name":"Summer Samba","release_date":"2026-07-18","release_date_precision":"day","total_tracks":80,"type":"album","uri":"spotify:album:04DUrFW9BaCSFn8w7gKbAc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/18jpL1sDsJKYn1UvSDvr3Z"},"href":"https://api.spotify.com/v1/artists/18jpL1sDsJKYn1UvSDvr3Z","id":"18jpL1sDsJKYn1UvSDvr3Z","name":"Newton Ferreira de Mendon\u00e7a","type":"artist","uri":"spotify:artist:18jpL1sDsJKYn1UvSDvr3Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5V0MlUE1Bft0mbLlND7FJz"},"href":"https://api.spotify.com/v1/artists/5V0MlUE1Bft0mbLlND7FJz","id":"5V0MlUE1Bft0mbLlND7FJz","name":"Ella Fitzgerald","type":"artist","uri":"spotify:artist:5V0MlUE1Bft0mbLlND7FJz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/69OOiGDvj0o9QQ184tqc9R"},"href":"https://api.spotify.com/v1/artists/69OOiGDvj0o9QQ184tqc9R","id":"69OOiGDvj0o9QQ184tqc9R","name":"Marty Paich","type":"artist","uri":"spotify:artist:69OOiGDvj0o9QQ184tqc9R"}],"disc_number":1,"duration_ms":132293,"explicit":false,"external_ids":{"isrc":"USPR36202480"},"external_urls":{"spotify":"https://open.spotify.com/track/1A11g7GMJYfswiOCFmxPow"},"href":"https://api.spotify.com/v1/tracks/1A11g7GMJYfswiOCFmxPow","id":"1A11g7GMJYfswiOCFmxPow","is_local":false,"is_playable":true,"name":"Desafinado","track_number":55,"type":"track","uri":"spotify:track:1A11g7GMJYfswiOCFmxPow"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Desafinado%22%20artist%3A%22Ant%C3%B4nio%20Carlos%20Jobim%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/7LAyThhW5nCJbjSRbQX0U1"},"href":"https://api.spotify.com/v1/albums/7LAyThhW5nCJbjSRbQX0U1","id":"7LAyThhW5nCJbjSRbQX0U1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fc4d8adbbae5be280e0cb43a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fc4d8adbbae5be280e0cb43a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fc4d8adbbae5be280e0cb43a"}],"is_playable":true,"name":"Jazz 'Round Midnight","release_date":"1988-01-27","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:7LAyThhW5nCJbjSRbQX0U1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":254000,"explicit":false,"external_ids":{"isrc":"BRMCA6400217"},"external_urls":{"spotify":"https://open.spotify.com/track/7oxwhQxkGegjlMf3k9sWgm"},"href":"https://api.spotify.com/v1/tracks/7oxwhQxkGegjlMf3k9sWgm","id":"7oxwhQxkGegjlMf3k9sWgm","is_local":false,"is_playable":true,"name":"Desafinado","track_number":6,"type":"track","uri":"spotify:track:7oxwhQxkGegjlMf3k9sWgm"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2W6Hvrtg2Zpc9dW4aBDbdP"},"href":"https://api.spotify.com/v1/albums/2W6Hvrtg2Zpc9dW4aBDbdP","id":"2W6Hvrtg2Zpc9dW4aBDbdP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273417cc363d7286a88489dee3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02417cc363d7286a88489dee3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851417cc363d7286a88489dee3c"}],"is_playable":true,"name":"Getz/Gilberto (Expanded Edition)","release_date":"1964-03-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2W6Hvrtg2Zpc9dW4aBDbdP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":250280,"explicit":false,"external_ids":{"isrc":"USUM71405437"},"external_urls":{"spotify":"https://open.spotify.com/track/3kkAzEqJeLv61hCb7Mrmak"},"href":"https://api.spotify.com/v1/tracks/3kkAzEqJeLv61hCb7Mrmak","id":"3kkAzEqJeLv61hCb7Mrmak","is_local":false,"is_playable":true,"name":"Desafinado - Mono Version","track_number":12,"type":"track","uri":"spotify:track:3kkAzEqJeLv61hCb7Mrmak"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/174ThXFgQg2VCq9r3m8ceb"},"href":"https://api.spotify.com/v1/artists/174ThXFgQg2VCq9r3m8ceb","id":"174ThXFgQg2VCq9r3m8ceb","name":"Luiz Bonf\u00e1","type":"artist","uri":"spotify:artist:174ThXFgQg2VCq9r3m8ceb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5V0MlUE1Bft0mbLlND7FJz"},"href":"https://api.spotify.com/v1/artists/5V0MlUE1Bft0mbLlND7FJz","id":"5V0MlUE1Bft0mbLlND7FJz","name":"Ella Fitzgerald","type":"artist","uri":"spotify:artist:5V0MlUE1Bft0mbLlND7FJz"}],"external_urls":{"spotify":"https://open.spotify.com/album/04DUrFW9BaCSFn8w7gKbAc"},"href":"https://api.spotify.com/v1/albums/04DUrFW9BaCSFn8w7gKbAc","id":"04DUrFW9BaCSFn8w7gKbAc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee6147f1f0e0279efbe743df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee6147f1f0e0279efbe743df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee6147f1f0e0279efbe743df"}],"is_playable":true,"name":"Summer Samba","release_date":"2026-07-18","release_date_precision":"day","total_tracks":80,"type":"album","uri":"spotify:album:04DUrFW9BaCSFn8w7gKbAc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/18jpL1sDsJKYn1UvSDvr3Z"},"href":"https://api.spotify.com/v1/artists/18jpL1sDsJKYn1UvSDvr3Z","id":"18jpL1sDsJKYn1UvSDvr3Z","name":"Newton Ferreira de Mendon\u00e7a","type":"artist","uri":"spotify:artist:18jpL1sDsJKYn1UvSDvr3Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"}],"disc_number":1,"duration_ms":352866,"explicit":false,"external_ids":{"isrc":"USMG16490004"},"external_urls":{"spotify":"https://open.spotify.com/track/1GS9esYcucwCDEwiZ6aOdF"},"href":"https://api.spotify.com/v1/tracks/1GS9esYcucwCDEwiZ6aOdF","id":"1GS9esYcucwCDEwiZ6aOdF","is_local":false,"is_playable":true,"name":"Desafinado","track_number":13,"type":"track","uri":"spotify:track:1GS9esYcucwCDEwiZ6aOdF"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/2A8A15YTJJEXGUNAJRKMPW"},"href":"https://api.spotify.com/v1/albums/2A8A15YTJJEXGUNAJRKMPW","id":"2A8A15YTJJEXGUNAJRKMPW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dbf19f504476a6d8fcacb604"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dbf19f504476a6d8fcacb604"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dbf19f504476a6d8fcacb604"}],"is_playable":true,"name":"In\u00e9dito","release_date":"2007-06-20","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:2A8A15YTJJEXGUNAJRKMPW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":175093,"explicit":false,"external_ids":{"isrc":"BRJ9B0500023"},"external_urls":{"spotify":"https://open.spotify.com/track/03uzQMPYLmH848VDbgvSkg"},"href":"https://api.spotify.com/v1/tracks/03uzQMPYLmH848VDbgvSkg","id":"03uzQMPYLmH848VDbgvSkg","is_local":false,"is_playable":true,"name":"Desafinado","track_number":23,"type":"track","uri":"spotify:track:03uzQMPYLmH848VDbgvSkg"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/4BPCMvUseTVsYIlmrFhaTM"},"href":"https://api.spotify.com/v1/albums/4BPCMvUseTVsYIlmrFhaTM","id":"4BPCMvUseTVsYIlmrFhaTM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739eee3849773bacd379cb5d7e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029eee3849773bacd379cb5d7e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519eee3849773bacd379cb5d7e"}],"is_playable":true,"name":"Terra Brasilis","release_date":"1980-03-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:4BPCMvUseTVsYIlmrFhaTM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":204133,"explicit":false,"external_ids":{"isrc":"USWB17900029"},"external_urls":{"spotify":"https://open.spotify.com/track/0TNYerVOpEweIZBsXfQpRV"},"href":"https://api.spotify.com/v1/tracks/0TNYerVOpEweIZBsXfQpRV","id":"0TNYerVOpEweIZBsXfQpRV","is_local":false,"is_playable":true,"name":"Desafinado","track_number":8,"type":"track","uri":"spotify:track:0TNYerVOpEweIZBsXfQpRV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/1sWqA3SOsxbVzN1gC4QrZ3"},"href":"https://api.spotify.com/v1/albums/1sWqA3SOsxbVzN1gC4QrZ3","id":"1sWqA3SOsxbVzN1gC4QrZ3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734993f10d473c7971d065d823"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024993f10d473c7971d065d823"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514993f10d473c7971d065d823"}],"is_playable":true,"name":"The Composer Of Desafinado, Plays","release_date":"1963-08-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1sWqA3SOsxbVzN1gC4QrZ3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":165020,"explicit":false,"external_ids":{"isrc":"BRMCA6400217"},"external_urls":{"spotify":"https://open.spotify.com/track/6zIKxGau9LUGBBYTvinFuX"},"href":"https://api.spotify.com/v1/tracks/6zIKxGau9LUGBBYTvinFuX","id":"6zIKxGau9LUGBBYTvinFuX","is_local":false,"is_playable":true,"name":"Desafinado","track_number":12,"type":"track","uri":"spotify:track:6zIKxGau9LUGBBYTvinFuX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Mxqyy3pSjf8kZZL4QVxS0"},"href":"https://api.spotify.com/v1/artists/1Mxqyy3pSjf8kZZL4QVxS0","id":"1Mxqyy3pSjf8kZZL4QVxS0","name":"Frank Sinatra","type":"artist","uri":"spotify:artist:1Mxqyy3pSjf8kZZL4QVxS0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/5280NkLzxe2w7K1JW9I8jX"},"href":"https://api.spotify.com/v1/albums/5280NkLzxe2w7K1JW9I8jX","id":"5280NkLzxe2w7K1JW9I8jX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737d6f106efadd36f7779383c7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027d6f106efadd36f7779383c7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517d6f106efadd36f7779383c7"}],"is_playable":true,"name":"Sinatra/Jobim: The Complete Reprise Recordings","release_date":"1967-03","release_date_precision":"month","total_tracks":20,"type":"album","uri":"spotify:album:5280NkLzxe2w7K1JW9I8jX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Mxqyy3pSjf8kZZL4QVxS0"},"href":"https://api.spotify.com/v1/artists/1Mxqyy3pSjf8kZZL4QVxS0","id":"1Mxqyy3pSjf8kZZL4QVxS0","name":"Frank Sinatra","type":"artist","uri":"spotify:artist:1Mxqyy3pSjf8kZZL4QVxS0"}],"disc_number":1,"duration_ms":189146,"explicit":false,"external_ids":{"isrc":"USRH11000340"},"external_urls":{"spotify":"https://open.spotify.com/track/46vkomL5vTShPCg1Jib22j"},"href":"https://api.spotify.com/v1/tracks/46vkomL5vTShPCg1Jib22j","id":"46vkomL5vTShPCg1Jib22j","is_local":false,"is_playable":true,"name":"Off Key (Desafinado)","track_number":19,"type":"track","uri":"spotify:track:46vkomL5vTShPCg1Jib22j"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/174ThXFgQg2VCq9r3m8ceb"},"href":"https://api.spotify.com/v1/artists/174ThXFgQg2VCq9r3m8ceb","id":"174ThXFgQg2VCq9r3m8ceb","name":"Luiz Bonf\u00e1","type":"artist","uri":"spotify:artist:174ThXFgQg2VCq9r3m8ceb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5V0MlUE1Bft0mbLlND7FJz"},"href":"https://api.spotify.com/v1/artists/5V0MlUE1Bft0mbLlND7FJz","id":"5V0MlUE1Bft0mbLlND7FJz","name":"Ella Fitzgerald","type":"artist","uri":"spotify:artist:5V0MlUE1Bft0mbLlND7FJz"}],"external_urls":{"spotify":"https://open.spotify.com/album/04DUrFW9BaCSFn8w7gKbAc"},"href":"https://api.spotify.com/v1/albums/04DUrFW9BaCSFn8w7gKbAc","id":"04DUrFW9BaCSFn8w7gKbAc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee6147f1f0e0279efbe743df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee6147f1f0e0279efbe743df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee6147f1f0e0279efbe743df"}],"is_playable":true,"name":"Summer Samba","release_date":"2026-07-18","release_date_precision":"day","total_tracks":80,"type":"album","uri":"spotify:album:04DUrFW9BaCSFn8w7gKbAc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5yS1gOuYkYFFmSejT6ugiV"},"href":"https://api.spotify.com/v1/artists/5yS1gOuYkYFFmSejT6ugiV","id":"5yS1gOuYkYFFmSejT6ugiV","name":"Newton Mendon\u00e7a","type":"artist","uri":"spotify:artist:5yS1gOuYkYFFmSejT6ugiV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0i5yrKtlP4URcRBXQQwnik"},"href":"https://api.spotify.com/v1/artists/0i5yrKtlP4URcRBXQQwnik","id":"0i5yrKtlP4URcRBXQQwnik","name":"Charlie Byrd","type":"artist","uri":"spotify:artist:0i5yrKtlP4URcRBXQQwnik"}],"disc_number":1,"duration_ms":350000,"explicit":false,"external_ids":{"isrc":"USPR36200025"},"external_urls":{"spotify":"https://open.spotify.com/track/10MNOqBfQ8yiKVcfiStHfx"},"href":"https://api.spotify.com/v1/tracks/10MNOqBfQ8yiKVcfiStHfx","id":"10MNOqBfQ8yiKVcfiStHfx","is_local":false,"is_playable":true,"name":"Desafinado","track_number":46,"type":"track","uri":"spotify:track:10MNOqBfQ8yiKVcfiStHfx"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"external_urls":{"spotify":"https://open.spotify.com/album/5fxCwduFydtcmLFrEkePFE"},"href":"https://api.spotify.com/v1/albums/5fxCwduFydtcmLFrEkePFE","id":"5fxCwduFydtcmLFrEkePFE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27321355492508451d92c107984"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0221355492508451d92c107984"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485121355492508451d92c107984"}],"is_playable":true,"name":"Compact Jazz: Antonio Carlos Jobim","release_date":"1990-08-21","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5fxCwduFydtcmLFrEkePFE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"}],"disc_number":1,"duration_ms":164333,"explicit":false,"external_ids":{"isrc":"BRMCA6400217"},"external_urls":{"spotify":"https://open.spotify.com/track/6ULNlWwIq1whu1FHkRdwQa"},"href":"https://api.spotify.com/v1/tracks/6ULNlWwIq1whu1FHkRdwQa","id":"6ULNlWwIq1whu1FHkRdwQa","is_local":false,"is_playable":true,"name":"Desafinado","track_number":3,"type":"track","uri":"spotify:track:6ULNlWwIq1whu1FHkRdwQa"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77ZUbcdoU5KCPHNUl8bgQy"},"href":"https://api.spotify.com/v1/artists/77ZUbcdoU5KCPHNUl8bgQy","id":"77ZUbcdoU5KCPHNUl8bgQy","name":"Jo\u00e3o Gilberto","type":"artist","uri":"spotify:artist:77ZUbcdoU5KCPHNUl8bgQy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/174ThXFgQg2VCq9r3m8ceb"},"href":"https://api.spotify.com/v1/artists/174ThXFgQg2VCq9r3m8ceb","id":"174ThXFgQg2VCq9r3m8ceb","name":"Luiz Bonf\u00e1","type":"artist","uri":"spotify:artist:174ThXFgQg2VCq9r3m8ceb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5V0MlUE1Bft0mbLlND7FJz"},"href":"https://api.spotify.com/v1/artists/5V0MlUE1Bft0mbLlND7FJz","id":"5V0MlUE1Bft0mbLlND7FJz","name":"Ella Fitzgerald","type":"artist","uri":"spotify:artist:5V0MlUE1Bft0mbLlND7FJz"}],"external_urls":{"spotify":"https://open.spotify.com/album/04DUrFW9BaCSFn8w7gKbAc"},"href":"https://api.spotify.com/v1/albums/04DUrFW9BaCSFn8w7gKbAc","id":"04DUrFW9BaCSFn8w7gKbAc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee6147f1f0e0279efbe743df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee6147f1f0e0279efbe743df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee6147f1f0e0279efbe743df"}],"is_playable":true,"name":"Summer Samba","release_date":"2026-07-18","release_date_precision":"day","total_tracks":80,"type":"album","uri":"spotify:album:04DUrFW9BaCSFn8w7gKbAc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/18jpL1sDsJKYn1UvSDvr3Z"},"href":"https://api.spotify.com/v1/artists/18jpL1sDsJKYn1UvSDvr3Z","id":"18jpL1sDsJKYn1UvSDvr3Z","name":"Newton Ferreira de Mendon\u00e7a","type":"artist","uri":"spotify:artist:18jpL1sDsJKYn1UvSDvr3Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3pO5VjZ4wOHCMBXOvbMISG"},"href":"https://api.spotify.com/v1/artists/3pO5VjZ4wOHCMBXOvbMISG","id":"3pO5VjZ4wOHCMBXOvbMISG","name":"Ant\u00f4nio Carlos Jobim","type":"artist","uri":"spotify:artist:3pO5VjZ4wOHCMBXOvbMISG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5V0MlUE1Bft0mbLlND7FJz"},"href":"https://api.spotify.com/v1/artists/5V0MlUE1Bft0mbLlND7FJz","id":"5V0MlUE1Bft0mbLlND7FJz","name":"Ella Fitzgerald","type":"artist","uri":"spotify:artist:5V0MlUE1Bft0mbLlND7FJz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/69OOiGDvj0o9QQ184tqc9R"},"href":"https://api.spotify.com/v1/artists/69OOiGDvj0o9QQ184tqc9R","id":"69OOiGDvj0o9QQ184tqc9R","name":"Marty Paich","type":"artist","uri":"spotify:artist:69OOiGDvj0o9QQ184tqc9R"}],"disc_number":1,"duration_ms":132293,"explicit":false,"external_ids":{"isrc":"USPR36202480"},"external_urls":{"spotify":"https://open.spotify.com/track/1A11g7GMJYfswiOCFmxPow"},"href":"https://api.spotify.com/v1/tracks/1A11g7GMJYfswiOCFmxPow","id":"1A11g7GMJYfswiOCFmxPow","is_local":false,"is_playable":true,"name":"Desafinado","track_number":55,"type":"track","uri":"spotify:track:1A11g7GMJYfswiOCFmxPow"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Desafinado%22+artist%3A%22Ant%C3%B4nio+Carlos+Jobim%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Don%27t%20Know%20Why%22%20artist%3A%22Norah%20Jones%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ArSFkv4OQOosOvYTrZNIl"},"href":"https://api.spotify.com/v1/albums/3ArSFkv4OQOosOvYTrZNIl","id":"3ArSFkv4OQOosOvYTrZNIl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c648a42b5dad72c8aafceeec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c648a42b5dad72c8aafceeec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c648a42b5dad72c8aafceeec"}],"is_playable":true,"name":"Come Away With Me (Super Deluxe Edition)","release_date":"2002-02-26","release_date_precision":"day","total_tracks":44,"type":"album","uri":"spotify:album:3ArSFkv4OQOosOvYTrZNIl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":186251,"explicit":false,"external_ids":{"isrc":"USBN20100529"},"external_urls":{"spotify":"https://open.spotify.com/track/1zNXF2svmdlNxfS5XeNUgr"},"href":"https://api.spotify.com/v1/tracks/1zNXF2svmdlNxfS5XeNUgr","id":"1zNXF2svmdlNxfS5XeNUgr","is_local":false,"is_playable":true,"name":"Don't Know Why","track_number":1,"type":"track","uri":"spotify:track:1zNXF2svmdlNxfS5XeNUgr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ul9GmXlTkmRMh3OciXxFR"},"href":"https://api.spotify.com/v1/albums/3ul9GmXlTkmRMh3OciXxFR","id":"3ul9GmXlTkmRMh3OciXxFR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f029ff168b1abcfc766c8e8c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f029ff168b1abcfc766c8e8c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f029ff168b1abcfc766c8e8c"}],"is_playable":true,"name":"Come Away With Me (Remastered 2022)","release_date":"2002-02-26","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:3ul9GmXlTkmRMh3OciXxFR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":186251,"explicit":false,"external_ids":{"isrc":"USBN20100529"},"external_urls":{"spotify":"https://open.spotify.com/track/7f5zk7bC3XL5AuGvrg6rsp"},"href":"https://api.spotify.com/v1/tracks/7f5zk7bC3XL5AuGvrg6rsp","id":"7f5zk7bC3XL5AuGvrg6rsp","is_local":false,"is_playable":true,"name":"Don't Know Why","track_number":1,"type":"track","uri":"spotify:track:7f5zk7bC3XL5AuGvrg6rsp"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ArSFkv4OQOosOvYTrZNIl"},"href":"https://api.spotify.com/v1/albums/3ArSFkv4OQOosOvYTrZNIl","id":"3ArSFkv4OQOosOvYTrZNIl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c648a42b5dad72c8aafceeec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c648a42b5dad72c8aafceeec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c648a42b5dad72c8aafceeec"}],"is_playable":true,"name":"Come Away With Me (Super Deluxe Edition)","release_date":"2002-02-26","release_date_precision":"day","total_tracks":44,"type":"album","uri":"spotify:album:3ArSFkv4OQOosOvYTrZNIl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":2,"duration_ms":189226,"explicit":false,"external_ids":{"isrc":"USUM72208509"},"external_urls":{"spotify":"https://open.spotify.com/track/7wcMDBp3SwDFqA2ypsZOql"},"href":"https://api.spotify.com/v1/tracks/7wcMDBp3SwDFqA2ypsZOql","id":"7wcMDBp3SwDFqA2ypsZOql","is_local":false,"is_playable":true,"name":"Don't Know Why - First Sessions Demo","track_number":12,"type":"track","uri":"spotify:track:7wcMDBp3SwDFqA2ypsZOql"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/4xt2QHvLWVEFuJTgQHzxl2"},"href":"https://api.spotify.com/v1/albums/4xt2QHvLWVEFuJTgQHzxl2","id":"4xt2QHvLWVEFuJTgQHzxl2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273830bd70d9db95284d057f198"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02830bd70d9db95284d057f198"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851830bd70d9db95284d057f198"}],"is_playable":true,"name":"Don't Know Why","release_date":"2002-01-01","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:4xt2QHvLWVEFuJTgQHzxl2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":187600,"explicit":false,"external_ids":{"isrc":"USBN20100529"},"external_urls":{"spotify":"https://open.spotify.com/track/5HUXKP6uCT4f6Y1vSnwZhv"},"href":"https://api.spotify.com/v1/tracks/5HUXKP6uCT4f6Y1vSnwZhv","id":"5HUXKP6uCT4f6Y1vSnwZhv","is_local":false,"is_playable":true,"name":"Don't Know Why","track_number":1,"type":"track","uri":"spotify:track:5HUXKP6uCT4f6Y1vSnwZhv"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3h4hern6IoIQV1gfFEFLRL"},"href":"https://api.spotify.com/v1/albums/3h4hern6IoIQV1gfFEFLRL","id":"3h4hern6IoIQV1gfFEFLRL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273608dc677f90bbf7e9a9703b5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02608dc677f90bbf7e9a9703b5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851608dc677f90bbf7e9a9703b5"}],"is_playable":true,"name":"Chill Hits","release_date":"2020-05-08","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:3h4hern6IoIQV1gfFEFLRL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":186160,"explicit":false,"external_ids":{"isrc":"USBN20100529"},"external_urls":{"spotify":"https://open.spotify.com/track/374i5d8bGJi15OGbzlcUsP"},"href":"https://api.spotify.com/v1/tracks/374i5d8bGJi15OGbzlcUsP","id":"374i5d8bGJi15OGbzlcUsP","is_local":false,"is_playable":true,"name":"Don't Know Why","track_number":14,"type":"track","uri":"spotify:track:374i5d8bGJi15OGbzlcUsP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/57W1WFxWy8nkVdY8HtaA0e"},"href":"https://api.spotify.com/v1/albums/57W1WFxWy8nkVdY8HtaA0e","id":"57W1WFxWy8nkVdY8HtaA0e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c55443fde6a784040c9bb67"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c55443fde6a784040c9bb67"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c55443fde6a784040c9bb67"}],"is_playable":true,"name":"Autumn Jones","release_date":"2024-10-04","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:57W1WFxWy8nkVdY8HtaA0e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":186160,"explicit":false,"external_ids":{"isrc":"USBN20100529"},"external_urls":{"spotify":"https://open.spotify.com/track/4EcYMmln4D263IpednKEFz"},"href":"https://api.spotify.com/v1/tracks/4EcYMmln4D263IpednKEFz","id":"4EcYMmln4D263IpednKEFz","is_local":false,"is_playable":true,"name":"Don't Know Why","track_number":1,"type":"track","uri":"spotify:track:4EcYMmln4D263IpednKEFz"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Fo4DmeOEN7xnSj3nnhaLd"},"href":"https://api.spotify.com/v1/albums/6Fo4DmeOEN7xnSj3nnhaLd","id":"6Fo4DmeOEN7xnSj3nnhaLd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27350c4f2d32747f7fd8aea6718"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0250c4f2d32747f7fd8aea6718"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485150c4f2d32747f7fd8aea6718"}],"is_playable":true,"name":"De Zwarte Lijst Volume 2","release_date":"2013-01-01","release_date_precision":"day","total_tracks":56,"type":"album","uri":"spotify:album:6Fo4DmeOEN7xnSj3nnhaLd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":2,"duration_ms":184360,"explicit":false,"external_ids":{"isrc":"USBN20100529"},"external_urls":{"spotify":"https://open.spotify.com/track/5JEi8jbVfRSnMLSi6fiBVj"},"href":"https://api.spotify.com/v1/tracks/5JEi8jbVfRSnMLSi6fiBVj","id":"5JEi8jbVfRSnMLSi6fiBVj","is_local":false,"is_playable":true,"name":"Don't Know Why","track_number":4,"type":"track","uri":"spotify:track:5JEi8jbVfRSnMLSi6fiBVj"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1aa0UIo8PVlUnBekxIhe7B"},"href":"https://api.spotify.com/v1/albums/1aa0UIo8PVlUnBekxIhe7B","id":"1aa0UIo8PVlUnBekxIhe7B","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732b8da90f3692ded8d0adaa75"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022b8da90f3692ded8d0adaa75"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512b8da90f3692ded8d0adaa75"}],"is_playable":true,"name":"Music to relax to","release_date":"2020-09-25","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:1aa0UIo8PVlUnBekxIhe7B"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":186160,"explicit":false,"external_ids":{"isrc":"USBN20100529"},"external_urls":{"spotify":"https://open.spotify.com/track/17sPZzKy4IRyTcOQbypSAM"},"href":"https://api.spotify.com/v1/tracks/17sPZzKy4IRyTcOQbypSAM","id":"17sPZzKy4IRyTcOQbypSAM","is_local":false,"is_playable":true,"name":"Don't Know Why","track_number":6,"type":"track","uri":"spotify:track:17sPZzKy4IRyTcOQbypSAM"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRvbiUyN3QlMjBLbm93JTIwV2h5JTIyJTIwYXJ0aXN0JTNBJTIyTm9yYWglMjBKb25lcyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwiaWQiOiIyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwibmFtZSI6Ik5vcmFoIEpvbmVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zQXJTRmt2NE9RT29zT3ZZVHJaTklsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0FyU0ZrdjRPUU9vc092WVRyWk5JbCIsImlkIjoiM0FyU0ZrdjRPUU9vc092WVRyWk5JbCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8v", + "aS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjNjQ4YTQyYjVkYWQ3MmM4YWFmY2VlZWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzY0OGE0MmI1ZGFkNzJjOGFhZmNlZWVjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNjQ4YTQyYjVkYWQ3MmM4YWFmY2VlZWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29tZSBBd2F5IFdpdGggTWUgKFN1cGVyIERlbHV4ZSBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjIwMDItMDItMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozQXJTRmt2NE9RT29zT3ZZVHJaTklsIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwiaWQiOiIyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwibmFtZSI6Ik5vcmFoIEpvbmVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg2MjUxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNCTjIwMTAwNTI5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xek5YRjJzdm1kbE54ZlM1WGVOVWdyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMXpOWEYyc3ZtZGxOeGZTNVhlTlVnciIsImlkIjoiMXpOWEYyc3ZtZGxOeGZTNVhlTlVnciIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb24ndCBLbm93IFdoeSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxek5YRjJzdm1kbE54ZlM1WGVOVWdyIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsImlkIjoiMkt4N01OWTdjSTFFTm5pVzd2VDMwTg==", + "IiwibmFtZSI6Ik5vcmFoIEpvbmVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zdWw5R21YbFRrbVJNaDNPY2lYeEZSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM3VsOUdtWGxUa21STWgzT2NpWHhGUiIsImlkIjoiM3VsOUdtWGxUa21STWgzT2NpWHhGUiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmMDI5ZmYxNjhiMWFiY2ZjNzY2YzhlOGMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjAyOWZmMTY4YjFhYmNmYzc2NmM4ZThjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmMDI5ZmYxNjhiMWFiY2ZjNzY2YzhlOGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29tZSBBd2F5IFdpdGggTWUgKFJlbWFzdGVyZWQgMjAyMikiLCJyZWxlYXNlX2RhdGUiOiIyMDAyLTAyLTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M3VsOUdtWGxUa21STWgzT2NpWHhGUiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsImlkIjoiMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsIm5hbWUiOiJOb3JhaCBKb25lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4NjI1MSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQk4yMDEwMDUyOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2Y1ems3YkMzWEw1QXVHdnJnNnJzcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdmNXprN2JDM1hMNUF1R3ZyZzZyc3AiLCJpZCI6IjdmNXprN2JDM1hMNUF1R3ZyZzZyc3AiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRG9uJw==", + "dCBLbm93IFdoeSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3ZjV6azdiQzNYTDVBdUd2cmc2cnNwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsImlkIjoiMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsIm5hbWUiOiJOb3JhaCBKb25lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM0FyU0ZrdjRPUU9vc092WVRyWk5JbCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNBclNGa3Y0T1FPb3NPdllUclpOSWwiLCJpZCI6IjNBclNGa3Y0T1FPb3NPdllUclpOSWwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzY0OGE0MmI1ZGFkNzJjOGFhZmNlZWVjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM2NDhhNDJiNWRhZDcyYzhhYWZjZWVlYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzY0OGE0MmI1ZGFkNzJjOGFhZmNlZWVjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbWUgQXdheSBXaXRoIE1lIChTdXBlciBEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDAyLTAyLTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0FyU0ZrdjRPUU9vc092WVRyWk5JbCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsImlkIjoiMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsIm5hbWUiOiJOb3JhaCBKb25lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIn1dLCJkaQ==", + "c2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MTg5MjI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcyMjA4NTA5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83d2NNREJwM1N3REZxQTJ5cHNaT3FsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN3djTURCcDNTd0RGcUEyeXBzWk9xbCIsImlkIjoiN3djTURCcDNTd0RGcUEyeXBzWk9xbCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb24ndCBLbm93IFdoeSAtIEZpcnN0IFNlc3Npb25zIERlbW8iLCJ0cmFja19udW1iZXIiOjEyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjd3Y01EQnAzU3dERnFBMnlwc1pPcWwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsImlkIjoiMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsIm5hbWUiOiJOb3JhaCBKb25lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNHh0MlFIdkxXVkVGdUpUZ1FIenhsMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzR4dDJRSHZMV1ZFRnVKVGdRSHp4bDIiLCJpZCI6IjR4dDJRSHZMV1ZFRnVKVGdRSHp4bDIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODMwYmQ3MGQ5ZGI5NTI4NGQwNTdmMTk4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjgzMGJkNzBkOWRiOTUyODRkMDU3ZjE5OCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODMwYmQ3MGQ5ZGI5NTI4NGQwNTdmMTk4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRvbid0IEtub3cgV2h5IiwicmVsZWFzZV9kYXRlIjoiMjAwMi0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZg==", + "eTphbGJ1bTo0eHQyUUh2TFdWRUZ1SlRnUUh6eGwyIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwiaWQiOiIyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwibmFtZSI6Ik5vcmFoIEpvbmVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg3NjAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNCTjIwMTAwNTI5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81SFVYS1A2dUNUNGY2WTF2U253Wmh2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUhVWEtQNnVDVDRmNlkxdlNud1podiIsImlkIjoiNUhVWEtQNnVDVDRmNlkxdlNud1podiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb24ndCBLbm93IFdoeSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1SFVYS1A2dUNUNGY2WTF2U253Wmh2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNoNGhlcm42SW9JUVYxZ2ZGRUZMUkwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zaDRoZXJuNklvSVFWMWdmRkVGTFJMIiwiaWQiOiIzaDRoZXJuNklvSVFWMWdmRkVGTFJMIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzYwOGRjNjc3ZjkwYmJmN2U5YTk3MDNiNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zYw==", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjYwOGRjNjc3ZjkwYmJmN2U5YTk3MDNiNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjA4ZGM2NzdmOTBiYmY3ZTlhOTcwM2I1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNoaWxsIEhpdHMiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTA1LTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2g0aGVybjZJb0lRVjFnZkZFRkxSTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsImlkIjoiMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsIm5hbWUiOiJOb3JhaCBKb25lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4NjE2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQk4yMDEwMDUyOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMzc0aTVkOGJHSmkxNU9HYnpsY1VzUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzM3NGk1ZDhiR0ppMTVPR2J6bGNVc1AiLCJpZCI6IjM3NGk1ZDhiR0ppMTVPR2J6bGNVc1AiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRG9uJ3QgS25vdyBXaHkiLCJ0cmFja19udW1iZXIiOjE0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjM3NGk1ZDhiR0ppMTVPR2J6bGNVc1AifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwiaWQiOiIyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwibmFtZSI6Ik5vcmFoIEpvbmVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbg==", + "LnNwb3RpZnkuY29tL2FsYnVtLzU3VzFXRnhXeThua1ZkWThIdGFBMGUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81N1cxV0Z4V3k4bmtWZFk4SHRhQTBlIiwiaWQiOiI1N1cxV0Z4V3k4bmtWZFk4SHRhQTBlIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZjNTU0NDNmZGU2YTc4NDA0MGM5YmI2NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2YzU1NDQzZmRlNmE3ODQwNDBjOWJiNjcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZjNTU0NDNmZGU2YTc4NDA0MGM5YmI2NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBdXR1bW4gSm9uZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTEwLTA0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1N1cxV0Z4V3k4bmtWZFk4SHRhQTBlIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwiaWQiOiIyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwibmFtZSI6Ik5vcmFoIEpvbmVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg2MTYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNCTjIwMTAwNTI5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80RWNZTW1sbjREMjYzSXBlZG5LRUZ6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNEVjWU1tbG40RDI2M0lwZWRuS0VGeiIsImlkIjoiNEVjWU1tbG40RDI2M0lwZWRuS0VGeiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb24ndCBLbm93IFdoeSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0RWNZTW1sbjREMjYzSXBlZG5LRUZ6In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cg==", + "bHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkZvNERtZU9FTjd4blNqM25uaGFMZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZGbzREbWVPRU43eG5TajNubmhhTGQiLCJpZCI6IjZGbzREbWVPRU43eG5TajNubmhhTGQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTBjNGYyZDMyNzQ3ZjdmZDhhZWE2NzE4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUwYzRmMmQzMjc0N2Y3ZmQ4YWVhNjcxOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTBjNGYyZDMyNzQ3ZjdmZDhhZWE2NzE4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlIFp3YXJ0ZSBMaWpzdCBWb2x1bWUgMiIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1NiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2Rm80RG1lT0VON3huU2ozbm5oYUxkIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwiaWQiOiIyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIiwibmFtZSI6Ik5vcmFoIEpvbmVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJLeDdNTlk3Y0kxRU5uaVc3dlQzME4ifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MTg0MzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNCTjIwMTAwNTI5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81SkVpOGpiVg==", + "ZlJTbk1MU2k2ZmlCVmoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81SkVpOGpiVmZSU25NTFNpNmZpQlZqIiwiaWQiOiI1SkVpOGpiVmZSU25NTFNpNmZpQlZqIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRvbid0IEtub3cgV2h5IiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVKRWk4amJWZlJTbk1MU2k2ZmlCVmoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMWFhMFVJbzhQVmxVbkJla3hJaGU3QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFhYTBVSW84UFZsVW5CZWt4SWhlN0IiLCJpZCI6IjFhYTBVSW84UFZsVW5CZWt4SWhlN0IiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMmI4ZGE5MGYzNjkyZGVkOGQwYWRhYTc1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjJiOGRhOTBmMzY5MmRlZDhkMGFkYWE3NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMmI4ZGE5MGYzNjkyZGVkOGQwYWRhYTc1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik11c2ljIHRvIHJlbGF4IHRvIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wOS0yNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFhYTBVSW84UFZsVW5CZWt4SWhlN0IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcg==", + "dGlzdHMvMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsImlkIjoiMkt4N01OWTdjSTFFTm5pVzd2VDMwTiIsIm5hbWUiOiJOb3JhaCBKb25lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyS3g3TU5ZN2NJMUVObmlXN3ZUMzBOIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4NjE2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQk4yMDEwMDUyOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMTdzUFp6S3k0SVJ5VGNPUWJ5cFNBTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzE3c1Baekt5NElSeVRjT1FieXBTQU0iLCJpZCI6IjE3c1Baekt5NElSeVRjT1FieXBTQU0iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRG9uJ3QgS25vdyBXaHkiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MTdzUFp6S3k0SVJ5VGNPUWJ5cFNBTSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Don%27t+Know+Why%22+artist%3A%22Norah+Jones%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Nardis%22%20artist%3A%22Bill%20Evans%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/5MuOxoJbvmGGIQxo6Pudu9"},"href":"https://api.spotify.com/v1/albums/5MuOxoJbvmGGIQxo6Pudu9","id":"5MuOxoJbvmGGIQxo6Pudu9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cab935f4386e58f05a9705bc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cab935f4386e58f05a9705bc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cab935f4386e58f05a9705bc"}],"is_playable":true,"name":"Explorations","release_date":"1961","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:5MuOxoJbvmGGIQxo6Pudu9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":349493,"explicit":false,"external_ids":{"isrc":"USFI86100421"},"external_urls":{"spotify":"https://open.spotify.com/track/37vEa9sfgAqEZuqX8AX0Zk"},"href":"https://api.spotify.com/v1/tracks/37vEa9sfgAqEZuqX8AX0Zk","id":"37vEa9sfgAqEZuqX8AX0Zk","is_local":false,"is_playable":true,"name":"Nardis","track_number":6,"type":"track","uri":"spotify:track:37vEa9sfgAqEZuqX8AX0Zk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Mb1e38JMVUFpDo3JKhcHN"},"href":"https://api.spotify.com/v1/albums/5Mb1e38JMVUFpDo3JKhcHN","id":"5Mb1e38JMVUFpDo3JKhcHN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ff7e9270dbc0efdf6465ca23"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ff7e9270dbc0efdf6465ca23"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ff7e9270dbc0efdf6465ca23"}],"is_playable":true,"name":"Another Time: The Hilversum Concert","release_date":"2017-09-01","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:5Mb1e38JMVUFpDo3JKhcHN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6HBVTGmPHytchERPb8YGPr"},"href":"https://api.spotify.com/v1/artists/6HBVTGmPHytchERPb8YGPr","id":"6HBVTGmPHytchERPb8YGPr","name":"Eddie G\u00f3mez","type":"artist","uri":"spotify:artist:6HBVTGmPHytchERPb8YGPr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7rDjbKTLlpNYJRWMm7QVxU"},"href":"https://api.spotify.com/v1/artists/7rDjbKTLlpNYJRWMm7QVxU","id":"7rDjbKTLlpNYJRWMm7QVxU","name":"Jack DeJohnette","type":"artist","uri":"spotify:artist:7rDjbKTLlpNYJRWMm7QVxU"}],"disc_number":1,"duration_ms":525699,"explicit":false,"external_ids":{"isrc":"QMLD61404269"},"external_urls":{"spotify":"https://open.spotify.com/track/7pNzValdo55jNcM7iIlR4J"},"href":"https://api.spotify.com/v1/tracks/7pNzValdo55jNcM7iIlR4J","id":"7pNzValdo55jNcM7iIlR4J","is_local":false,"is_playable":true,"name":"Nardis","track_number":7,"type":"track","uri":"spotify:track:7pNzValdo55jNcM7iIlR4J"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/65WRTYbbWEVW1fEqei8D1f"},"href":"https://api.spotify.com/v1/albums/65WRTYbbWEVW1fEqei8D1f","id":"65WRTYbbWEVW1fEqei8D1f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ff2cd3b0aef4ef3609241607"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ff2cd3b0aef4ef3609241607"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ff2cd3b0aef4ef3609241607"}],"is_playable":true,"name":"Nardis","release_date":"1961-01-01","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:65WRTYbbWEVW1fEqei8D1f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":351026,"explicit":false,"external_ids":{"isrc":"USA561434417"},"external_urls":{"spotify":"https://open.spotify.com/track/67S1SpDOObO5Th4vuMOb2h"},"href":"https://api.spotify.com/v1/tracks/67S1SpDOObO5Th4vuMOb2h","id":"67S1SpDOObO5Th4vuMOb2h","is_local":false,"is_playable":true,"name":"Nardis","track_number":1,"type":"track","uri":"spotify:track:67S1SpDOObO5Th4vuMOb2h"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/3PGsNODk3bl8GYvAtgbBBw"},"href":"https://api.spotify.com/v1/albums/3PGsNODk3bl8GYvAtgbBBw","id":"3PGsNODk3bl8GYvAtgbBBw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c9c0b0eb630bc09ac89ad51d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c9c0b0eb630bc09ac89ad51d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c9c0b0eb630bc09ac89ad51d"}],"is_playable":true,"name":"Explorations [Original Jazz Classics Remasters]","release_date":"1961","release_date_precision":"year","total_tracks":12,"type":"album","uri":"spotify:album:3PGsNODk3bl8GYvAtgbBBw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":350520,"explicit":false,"external_ids":{"isrc":"USC4R1116926"},"external_urls":{"spotify":"https://open.spotify.com/track/1du69AtQFR56cpCxoxSCeS"},"href":"https://api.spotify.com/v1/tracks/1du69AtQFR56cpCxoxSCeS","id":"1du69AtQFR56cpCxoxSCeS","is_local":false,"is_playable":true,"name":"Nardis","track_number":5,"type":"track","uri":"spotify:track:1du69AtQFR56cpCxoxSCeS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/37Aevjp3ZRrGx3rxwpWW5A"},"href":"https://api.spotify.com/v1/albums/37Aevjp3ZRrGx3rxwpWW5A","id":"37Aevjp3ZRrGx3rxwpWW5A","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273800af01bf8b2ced8be5c00d6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02800af01bf8b2ced8be5c00d6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851800af01bf8b2ced8be5c00d6"}],"is_playable":true,"name":"The Best Of Bill Evans","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:37Aevjp3ZRrGx3rxwpWW5A"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":352746,"explicit":false,"external_ids":{"isrc":"USFI86100421"},"external_urls":{"spotify":"https://open.spotify.com/track/7hqdS37gvKxnBy2seoXnt6"},"href":"https://api.spotify.com/v1/tracks/7hqdS37gvKxnBy2seoXnt6","id":"7hqdS37gvKxnBy2seoXnt6","is_local":false,"is_playable":true,"name":"Nardis","track_number":8,"type":"track","uri":"spotify:track:7hqdS37gvKxnBy2seoXnt6"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/3X9GUouKmjn5Ou5Ia9rmxD"},"href":"https://api.spotify.com/v1/albums/3X9GUouKmjn5Ou5Ia9rmxD","id":"3X9GUouKmjn5Ou5Ia9rmxD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273541cec2bbc16bdcf1b790818"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02541cec2bbc16bdcf1b790818"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851541cec2bbc16bdcf1b790818"}],"is_playable":true,"name":"Behind the Dikes: The 1969 Netherlands Recordings (Live)","release_date":"2021-08-20","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:3X9GUouKmjn5Ou5Ia9rmxD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":364866,"explicit":false,"external_ids":{"isrc":"ES49E2100078"},"external_urls":{"spotify":"https://open.spotify.com/track/0aude3ZRNuO740EbiZMLwR"},"href":"https://api.spotify.com/v1/tracks/0aude3ZRNuO740EbiZMLwR","id":"0aude3ZRNuO740EbiZMLwR","is_local":false,"is_playable":true,"name":"Nardis - Live","track_number":22,"type":"track","uri":"spotify:track:0aude3ZRNuO740EbiZMLwR"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1CjnyyNFm22vUIjRfxT6ex"},"href":"https://api.spotify.com/v1/albums/1CjnyyNFm22vUIjRfxT6ex","id":"1CjnyyNFm22vUIjRfxT6ex","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273439422845abf1fbe5926ea48"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02439422845abf1fbe5926ea48"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851439422845abf1fbe5926ea48"}],"is_playable":true,"name":"Portraits at the Penthouse: Live in Seattle","release_date":"2026-01-16","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1CjnyyNFm22vUIjRfxT6ex"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6HBVTGmPHytchERPb8YGPr"},"href":"https://api.spotify.com/v1/artists/6HBVTGmPHytchERPb8YGPr","id":"6HBVTGmPHytchERPb8YGPr","name":"Eddie G\u00f3mez","type":"artist","uri":"spotify:artist:6HBVTGmPHytchERPb8YGPr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6TsAKBA7qM66xRgpTwKrK8"},"href":"https://api.spotify.com/v1/artists/6TsAKBA7qM66xRgpTwKrK8","id":"6TsAKBA7qM66xRgpTwKrK8","name":"Joe Hunt","type":"artist","uri":"spotify:artist:6TsAKBA7qM66xRgpTwKrK8"}],"disc_number":1,"duration_ms":294052,"explicit":false,"external_ids":{"isrc":"USA2P2547810"},"external_urls":{"spotify":"https://open.spotify.com/track/5i68OAr6BEZ8iJRtEmNqSk"},"href":"https://api.spotify.com/v1/tracks/5i68OAr6BEZ8iJRtEmNqSk","id":"5i68OAr6BEZ8iJRtEmNqSk","is_local":false,"is_playable":true,"name":"Nardis (Live at the Penthouse in Seattle May 19, 1966)","track_number":5,"type":"track","uri":"spotify:track:5i68OAr6BEZ8iJRtEmNqSk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/3OJo4kqQp8AFTlmwza38cb"},"href":"https://api.spotify.com/v1/albums/3OJo4kqQp8AFTlmwza38cb","id":"3OJo4kqQp8AFTlmwza38cb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731255a1c6695b85a378ccfa71"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021255a1c6695b85a378ccfa71"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511255a1c6695b85a378ccfa71"}],"is_playable":true,"name":"Bill Evans - At The Montreux Jazz Festival","release_date":"1968","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:3OJo4kqQp8AFTlmwza38cb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/06u9yYuuuZ0exLvF8XG61k"},"href":"https://api.spotify.com/v1/artists/06u9yYuuuZ0exLvF8XG61k","id":"06u9yYuuuZ0exLvF8XG61k","name":"BOB SCHWARZ","type":"artist","uri":"spotify:artist:06u9yYuuuZ0exLvF8XG61k"}],"disc_number":1,"duration_ms":503933,"explicit":false,"external_ids":{"isrc":"USPR36860041"},"external_urls":{"spotify":"https://open.spotify.com/track/2tR2Ko4LEejCG1o5taXSmg"},"href":"https://api.spotify.com/v1/tracks/2tR2Ko4LEejCG1o5taXSmg","id":"2tR2Ko4LEejCG1o5taXSmg","is_local":false,"is_playable":true,"name":"Nardis - Live At The Montreux Jazz Festival, 1968","track_number":4,"type":"track","uri":"spotify:track:2tR2Ko4LEejCG1o5taXSmg"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/0oh1wwf2QIL1iiHdDDX6uP"},"href":"https://api.spotify.com/v1/albums/0oh1wwf2QIL1iiHdDDX6uP","id":"0oh1wwf2QIL1iiHdDDX6uP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d99278b78bf2041cd0f5d533"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d99278b78bf2041cd0f5d533"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d99278b78bf2041cd0f5d533"}],"is_playable":true,"name":"The Solo Sessions","release_date":"1989-01-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:0oh1wwf2QIL1iiHdDDX6uP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":517466,"explicit":false,"external_ids":{"isrc":"USFI88400126"},"external_urls":{"spotify":"https://open.spotify.com/track/18MdkWVDeTH1KbCwavftec"},"href":"https://api.spotify.com/v1/tracks/18MdkWVDeTH1KbCwavftec","id":"18MdkWVDeTH1KbCwavftec","is_local":false,"is_playable":true,"name":"Medley: \"Spartacus\" Love Theme / Nardis","track_number":4,"type":"track","uri":"spotify:track:18MdkWVDeTH1KbCwavftec"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GAlJcapheEZDKdlCUGOFq"},"href":"https://api.spotify.com/v1/albums/5GAlJcapheEZDKdlCUGOFq","id":"5GAlJcapheEZDKdlCUGOFq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f794511b5186f8c3cd56b52a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f794511b5186f8c3cd56b52a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f794511b5186f8c3cd56b52a"}],"is_playable":true,"name":"Haunted Heart: The Legendary Riverside Studio Recordings (Remastered 2025)","release_date":"2025-11-07","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:5GAlJcapheEZDKdlCUGOFq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":2,"duration_ms":350843,"explicit":false,"external_ids":{"isrc":"USC4R2500491"},"external_urls":{"spotify":"https://open.spotify.com/track/48BZ3w3sMvHM6TBNo2YfiC"},"href":"https://api.spotify.com/v1/tracks/48BZ3w3sMvHM6TBNo2YfiC","id":"48BZ3w3sMvHM6TBNo2YfiC","is_local":false,"is_playable":true,"name":"Nardis - Remastered Stereo 2025","track_number":5,"type":"track","uri":"spotify:track:48BZ3w3sMvHM6TBNo2YfiC"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Nardis%22%20artist%3A%22Bill%20Evans%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/5MuOxoJbvmGGIQxo6Pudu9"},"href":"https://api.spotify.com/v1/albums/5MuOxoJbvmGGIQxo6Pudu9","id":"5MuOxoJbvmGGIQxo6Pudu9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cab935f4386e58f05a9705bc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cab935f4386e58f05a9705bc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cab935f4386e58f05a9705bc"}],"is_playable":true,"name":"Explorations","release_date":"1961","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:5MuOxoJbvmGGIQxo6Pudu9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":349493,"explicit":false,"external_ids":{"isrc":"USFI86100421"},"external_urls":{"spotify":"https://open.spotify.com/track/37vEa9sfgAqEZuqX8AX0Zk"},"href":"https://api.spotify.com/v1/tracks/37vEa9sfgAqEZuqX8AX0Zk","id":"37vEa9sfgAqEZuqX8AX0Zk","is_local":false,"is_playable":true,"name":"Nardis","track_number":6,"type":"track","uri":"spotify:track:37vEa9sfgAqEZuqX8AX0Zk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Mb1e38JMVUFpDo3JKhcHN"},"href":"https://api.spotify.com/v1/albums/5Mb1e38JMVUFpDo3JKhcHN","id":"5Mb1e38JMVUFpDo3JKhcHN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ff7e9270dbc0efdf6465ca23"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ff7e9270dbc0efdf6465ca23"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ff7e9270dbc0efdf6465ca23"}],"is_playable":true,"name":"Another Time: The Hilversum Concert","release_date":"2017-09-01","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:5Mb1e38JMVUFpDo3JKhcHN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6HBVTGmPHytchERPb8YGPr"},"href":"https://api.spotify.com/v1/artists/6HBVTGmPHytchERPb8YGPr","id":"6HBVTGmPHytchERPb8YGPr","name":"Eddie G\u00f3mez","type":"artist","uri":"spotify:artist:6HBVTGmPHytchERPb8YGPr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7rDjbKTLlpNYJRWMm7QVxU"},"href":"https://api.spotify.com/v1/artists/7rDjbKTLlpNYJRWMm7QVxU","id":"7rDjbKTLlpNYJRWMm7QVxU","name":"Jack DeJohnette","type":"artist","uri":"spotify:artist:7rDjbKTLlpNYJRWMm7QVxU"}],"disc_number":1,"duration_ms":525699,"explicit":false,"external_ids":{"isrc":"QMLD61404269"},"external_urls":{"spotify":"https://open.spotify.com/track/7pNzValdo55jNcM7iIlR4J"},"href":"https://api.spotify.com/v1/tracks/7pNzValdo55jNcM7iIlR4J","id":"7pNzValdo55jNcM7iIlR4J","is_local":false,"is_playable":true,"name":"Nardis","track_number":7,"type":"track","uri":"spotify:track:7pNzValdo55jNcM7iIlR4J"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/65WRTYbbWEVW1fEqei8D1f"},"href":"https://api.spotify.com/v1/albums/65WRTYbbWEVW1fEqei8D1f","id":"65WRTYbbWEVW1fEqei8D1f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ff2cd3b0aef4ef3609241607"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ff2cd3b0aef4ef3609241607"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ff2cd3b0aef4ef3609241607"}],"is_playable":true,"name":"Nardis","release_date":"1961-01-01","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:65WRTYbbWEVW1fEqei8D1f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":351026,"explicit":false,"external_ids":{"isrc":"USA561434417"},"external_urls":{"spotify":"https://open.spotify.com/track/67S1SpDOObO5Th4vuMOb2h"},"href":"https://api.spotify.com/v1/tracks/67S1SpDOObO5Th4vuMOb2h","id":"67S1SpDOObO5Th4vuMOb2h","is_local":false,"is_playable":true,"name":"Nardis","track_number":1,"type":"track","uri":"spotify:track:67S1SpDOObO5Th4vuMOb2h"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/3PGsNODk3bl8GYvAtgbBBw"},"href":"https://api.spotify.com/v1/albums/3PGsNODk3bl8GYvAtgbBBw","id":"3PGsNODk3bl8GYvAtgbBBw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c9c0b0eb630bc09ac89ad51d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c9c0b0eb630bc09ac89ad51d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c9c0b0eb630bc09ac89ad51d"}],"is_playable":true,"name":"Explorations [Original Jazz Classics Remasters]","release_date":"1961","release_date_precision":"year","total_tracks":12,"type":"album","uri":"spotify:album:3PGsNODk3bl8GYvAtgbBBw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":350520,"explicit":false,"external_ids":{"isrc":"USC4R1116926"},"external_urls":{"spotify":"https://open.spotify.com/track/1du69AtQFR56cpCxoxSCeS"},"href":"https://api.spotify.com/v1/tracks/1du69AtQFR56cpCxoxSCeS","id":"1du69AtQFR56cpCxoxSCeS","is_local":false,"is_playable":true,"name":"Nardis","track_number":5,"type":"track","uri":"spotify:track:1du69AtQFR56cpCxoxSCeS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/37Aevjp3ZRrGx3rxwpWW5A"},"href":"https://api.spotify.com/v1/albums/37Aevjp3ZRrGx3rxwpWW5A","id":"37Aevjp3ZRrGx3rxwpWW5A","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273800af01bf8b2ced8be5c00d6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02800af01bf8b2ced8be5c00d6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851800af01bf8b2ced8be5c00d6"}],"is_playable":true,"name":"The Best Of Bill Evans","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:37Aevjp3ZRrGx3rxwpWW5A"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":1,"duration_ms":352746,"explicit":false,"external_ids":{"isrc":"USFI86100421"},"external_urls":{"spotify":"https://open.spotify.com/track/7hqdS37gvKxnBy2seoXnt6"},"href":"https://api.spotify.com/v1/tracks/7hqdS37gvKxnBy2seoXnt6","id":"7hqdS37gvKxnBy2seoXnt6","is_local":false,"is_playable":true,"name":"Nardis","track_number":8,"type":"track","uri":"spotify:track:7hqdS37gvKxnBy2seoXnt6"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/3X9GUouKmjn5Ou5Ia9rmxD"},"href":"https://api.spotify.com/v1/albums/3X9GUouKmjn5Ou5Ia9rmxD","id":"3X9GUouKmjn5Ou5Ia9rmxD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273541cec2bbc16bdcf1b790818"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02541cec2bbc16bdcf1b790818"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851541cec2bbc16bdcf1b790818"}],"is_playable":true,"name":"Behind the Dikes: The 1969 Netherlands Recordings (Live)","release_date":"2021-08-20","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:3X9GUouKmjn5Ou5Ia9rmxD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":364866,"explicit":false,"external_ids":{"isrc":"ES49E2100078"},"external_urls":{"spotify":"https://open.spotify.com/track/0aude3ZRNuO740EbiZMLwR"},"href":"https://api.spotify.com/v1/tracks/0aude3ZRNuO740EbiZMLwR","id":"0aude3ZRNuO740EbiZMLwR","is_local":false,"is_playable":true,"name":"Nardis - Live","track_number":22,"type":"track","uri":"spotify:track:0aude3ZRNuO740EbiZMLwR"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1CjnyyNFm22vUIjRfxT6ex"},"href":"https://api.spotify.com/v1/albums/1CjnyyNFm22vUIjRfxT6ex","id":"1CjnyyNFm22vUIjRfxT6ex","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273439422845abf1fbe5926ea48"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02439422845abf1fbe5926ea48"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851439422845abf1fbe5926ea48"}],"is_playable":true,"name":"Portraits at the Penthouse: Live in Seattle","release_date":"2026-01-16","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1CjnyyNFm22vUIjRfxT6ex"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6HBVTGmPHytchERPb8YGPr"},"href":"https://api.spotify.com/v1/artists/6HBVTGmPHytchERPb8YGPr","id":"6HBVTGmPHytchERPb8YGPr","name":"Eddie G\u00f3mez","type":"artist","uri":"spotify:artist:6HBVTGmPHytchERPb8YGPr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6TsAKBA7qM66xRgpTwKrK8"},"href":"https://api.spotify.com/v1/artists/6TsAKBA7qM66xRgpTwKrK8","id":"6TsAKBA7qM66xRgpTwKrK8","name":"Joe Hunt","type":"artist","uri":"spotify:artist:6TsAKBA7qM66xRgpTwKrK8"}],"disc_number":1,"duration_ms":294052,"explicit":false,"external_ids":{"isrc":"USA2P2547810"},"external_urls":{"spotify":"https://open.spotify.com/track/5i68OAr6BEZ8iJRtEmNqSk"},"href":"https://api.spotify.com/v1/tracks/5i68OAr6BEZ8iJRtEmNqSk","id":"5i68OAr6BEZ8iJRtEmNqSk","is_local":false,"is_playable":true,"name":"Nardis (Live at the Penthouse in Seattle May 19, 1966)","track_number":5,"type":"track","uri":"spotify:track:5i68OAr6BEZ8iJRtEmNqSk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/3OJo4kqQp8AFTlmwza38cb"},"href":"https://api.spotify.com/v1/albums/3OJo4kqQp8AFTlmwza38cb","id":"3OJo4kqQp8AFTlmwza38cb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731255a1c6695b85a378ccfa71"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021255a1c6695b85a378ccfa71"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511255a1c6695b85a378ccfa71"}],"is_playable":true,"name":"Bill Evans - At The Montreux Jazz Festival","release_date":"1968","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:3OJo4kqQp8AFTlmwza38cb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/06u9yYuuuZ0exLvF8XG61k"},"href":"https://api.spotify.com/v1/artists/06u9yYuuuZ0exLvF8XG61k","id":"06u9yYuuuZ0exLvF8XG61k","name":"BOB SCHWARZ","type":"artist","uri":"spotify:artist:06u9yYuuuZ0exLvF8XG61k"}],"disc_number":1,"duration_ms":503933,"explicit":false,"external_ids":{"isrc":"USPR36860041"},"external_urls":{"spotify":"https://open.spotify.com/track/2tR2Ko4LEejCG1o5taXSmg"},"href":"https://api.spotify.com/v1/tracks/2tR2Ko4LEejCG1o5taXSmg","id":"2tR2Ko4LEejCG1o5taXSmg","is_local":false,"is_playable":true,"name":"Nardis - Live At The Montreux Jazz Festival, 1968","track_number":4,"type":"track","uri":"spotify:track:2tR2Ko4LEejCG1o5taXSmg"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"external_urls":{"spotify":"https://open.spotify.com/album/0oh1wwf2QIL1iiHdDDX6uP"},"href":"https://api.spotify.com/v1/albums/0oh1wwf2QIL1iiHdDDX6uP","id":"0oh1wwf2QIL1iiHdDDX6uP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d99278b78bf2041cd0f5d533"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d99278b78bf2041cd0f5d533"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d99278b78bf2041cd0f5d533"}],"is_playable":true,"name":"The Solo Sessions","release_date":"1989-01-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:0oh1wwf2QIL1iiHdDDX6uP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4jXfFzeP66Zy67HM2mvIIF"},"href":"https://api.spotify.com/v1/artists/4jXfFzeP66Zy67HM2mvIIF","id":"4jXfFzeP66Zy67HM2mvIIF","name":"Bill Evans","type":"artist","uri":"spotify:artist:4jXfFzeP66Zy67HM2mvIIF"}],"disc_number":1,"duration_ms":517466,"explicit":false,"external_ids":{"isrc":"USFI88400126"},"external_urls":{"spotify":"https://open.spotify.com/track/18MdkWVDeTH1KbCwavftec"},"href":"https://api.spotify.com/v1/tracks/18MdkWVDeTH1KbCwavftec","id":"18MdkWVDeTH1KbCwavftec","is_local":false,"is_playable":true,"name":"Medley: \"Spartacus\" Love Theme / Nardis","track_number":4,"type":"track","uri":"spotify:track:18MdkWVDeTH1KbCwavftec"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GAlJcapheEZDKdlCUGOFq"},"href":"https://api.spotify.com/v1/albums/5GAlJcapheEZDKdlCUGOFq","id":"5GAlJcapheEZDKdlCUGOFq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f794511b5186f8c3cd56b52a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f794511b5186f8c3cd56b52a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f794511b5186f8c3cd56b52a"}],"is_playable":true,"name":"Haunted Heart: The Legendary Riverside Studio Recordings (Remastered 2025)","release_date":"2025-11-07","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:5GAlJcapheEZDKdlCUGOFq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VEG6gxFIMfl4Cdog26avS"},"href":"https://api.spotify.com/v1/artists/3VEG6gxFIMfl4Cdog26avS","id":"3VEG6gxFIMfl4Cdog26avS","name":"Bill Evans Trio","type":"artist","uri":"spotify:artist:3VEG6gxFIMfl4Cdog26avS"}],"disc_number":2,"duration_ms":350843,"explicit":false,"external_ids":{"isrc":"USC4R2500491"},"external_urls":{"spotify":"https://open.spotify.com/track/48BZ3w3sMvHM6TBNo2YfiC"},"href":"https://api.spotify.com/v1/tracks/48BZ3w3sMvHM6TBNo2YfiC","id":"48BZ3w3sMvHM6TBNo2YfiC","is_local":false,"is_playable":true,"name":"Nardis - Remastered Stereo 2025","track_number":5,"type":"track","uri":"spotify:track:48BZ3w3sMvHM6TBNo2YfiC"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Nardis%22+artist%3A%22Bill+Evans%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Someday%20My%20Prince%20Will%20Come%22%20artist%3A%22Miles%20Davis%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/68A4o4tkirJRFYbO9Ag0YZ"},"href":"https://api.spotify.com/v1/albums/68A4o4tkirJRFYbO9Ag0YZ","id":"68A4o4tkirJRFYbO9Ag0YZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e7297f99ec874127e1285728"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e7297f99ec874127e1285728"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e7297f99ec874127e1285728"}],"is_playable":true,"name":"Someday My Prince Will Come","release_date":"1961-12-11","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:68A4o4tkirJRFYbO9Ag0YZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":542400,"explicit":false,"external_ids":{"isrc":"USSM16101199"},"external_urls":{"spotify":"https://open.spotify.com/track/0PHqHvmg4TIaANfbsvDMTR"},"href":"https://api.spotify.com/v1/tracks/0PHqHvmg4TIaANfbsvDMTR","id":"0PHqHvmg4TIaANfbsvDMTR","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb)","track_number":1,"type":"track","uri":"spotify:track:0PHqHvmg4TIaANfbsvDMTR"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/68A4o4tkirJRFYbO9Ag0YZ"},"href":"https://api.spotify.com/v1/albums/68A4o4tkirJRFYbO9Ag0YZ","id":"68A4o4tkirJRFYbO9Ag0YZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e7297f99ec874127e1285728"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e7297f99ec874127e1285728"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e7297f99ec874127e1285728"}],"is_playable":true,"name":"Someday My Prince Will Come","release_date":"1961-12-11","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:68A4o4tkirJRFYbO9Ag0YZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":333760,"explicit":false,"external_ids":{"isrc":"USSM16101279"},"external_urls":{"spotify":"https://open.spotify.com/track/5h3M1h279xrxl1WtMS71Jb"},"href":"https://api.spotify.com/v1/tracks/5h3M1h279xrxl1WtMS71Jb","id":"5h3M1h279xrxl1WtMS71Jb","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb) - Alternate Take","track_number":8,"type":"track","uri":"spotify:track:5h3M1h279xrxl1WtMS71Jb"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Khts8jtPr6XbQP10q80Hw"},"href":"https://api.spotify.com/v1/albums/4Khts8jtPr6XbQP10q80Hw","id":"4Khts8jtPr6XbQP10q80Hw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a75b7acd5c81d2090d445923"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a75b7acd5c81d2090d445923"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a75b7acd5c81d2090d445923"}],"is_playable":true,"name":"Someday My Prince Will Come (Mono Version)","release_date":"1961-01-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:4Khts8jtPr6XbQP10q80Hw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":549942,"explicit":false,"external_ids":{"isrc":"USSM11300707"},"external_urls":{"spotify":"https://open.spotify.com/track/1JAqIokUYQb4P6F1yTJP85"},"href":"https://api.spotify.com/v1/tracks/1JAqIokUYQb4P6F1yTJP85","id":"1JAqIokUYQb4P6F1yTJP85","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb) - Mono Version","track_number":1,"type":"track","uri":"spotify:track:1JAqIokUYQb4P6F1yTJP85"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/14Gdsp33387vOEIskmNYUy"},"href":"https://api.spotify.com/v1/albums/14Gdsp33387vOEIskmNYUy","id":"14Gdsp33387vOEIskmNYUy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27359d0e1884eb9df006b900208"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0259d0e1884eb9df006b900208"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485159d0e1884eb9df006b900208"}],"is_playable":true,"name":"The Best Of Miles Davis","release_date":"2002-09-03","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:14Gdsp33387vOEIskmNYUy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":543093,"explicit":false,"external_ids":{"isrc":"USSM16101279"},"external_urls":{"spotify":"https://open.spotify.com/track/5p3U69N2wmctx2Zu6KfHss"},"href":"https://api.spotify.com/v1/tracks/5p3U69N2wmctx2Zu6KfHss","id":"5p3U69N2wmctx2Zu6KfHss","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb) - Alternate Take","track_number":1,"type":"track","uri":"spotify:track:5p3U69N2wmctx2Zu6KfHss"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/0JDBCK1VDNacLmb49NCG9V"},"href":"https://api.spotify.com/v1/albums/0JDBCK1VDNacLmb49NCG9V","id":"0JDBCK1VDNacLmb49NCG9V","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736a73b25b08203cfa3406a9e6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026a73b25b08203cfa3406a9e6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516a73b25b08203cfa3406a9e6"}],"is_playable":true,"name":"Music From and Inspired by The Film Birth Of The Cool","release_date":"2020-02-21","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:0JDBCK1VDNacLmb49NCG9V"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":542695,"explicit":false,"external_ids":{"isrc":"USSM16101199"},"external_urls":{"spotify":"https://open.spotify.com/track/2DkRGTwxczvG8zs23A7sdS"},"href":"https://api.spotify.com/v1/tracks/2DkRGTwxczvG8zs23A7sdS","id":"2DkRGTwxczvG8zs23A7sdS","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb)","track_number":20,"type":"track","uri":"spotify:track:2DkRGTwxczvG8zs23A7sdS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/23CsInPSHn88bjLSPIFVh9"},"href":"https://api.spotify.com/v1/albums/23CsInPSHn88bjLSPIFVh9","id":"23CsInPSHn88bjLSPIFVh9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27317a82c928f107503bb7b2cab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0217a82c928f107503bb7b2cab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485117a82c928f107503bb7b2cab"}],"is_playable":true,"name":"The Essential Miles Davis","release_date":"2001-05-15","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:23CsInPSHn88bjLSPIFVh9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":543773,"explicit":false,"external_ids":{"isrc":"USSM16101279"},"external_urls":{"spotify":"https://open.spotify.com/track/0biYHapyV0kdCn4tuTmopE"},"href":"https://api.spotify.com/v1/tracks/0biYHapyV0kdCn4tuTmopE","id":"0biYHapyV0kdCn4tuTmopE","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb) - Alternate Take","track_number":13,"type":"track","uri":"spotify:track:0biYHapyV0kdCn4tuTmopE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ii2CVdTbZAG72QMedF6kb"},"href":"https://api.spotify.com/v1/albums/4ii2CVdTbZAG72QMedF6kb","id":"4ii2CVdTbZAG72QMedF6kb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273883f35db8d0c1f4ba272f505"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02883f35db8d0c1f4ba272f505"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851883f35db8d0c1f4ba272f505"}],"is_playable":true,"name":"Miles Davis At Carnegie Hall- The Complete Concert","release_date":"1962","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:4ii2CVdTbZAG72QMedF6kb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7g9DeYASD3RzlT4kDchsQZ"},"href":"https://api.spotify.com/v1/artists/7g9DeYASD3RzlT4kDchsQZ","id":"7g9DeYASD3RzlT4kDchsQZ","name":"Gil Evans","type":"artist","uri":"spotify:artist:7g9DeYASD3RzlT4kDchsQZ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"}],"disc_number":2,"duration_ms":175000,"explicit":false,"external_ids":{"isrc":"USSM16100281"},"external_urls":{"spotify":"https://open.spotify.com/track/7pNwcMKCAzc5W3Iaq1OPQD"},"href":"https://api.spotify.com/v1/tracks/7pNwcMKCAzc5W3Iaq1OPQD","id":"7pNwcMKCAzc5W3Iaq1OPQD","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come - Live","track_number":1,"type":"track","uri":"spotify:track:7pNwcMKCAzc5W3Iaq1OPQD"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/5t2mbu43eBgynAQg8xir6f"},"href":"https://api.spotify.com/v1/albums/5t2mbu43eBgynAQg8xir6f","id":"5t2mbu43eBgynAQg8xir6f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f48c0a7e3c905a484ea119c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f48c0a7e3c905a484ea119c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f48c0a7e3c905a484ea119c"}],"is_playable":true,"name":"The Best Of Miles Davis & John Coltrane - Le Best Of Des Deux G\u00e9ants Du Jazz ! - The Two Greatest Jazz Legends !","release_date":"2016-09-16","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:5t2mbu43eBgynAQg8xir6f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":544800,"explicit":false,"external_ids":{"isrc":"GBBXS1156594"},"external_urls":{"spotify":"https://open.spotify.com/track/7jMJ5qSSLYFGwL7gabHKm2"},"href":"https://api.spotify.com/v1/tracks/7jMJ5qSSLYFGwL7gabHKm2","id":"7jMJ5qSSLYFGwL7gabHKm2","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come","track_number":14,"type":"track","uri":"spotify:track:7jMJ5qSSLYFGwL7gabHKm2"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/5A4BHYbEff8raBUrt4CCE0"},"href":"https://api.spotify.com/v1/albums/5A4BHYbEff8raBUrt4CCE0","id":"5A4BHYbEff8raBUrt4CCE0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27317608e0f7a6351dfa00750ed"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0217608e0f7a6351dfa00750ed"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485117608e0f7a6351dfa00750ed"}],"is_playable":true,"name":"Another Side Of John Coltrane","release_date":"2021-08-20","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5A4BHYbEff8raBUrt4CCE0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":542413,"explicit":false,"external_ids":{"isrc":"USSM16101199"},"external_urls":{"spotify":"https://open.spotify.com/track/6mybDGLeh6pxo74vRfqfwS"},"href":"https://api.spotify.com/v1/tracks/6mybDGLeh6pxo74vRfqfwS","id":"6mybDGLeh6pxo74vRfqfwS","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come","track_number":11,"type":"track","uri":"spotify:track:6mybDGLeh6pxo74vRfqfwS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/6IzgiocSjbE00rv35dGtAP"},"href":"https://api.spotify.com/v1/albums/6IzgiocSjbE00rv35dGtAP","id":"6IzgiocSjbE00rv35dGtAP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a733c50dcf55d0bc346d72f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a733c50dcf55d0bc346d72f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a733c50dcf55d0bc346d72f7"}],"is_playable":true,"name":"MILES DAVIS INTEGRAL 1957 - 1962","release_date":"2023-06-02","release_date_precision":"day","total_tracks":132,"type":"album","uri":"spotify:album:6IzgiocSjbE00rv35dGtAP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":7,"duration_ms":544440,"explicit":false,"external_ids":{"isrc":"FR8X02300154"},"external_urls":{"spotify":"https://open.spotify.com/track/7uZvZVgWfO0si2KrSf4gVP"},"href":"https://api.spotify.com/v1/tracks/7uZvZVgWfO0si2KrSf4gVP","id":"7uZvZVgWfO0si2KrSf4gVP","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (with John Coltrane)","track_number":9,"type":"track","uri":"spotify:track:7uZvZVgWfO0si2KrSf4gVP"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Someday%20My%20Prince%20Will%20Come%22%20artist%3A%22Miles%20Davis%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/68A4o4tkirJRFYbO9Ag0YZ"},"href":"https://api.spotify.com/v1/albums/68A4o4tkirJRFYbO9Ag0YZ","id":"68A4o4tkirJRFYbO9Ag0YZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e7297f99ec874127e1285728"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e7297f99ec874127e1285728"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e7297f99ec874127e1285728"}],"is_playable":true,"name":"Someday My Prince Will Come","release_date":"1961-12-11","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:68A4o4tkirJRFYbO9Ag0YZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":542400,"explicit":false,"external_ids":{"isrc":"USSM16101199"},"external_urls":{"spotify":"https://open.spotify.com/track/0PHqHvmg4TIaANfbsvDMTR"},"href":"https://api.spotify.com/v1/tracks/0PHqHvmg4TIaANfbsvDMTR","id":"0PHqHvmg4TIaANfbsvDMTR","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb)","track_number":1,"type":"track","uri":"spotify:track:0PHqHvmg4TIaANfbsvDMTR"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/68A4o4tkirJRFYbO9Ag0YZ"},"href":"https://api.spotify.com/v1/albums/68A4o4tkirJRFYbO9Ag0YZ","id":"68A4o4tkirJRFYbO9Ag0YZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e7297f99ec874127e1285728"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e7297f99ec874127e1285728"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e7297f99ec874127e1285728"}],"is_playable":true,"name":"Someday My Prince Will Come","release_date":"1961-12-11","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:68A4o4tkirJRFYbO9Ag0YZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":333760,"explicit":false,"external_ids":{"isrc":"USSM16101279"},"external_urls":{"spotify":"https://open.spotify.com/track/5h3M1h279xrxl1WtMS71Jb"},"href":"https://api.spotify.com/v1/tracks/5h3M1h279xrxl1WtMS71Jb","id":"5h3M1h279xrxl1WtMS71Jb","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb) - Alternate Take","track_number":8,"type":"track","uri":"spotify:track:5h3M1h279xrxl1WtMS71Jb"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Khts8jtPr6XbQP10q80Hw"},"href":"https://api.spotify.com/v1/albums/4Khts8jtPr6XbQP10q80Hw","id":"4Khts8jtPr6XbQP10q80Hw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a75b7acd5c81d2090d445923"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a75b7acd5c81d2090d445923"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a75b7acd5c81d2090d445923"}],"is_playable":true,"name":"Someday My Prince Will Come (Mono Version)","release_date":"1961-01-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:4Khts8jtPr6XbQP10q80Hw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":549942,"explicit":false,"external_ids":{"isrc":"USSM11300707"},"external_urls":{"spotify":"https://open.spotify.com/track/1JAqIokUYQb4P6F1yTJP85"},"href":"https://api.spotify.com/v1/tracks/1JAqIokUYQb4P6F1yTJP85","id":"1JAqIokUYQb4P6F1yTJP85","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb) - Mono Version","track_number":1,"type":"track","uri":"spotify:track:1JAqIokUYQb4P6F1yTJP85"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/14Gdsp33387vOEIskmNYUy"},"href":"https://api.spotify.com/v1/albums/14Gdsp33387vOEIskmNYUy","id":"14Gdsp33387vOEIskmNYUy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27359d0e1884eb9df006b900208"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0259d0e1884eb9df006b900208"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485159d0e1884eb9df006b900208"}],"is_playable":true,"name":"The Best Of Miles Davis","release_date":"2002-09-03","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:14Gdsp33387vOEIskmNYUy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":543093,"explicit":false,"external_ids":{"isrc":"USSM16101279"},"external_urls":{"spotify":"https://open.spotify.com/track/5p3U69N2wmctx2Zu6KfHss"},"href":"https://api.spotify.com/v1/tracks/5p3U69N2wmctx2Zu6KfHss","id":"5p3U69N2wmctx2Zu6KfHss","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb) - Alternate Take","track_number":1,"type":"track","uri":"spotify:track:5p3U69N2wmctx2Zu6KfHss"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/0JDBCK1VDNacLmb49NCG9V"},"href":"https://api.spotify.com/v1/albums/0JDBCK1VDNacLmb49NCG9V","id":"0JDBCK1VDNacLmb49NCG9V","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736a73b25b08203cfa3406a9e6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026a73b25b08203cfa3406a9e6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516a73b25b08203cfa3406a9e6"}],"is_playable":true,"name":"Music From and Inspired by The Film Birth Of The Cool","release_date":"2020-02-21","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:0JDBCK1VDNacLmb49NCG9V"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":542695,"explicit":false,"external_ids":{"isrc":"USSM16101199"},"external_urls":{"spotify":"https://open.spotify.com/track/2DkRGTwxczvG8zs23A7sdS"},"href":"https://api.spotify.com/v1/tracks/2DkRGTwxczvG8zs23A7sdS","id":"2DkRGTwxczvG8zs23A7sdS","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb)","track_number":20,"type":"track","uri":"spotify:track:2DkRGTwxczvG8zs23A7sdS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/23CsInPSHn88bjLSPIFVh9"},"href":"https://api.spotify.com/v1/albums/23CsInPSHn88bjLSPIFVh9","id":"23CsInPSHn88bjLSPIFVh9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27317a82c928f107503bb7b2cab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0217a82c928f107503bb7b2cab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485117a82c928f107503bb7b2cab"}],"is_playable":true,"name":"The Essential Miles Davis","release_date":"2001-05-15","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:23CsInPSHn88bjLSPIFVh9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"}],"disc_number":1,"duration_ms":543773,"explicit":false,"external_ids":{"isrc":"USSM16101279"},"external_urls":{"spotify":"https://open.spotify.com/track/0biYHapyV0kdCn4tuTmopE"},"href":"https://api.spotify.com/v1/tracks/0biYHapyV0kdCn4tuTmopE","id":"0biYHapyV0kdCn4tuTmopE","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (feat. John Coltrane, Hank Mobley, Wynton Kelly, Paul Chambers & Jimmy Cobb) - Alternate Take","track_number":13,"type":"track","uri":"spotify:track:0biYHapyV0kdCn4tuTmopE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ii2CVdTbZAG72QMedF6kb"},"href":"https://api.spotify.com/v1/albums/4ii2CVdTbZAG72QMedF6kb","id":"4ii2CVdTbZAG72QMedF6kb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273883f35db8d0c1f4ba272f505"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02883f35db8d0c1f4ba272f505"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851883f35db8d0c1f4ba272f505"}],"is_playable":true,"name":"Miles Davis At Carnegie Hall- The Complete Concert","release_date":"1962","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:4ii2CVdTbZAG72QMedF6kb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7g9DeYASD3RzlT4kDchsQZ"},"href":"https://api.spotify.com/v1/artists/7g9DeYASD3RzlT4kDchsQZ","id":"7g9DeYASD3RzlT4kDchsQZ","name":"Gil Evans","type":"artist","uri":"spotify:artist:7g9DeYASD3RzlT4kDchsQZ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5cbutZUQE7SUCA6MsEMbBv"},"href":"https://api.spotify.com/v1/artists/5cbutZUQE7SUCA6MsEMbBv","id":"5cbutZUQE7SUCA6MsEMbBv","name":"Hank Mobley","type":"artist","uri":"spotify:artist:5cbutZUQE7SUCA6MsEMbBv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7KLg0R9RSUabK2CG2MTbBJ"},"href":"https://api.spotify.com/v1/artists/7KLg0R9RSUabK2CG2MTbBJ","id":"7KLg0R9RSUabK2CG2MTbBJ","name":"Jimmy Cobb","type":"artist","uri":"spotify:artist:7KLg0R9RSUabK2CG2MTbBJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0M1UOBJZ9tcKJbrbnVlHZG"},"href":"https://api.spotify.com/v1/artists/0M1UOBJZ9tcKJbrbnVlHZG","id":"0M1UOBJZ9tcKJbrbnVlHZG","name":"Paul Chambers","type":"artist","uri":"spotify:artist:0M1UOBJZ9tcKJbrbnVlHZG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ncBRFyyylFng7kQJaRXN0"},"href":"https://api.spotify.com/v1/artists/5ncBRFyyylFng7kQJaRXN0","id":"5ncBRFyyylFng7kQJaRXN0","name":"Wynton Kelly","type":"artist","uri":"spotify:artist:5ncBRFyyylFng7kQJaRXN0"}],"disc_number":2,"duration_ms":175000,"explicit":false,"external_ids":{"isrc":"USSM16100281"},"external_urls":{"spotify":"https://open.spotify.com/track/7pNwcMKCAzc5W3Iaq1OPQD"},"href":"https://api.spotify.com/v1/tracks/7pNwcMKCAzc5W3Iaq1OPQD","id":"7pNwcMKCAzc5W3Iaq1OPQD","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come - Live","track_number":1,"type":"track","uri":"spotify:track:7pNwcMKCAzc5W3Iaq1OPQD"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/5t2mbu43eBgynAQg8xir6f"},"href":"https://api.spotify.com/v1/albums/5t2mbu43eBgynAQg8xir6f","id":"5t2mbu43eBgynAQg8xir6f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f48c0a7e3c905a484ea119c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f48c0a7e3c905a484ea119c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f48c0a7e3c905a484ea119c"}],"is_playable":true,"name":"The Best Of Miles Davis & John Coltrane - Le Best Of Des Deux G\u00e9ants Du Jazz ! - The Two Greatest Jazz Legends !","release_date":"2016-09-16","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:5t2mbu43eBgynAQg8xir6f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":544800,"explicit":false,"external_ids":{"isrc":"GBBXS1156594"},"external_urls":{"spotify":"https://open.spotify.com/track/7jMJ5qSSLYFGwL7gabHKm2"},"href":"https://api.spotify.com/v1/tracks/7jMJ5qSSLYFGwL7gabHKm2","id":"7jMJ5qSSLYFGwL7gabHKm2","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come","track_number":14,"type":"track","uri":"spotify:track:7jMJ5qSSLYFGwL7gabHKm2"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"external_urls":{"spotify":"https://open.spotify.com/album/5A4BHYbEff8raBUrt4CCE0"},"href":"https://api.spotify.com/v1/albums/5A4BHYbEff8raBUrt4CCE0","id":"5A4BHYbEff8raBUrt4CCE0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27317608e0f7a6351dfa00750ed"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0217608e0f7a6351dfa00750ed"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485117608e0f7a6351dfa00750ed"}],"is_playable":true,"name":"Another Side Of John Coltrane","release_date":"2021-08-20","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5A4BHYbEff8raBUrt4CCE0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"disc_number":1,"duration_ms":542413,"explicit":false,"external_ids":{"isrc":"USSM16101199"},"external_urls":{"spotify":"https://open.spotify.com/track/6mybDGLeh6pxo74vRfqfwS"},"href":"https://api.spotify.com/v1/tracks/6mybDGLeh6pxo74vRfqfwS","id":"6mybDGLeh6pxo74vRfqfwS","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come","track_number":11,"type":"track","uri":"spotify:track:6mybDGLeh6pxo74vRfqfwS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"}],"external_urls":{"spotify":"https://open.spotify.com/album/6IzgiocSjbE00rv35dGtAP"},"href":"https://api.spotify.com/v1/albums/6IzgiocSjbE00rv35dGtAP","id":"6IzgiocSjbE00rv35dGtAP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a733c50dcf55d0bc346d72f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a733c50dcf55d0bc346d72f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a733c50dcf55d0bc346d72f7"}],"is_playable":true,"name":"MILES DAVIS INTEGRAL 1957 - 1962","release_date":"2023-06-02","release_date_precision":"day","total_tracks":132,"type":"album","uri":"spotify:album:6IzgiocSjbE00rv35dGtAP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0kbYTNQb4Pb1rPbbaF0pT4"},"href":"https://api.spotify.com/v1/artists/0kbYTNQb4Pb1rPbbaF0pT4","id":"0kbYTNQb4Pb1rPbbaF0pT4","name":"Miles Davis","type":"artist","uri":"spotify:artist:0kbYTNQb4Pb1rPbbaF0pT4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2hGh5VOeeqimQFxqXvfCUf"},"href":"https://api.spotify.com/v1/artists/2hGh5VOeeqimQFxqXvfCUf","id":"2hGh5VOeeqimQFxqXvfCUf","name":"John Coltrane","type":"artist","uri":"spotify:artist:2hGh5VOeeqimQFxqXvfCUf"}],"disc_number":7,"duration_ms":544440,"explicit":false,"external_ids":{"isrc":"FR8X02300154"},"external_urls":{"spotify":"https://open.spotify.com/track/7uZvZVgWfO0si2KrSf4gVP"},"href":"https://api.spotify.com/v1/tracks/7uZvZVgWfO0si2KrSf4gVP","id":"7uZvZVgWfO0si2KrSf4gVP","is_local":false,"is_playable":true,"name":"Someday My Prince Will Come (with John Coltrane)","track_number":9,"type":"track","uri":"spotify:track:7uZvZVgWfO0si2KrSf4gVP"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Someday+My+Prince+Will+Come%22+artist%3A%22Miles+Davis%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Take%20Five%22%20artist%3A%22Dave%20Brubeck%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"external_urls":{"spotify":"https://open.spotify.com/album/0nTTEAhCZsbbeplyDMIFuA"},"href":"https://api.spotify.com/v1/albums/0nTTEAhCZsbbeplyDMIFuA","id":"0nTTEAhCZsbbeplyDMIFuA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6bd44cf06bf8f4d5ce1e080"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6bd44cf06bf8f4d5ce1e080"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6bd44cf06bf8f4d5ce1e080"}],"is_playable":true,"name":"Time Out","release_date":"1959-12-14","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:0nTTEAhCZsbbeplyDMIFuA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"disc_number":1,"duration_ms":328831,"explicit":false,"external_ids":{"isrc":"USSM15900108"},"external_urls":{"spotify":"https://open.spotify.com/track/1YQWosTIljIvxAgHWTp7KP"},"href":"https://api.spotify.com/v1/tracks/1YQWosTIljIvxAgHWTp7KP","id":"1YQWosTIljIvxAgHWTp7KP","is_local":false,"is_playable":true,"name":"Take Five","track_number":3,"type":"track","uri":"spotify:track:1YQWosTIljIvxAgHWTp7KP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"}],"external_urls":{"spotify":"https://open.spotify.com/album/425dVE44lkA2a0FBI7MGLE"},"href":"https://api.spotify.com/v1/albums/425dVE44lkA2a0FBI7MGLE","id":"425dVE44lkA2a0FBI7MGLE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736ca90aff3927a8b212258770"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026ca90aff3927a8b212258770"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516ca90aff3927a8b212258770"}],"is_playable":true,"name":"Dave Brubeck's Greatest Hits","release_date":"1966","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:425dVE44lkA2a0FBI7MGLE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"disc_number":1,"duration_ms":324160,"explicit":false,"external_ids":{"isrc":"USSM16600282"},"external_urls":{"spotify":"https://open.spotify.com/track/5UbLKRX1qVROlwDFOooEvG"},"href":"https://api.spotify.com/v1/tracks/5UbLKRX1qVROlwDFOooEvG","id":"5UbLKRX1qVROlwDFOooEvG","is_local":false,"is_playable":true,"name":"Take Five","track_number":1,"type":"track","uri":"spotify:track:5UbLKRX1qVROlwDFOooEvG"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"}],"external_urls":{"spotify":"https://open.spotify.com/album/5LiPzuR79DTTmyROUm2luC"},"href":"https://api.spotify.com/v1/albums/5LiPzuR79DTTmyROUm2luC","id":"5LiPzuR79DTTmyROUm2luC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c0f74b53d4cf4b14f7f5d41a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c0f74b53d4cf4b14f7f5d41a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c0f74b53d4cf4b14f7f5d41a"}],"is_playable":true,"name":"On Time","release_date":"2001-04-02","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:5LiPzuR79DTTmyROUm2luC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"disc_number":1,"duration_ms":323066,"explicit":false,"external_ids":{"isrc":"USSM16600282"},"external_urls":{"spotify":"https://open.spotify.com/track/5p6me2mwQrGfH30eExHn6v"},"href":"https://api.spotify.com/v1/tracks/5p6me2mwQrGfH30eExHn6v","id":"5p6me2mwQrGfH30eExHn6v","is_local":false,"is_playable":true,"name":"Take Five","track_number":1,"type":"track","uri":"spotify:track:5p6me2mwQrGfH30eExHn6v"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"}],"external_urls":{"spotify":"https://open.spotify.com/album/4kgsqZhNOPOPwg4T5KKqVe"},"href":"https://api.spotify.com/v1/albums/4kgsqZhNOPOPwg4T5KKqVe","id":"4kgsqZhNOPOPwg4T5KKqVe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737a3bef7f31457ad46575c416"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027a3bef7f31457ad46575c416"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517a3bef7f31457ad46575c416"}],"is_playable":true,"name":"I Like Jazz: The Essence Of Dave Brubeck","release_date":"1991-10-04","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:4kgsqZhNOPOPwg4T5KKqVe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"disc_number":1,"duration_ms":324173,"explicit":false,"external_ids":{"isrc":"USSM10020248"},"external_urls":{"spotify":"https://open.spotify.com/track/63H27dCDIap9kwalfQYe8B"},"href":"https://api.spotify.com/v1/tracks/63H27dCDIap9kwalfQYe8B","id":"63H27dCDIap9kwalfQYe8B","is_local":false,"is_playable":true,"name":"Take Five","track_number":2,"type":"track","uri":"spotify:track:63H27dCDIap9kwalfQYe8B"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"}],"external_urls":{"spotify":"https://open.spotify.com/album/2FpXNwmewH9F2bytZMevuS"},"href":"https://api.spotify.com/v1/albums/2FpXNwmewH9F2bytZMevuS","id":"2FpXNwmewH9F2bytZMevuS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fe2b2f8f198919925d9dd031"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fe2b2f8f198919925d9dd031"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fe2b2f8f198919925d9dd031"}],"is_playable":true,"name":"Time Out","release_date":"1959","release_date_precision":"year","total_tracks":15,"type":"album","uri":"spotify:album:2FpXNwmewH9F2bytZMevuS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"disc_number":1,"duration_ms":324680,"explicit":false,"external_ids":{"isrc":"USSM15900108"},"external_urls":{"spotify":"https://open.spotify.com/track/1hVXZoSAkZ3P5Lp6fKOcgx"},"href":"https://api.spotify.com/v1/tracks/1hVXZoSAkZ3P5Lp6fKOcgx","id":"1hVXZoSAkZ3P5Lp6fKOcgx","is_local":false,"is_playable":true,"name":"Take Five","track_number":3,"type":"track","uri":"spotify:track:1hVXZoSAkZ3P5Lp6fKOcgx"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"}],"external_urls":{"spotify":"https://open.spotify.com/album/7fm20lvlAO6TfVfihMZ8CR"},"href":"https://api.spotify.com/v1/albums/7fm20lvlAO6TfVfihMZ8CR","id":"7fm20lvlAO6TfVfihMZ8CR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730de291c11cac5ffb87dcf8de"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020de291c11cac5ffb87dcf8de"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510de291c11cac5ffb87dcf8de"}],"is_playable":true,"name":"Brubeck","release_date":"2023-11-07","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7fm20lvlAO6TfVfihMZ8CR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"}],"disc_number":1,"duration_ms":325172,"explicit":false,"external_ids":{"isrc":"GBHQC0585950"},"external_urls":{"spotify":"https://open.spotify.com/track/2RbRw7ziNv8VLuUNmiMFDo"},"href":"https://api.spotify.com/v1/tracks/2RbRw7ziNv8VLuUNmiMFDo","id":"2RbRw7ziNv8VLuUNmiMFDo","is_local":false,"is_playable":true,"name":"Take Five","track_number":1,"type":"track","uri":"spotify:track:2RbRw7ziNv8VLuUNmiMFDo"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3j47GWo6Gu4KY2FiOskzEw"},"href":"https://api.spotify.com/v1/albums/3j47GWo6Gu4KY2FiOskzEw","id":"3j47GWo6Gu4KY2FiOskzEw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734524cf0a3c044cfa368ce2e3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024524cf0a3c044cfa368ce2e3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514524cf0a3c044cfa368ce2e3"}],"is_playable":true,"name":"Summer Cool Jazz","release_date":"2018-07-10","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:3j47GWo6Gu4KY2FiOskzEw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"disc_number":1,"duration_ms":325346,"explicit":false,"external_ids":{"isrc":"USSM16600282"},"external_urls":{"spotify":"https://open.spotify.com/track/5lIOsKRGOEFgcKCxnUEksv"},"href":"https://api.spotify.com/v1/tracks/5lIOsKRGOEFgcKCxnUEksv","id":"5lIOsKRGOEFgcKCxnUEksv","is_local":false,"is_playable":true,"name":"Take Five","track_number":4,"type":"track","uri":"spotify:track:5lIOsKRGOEFgcKCxnUEksv"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"external_urls":{"spotify":"https://open.spotify.com/album/6h9mg85Ynp4KxGviWAMhnj"},"href":"https://api.spotify.com/v1/albums/6h9mg85Ynp4KxGviWAMhnj","id":"6h9mg85Ynp4KxGviWAMhnj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27384a9283a1fa8c87ecc101f5d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0284a9283a1fa8c87ecc101f5d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485184a9283a1fa8c87ecc101f5d"}],"is_playable":true,"name":"Sony Jazz Trios","release_date":"2001-10-28","release_date_precision":"day","total_tracks":38,"type":"album","uri":"spotify:album:6h9mg85Ynp4KxGviWAMhnj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2E3nXyfocf7qfHAIFNbBuj"},"href":"https://api.spotify.com/v1/artists/2E3nXyfocf7qfHAIFNbBuj","id":"2E3nXyfocf7qfHAIFNbBuj","name":"Carmen McRae","type":"artist","uri":"spotify:artist:2E3nXyfocf7qfHAIFNbBuj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"disc_number":2,"duration_ms":137906,"explicit":false,"external_ids":{"isrc":"USSM10016393"},"external_urls":{"spotify":"https://open.spotify.com/track/6WuFYOVz5mjfT1QU1beDbi"},"href":"https://api.spotify.com/v1/tracks/6WuFYOVz5mjfT1QU1beDbi","id":"6WuFYOVz5mjfT1QU1beDbi","is_local":false,"is_playable":true,"name":"Take Five (with The Dave Brubeck Quartet) - Single Version","track_number":18,"type":"track","uri":"spotify:track:6WuFYOVz5mjfT1QU1beDbi"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1VuCANtzxz5NtmOD2x0y2e"},"href":"https://api.spotify.com/v1/albums/1VuCANtzxz5NtmOD2x0y2e","id":"1VuCANtzxz5NtmOD2x0y2e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27301478940870065d0abc6bcdb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0201478940870065d0abc6bcdb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485101478940870065d0abc6bcdb"}],"is_playable":true,"name":"Summer Jazz","release_date":"2009-07-13","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:1VuCANtzxz5NtmOD2x0y2e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"disc_number":1,"duration_ms":324800,"explicit":false,"external_ids":{"isrc":"USSM15900108"},"external_urls":{"spotify":"https://open.spotify.com/track/4XMABfJpSIlkunXhClD1eB"},"href":"https://api.spotify.com/v1/tracks/4XMABfJpSIlkunXhClD1eB","id":"4XMABfJpSIlkunXhClD1eB","is_local":false,"is_playable":true,"name":"Take Five","track_number":1,"type":"track","uri":"spotify:track:4XMABfJpSIlkunXhClD1eB"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"}],"external_urls":{"spotify":"https://open.spotify.com/album/4LQExLbhrS89T1WbGtst4d"},"href":"https://api.spotify.com/v1/albums/4LQExLbhrS89T1WbGtst4d","id":"4LQExLbhrS89T1WbGtst4d","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e276ee136067216358889437"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e276ee136067216358889437"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e276ee136067216358889437"}],"is_playable":true,"name":"Columbia Jazz Profile","release_date":"2007-08-09","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4LQExLbhrS89T1WbGtst4d"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3kUKwTJdH8FuWzF8p6Dg9E"},"href":"https://api.spotify.com/v1/artists/3kUKwTJdH8FuWzF8p6Dg9E","id":"3kUKwTJdH8FuWzF8p6Dg9E","name":"Dave Brubeck","type":"artist","uri":"spotify:artist:3kUKwTJdH8FuWzF8p6Dg9E"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4iRZAbYvBqnxrbs6K25aJ7"},"href":"https://api.spotify.com/v1/artists/4iRZAbYvBqnxrbs6K25aJ7","id":"4iRZAbYvBqnxrbs6K25aJ7","name":"The Dave Brubeck Quartet","type":"artist","uri":"spotify:artist:4iRZAbYvBqnxrbs6K25aJ7"}],"disc_number":1,"duration_ms":324933,"explicit":false,"external_ids":{"isrc":"USSM15900020"},"external_urls":{"spotify":"https://open.spotify.com/track/6Kfoj2DCFMVXiutjYOhku3"},"href":"https://api.spotify.com/v1/tracks/6Kfoj2DCFMVXiutjYOhku3","id":"6Kfoj2DCFMVXiutjYOhku3","is_local":false,"is_playable":true,"name":"Take Five - Instrumental","track_number":1,"type":"track","uri":"spotify:track:6Kfoj2DCFMVXiutjYOhku3"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRha2UlMjBGaXZlJTIyJTIwYXJ0aXN0JTNBJTIyRGF2ZSUyMEJydWJlY2slMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRpUlpBYll2QnFueHJiczZLMjVhSjcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGlSWkFiWXZCcW54cmJzNksyNWFKNyIsImlkIjoiNGlSWkFiWXZCcW54cmJzNksyNWFKNyIsIm5hbWUiOiJUaGUgRGF2ZSBCcnViZWNrIFF1YXJ0ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGlSWkFiWXZCcW54cmJzNksyNWFKNyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBuVFRFQWhDWnNiYmVwbHlETUlGdUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wblRURUFoQ1pzYmJlcGx5RE1JRnVBIiwiaWQiOiIwblRURUFoQ1pzYmJlcGx5RE1JRnVBIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0", + "cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I2YmQ0NGNmMDZiZjhmNGQ1Y2UxZTA4MCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiNmJkNDRjZjA2YmY4ZjRkNWNlMWUwODAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI2YmQ0NGNmMDZiZjhmNGQ1Y2UxZTA4MCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaW1lIE91dCIsInJlbGVhc2VfZGF0ZSI6IjE5NTktMTItMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBuVFRFQWhDWnNiYmVwbHlETUlGdUEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80aVJaQWJZdkJxbnhyYnM2SzI1YUo3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRpUlpBYll2QnFueHJiczZLMjVhSjciLCJpZCI6IjRpUlpBYll2QnFueHJiczZLMjVhSjciLCJuYW1lIjoiVGhlIERhdmUgQnJ1YmVjayBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRpUlpBYll2QnFueHJiczZLMjVhSjcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI4ODMxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTE1OTAwMTA4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xWVFXb3NUSWxqSXZ4QWdIV1RwN0tQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVlRV29zVElsakl2eEFnSFdUcDdLUCIsImlkIjoiMVlRV29zVElsakl2eEFnSFdUcDdLUCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUYWtlIEZpdmUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MVlRV29zVElsakl2eEFnSFdUcDdLUCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8za1VLd1RKZEg4RnVXekY4cDZEZzlFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJpZCI6IjNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJuYW1lIjoiRGF2ZQ==", + "IEJydWJlY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzQyNWRWRTQ0bGtBMmEwRkJJN01HTEUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80MjVkVkU0NGxrQTJhMEZCSTdNR0xFIiwiaWQiOiI0MjVkVkU0NGxrQTJhMEZCSTdNR0xFIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZjYTkwYWZmMzkyN2E4YjIxMjI1ODc3MCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2Y2E5MGFmZjM5MjdhOGIyMTIyNTg3NzAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZjYTkwYWZmMzkyN2E4YjIxMjI1ODc3MCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEYXZlIEJydWJlY2sncyBHcmVhdGVzdCBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMTk2NiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0MjVkVkU0NGxrQTJhMEZCSTdNR0xFIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8za1VLd1RKZEg4RnVXekY4cDZEZzlFIiwiaWQiOiIza1VLd1RKZEg4RnVXekY4cDZEZzlFIiwibmFtZSI6IkRhdmUgQnJ1YmVjayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoza1VLd1RKZEg4RnVXekY4cDZEZzlFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRpUlpBYll2QnFueHJiczZLMjVhSjcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGlSWkFiWXZCcW54cmJzNksyNWFKNyIsImlkIjoiNGlSWkFiWXZCcW54cmJzNksyNWFKNyIsIm5hbWUiOiJUaGUgRGF2ZSBCcnViZWNrIFF1YXJ0ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGlSWkFiWXZCcW54cmJzNksyNWFKNyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjQxNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaQ==", + "ZHMiOnsiaXNyYyI6IlVTU00xNjYwMDI4MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVViTEtSWDFxVlJPbHdERk9vb0V2RyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVVYkxLUlgxcVZST2x3REZPb29FdkciLCJpZCI6IjVVYkxLUlgxcVZST2x3REZPb29FdkciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGFrZSBGaXZlIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVVYkxLUlgxcVZST2x3REZPb29FdkcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8za1VLd1RKZEg4RnVXekY4cDZEZzlFIiwiaWQiOiIza1VLd1RKZEg4RnVXekY4cDZEZzlFIiwibmFtZSI6IkRhdmUgQnJ1YmVjayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoza1VLd1RKZEg4RnVXekY4cDZEZzlFIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUxpUHp1Ujc5RFRUbXlST1VtMmx1QyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVMaVB6dVI3OURUVG15Uk9VbTJsdUMiLCJpZCI6IjVMaVB6dVI3OURUVG15Uk9VbTJsdUMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzBmNzRiNTNkNGNmNGIxNGY3ZjVkNDFhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmMwZjc0YjUzZDRjZjRiMTRmN2Y1ZDQxYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzBmNzRiNTNkNGNmNGIxNGY3ZjVkNDFhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik9uIFRpbWUiLCJyZWxlYXNlX2RhdGUiOiIyMDAxLTA0LTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUxpUHp1Ujc5RFRUbXlST1VtMmx1QyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdA==", + "aWZ5LmNvbS9hcnRpc3QvM2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8za1VLd1RKZEg4RnVXekY4cDZEZzlFIiwiaWQiOiIza1VLd1RKZEg4RnVXekY4cDZEZzlFIiwibmFtZSI6IkRhdmUgQnJ1YmVjayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoza1VLd1RKZEg4RnVXekY4cDZEZzlFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRpUlpBYll2QnFueHJiczZLMjVhSjcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGlSWkFiWXZCcW54cmJzNksyNWFKNyIsImlkIjoiNGlSWkFiWXZCcW54cmJzNksyNWFKNyIsIm5hbWUiOiJUaGUgRGF2ZSBCcnViZWNrIFF1YXJ0ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGlSWkFiWXZCcW54cmJzNksyNWFKNyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjMwNjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTY2MDAyODIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVwNm1lMm13UXJHZkgzMGVFeEhuNnYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81cDZtZTJtd1FyR2ZIMzBlRXhIbjZ2IiwiaWQiOiI1cDZtZTJtd1FyR2ZIMzBlRXhIbjZ2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRha2UgRml2ZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1cDZtZTJtd1FyR2ZIMzBlRXhIbjZ2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNrVUt3VEpkSDhGdVd6RjhwNkRnOUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSIsImlkIjoiM2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSIsIm5hbWUiOiJEYXZlIEJydWJlY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRrZ3NxWmhOT1BPUHdnNFQ1S0txVmUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80a2dzcVpoTk9QT1B3ZzRUNUtLcVZlIiwiaWQiOiI0aw==", + "Z3NxWmhOT1BPUHdnNFQ1S0txVmUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2EzYmVmN2YzMTQ1N2FkNDY1NzVjNDE2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdhM2JlZjdmMzE0NTdhZDQ2NTc1YzQxNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2EzYmVmN2YzMTQ1N2FkNDY1NzVjNDE2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkkgTGlrZSBKYXp6OiBUaGUgRXNzZW5jZSBPZiBEYXZlIEJydWJlY2siLCJyZWxlYXNlX2RhdGUiOiIxOTkxLTEwLTA0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0a2dzcVpoTk9QT1B3ZzRUNUtLcVZlIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8za1VLd1RKZEg4RnVXekY4cDZEZzlFIiwiaWQiOiIza1VLd1RKZEg4RnVXekY4cDZEZzlFIiwibmFtZSI6IkRhdmUgQnJ1YmVjayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoza1VLd1RKZEg4RnVXekY4cDZEZzlFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRpUlpBYll2QnFueHJiczZLMjVhSjcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGlSWkFiWXZCcW54cmJzNksyNWFKNyIsImlkIjoiNGlSWkFiWXZCcW54cmJzNksyNWFKNyIsIm5hbWUiOiJUaGUgRGF2ZSBCcnViZWNrIFF1YXJ0ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGlSWkFiWXZCcW54cmJzNksyNWFKNyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjQxNzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTAwMjAyNDgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzYzSDI3ZENESWFwOWt3YWxmUVllOEIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82M0gyN2RDRElhcDlrd2FsZlFZZThCIiwiaWQiOiI2M0gyN2RDRElhcDlrd2FsZlFZZThCIiwiaXNfbG9jYQ==", + "bCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGFrZSBGaXZlIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjYzSDI3ZENESWFwOWt3YWxmUVllOEIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8za1VLd1RKZEg4RnVXekY4cDZEZzlFIiwiaWQiOiIza1VLd1RKZEg4RnVXekY4cDZEZzlFIiwibmFtZSI6IkRhdmUgQnJ1YmVjayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoza1VLd1RKZEg4RnVXekY4cDZEZzlFIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkZwWE53bWV3SDlGMmJ5dFpNZXZ1UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJGcFhOd21ld0g5RjJieXRaTWV2dVMiLCJpZCI6IjJGcFhOd21ld0g5RjJieXRaTWV2dVMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmUyYjJmOGYxOTg5MTk5MjVkOWRkMDMxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZlMmIyZjhmMTk4OTE5OTI1ZDlkZDAzMSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmUyYjJmOGYxOTg5MTk5MjVkOWRkMDMxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRpbWUgT3V0IiwicmVsZWFzZV9kYXRlIjoiMTk1OSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyRnBYTndtZXdIOUYyYnl0Wk1ldnVTIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGlSWkFiWXZCcW54cmJzNksyNWFKNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80aVJaQWJZdkJxbnhyYnM2SzI1YUo3IiwiaWQiOiI0aVJaQWJZdkJxbnhyYnM2SzI1YUo3IiwibmFtZSI6IlRoZSBEYXZlIEJydWJlY2sgUXVhcnRldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0aVJaQWJZdkJxbnhyYnM2Sw==", + "MjVhSjcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI0NjgwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTE1OTAwMTA4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xaFZYWm9TQWtaM1A1THA2ZktPY2d4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMWhWWFpvU0FrWjNQNUxwNmZLT2NneCIsImlkIjoiMWhWWFpvU0FrWjNQNUxwNmZLT2NneCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUYWtlIEZpdmUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MWhWWFpvU0FrWjNQNUxwNmZLT2NneCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8za1VLd1RKZEg4RnVXekY4cDZEZzlFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJpZCI6IjNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJuYW1lIjoiRGF2ZSBCcnViZWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNrVUt3VEpkSDhGdVd6RjhwNkRnOUUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83Zm0yMGx2bEFPNlRmVmZpaE1aOENSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN2ZtMjBsdmxBTzZUZlZmaWhNWjhDUiIsImlkIjoiN2ZtMjBsdmxBTzZUZlZmaWhNWjhDUiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZGUyOTFjMTFjYWM1ZmZiODdkY2Y4ZGUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGRlMjkxYzExY2FjNWZmYjg3ZGNmOGRlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwZGUyOTFjMTFjYWM1ZmZiODdkY2Y4ZGUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQnJ1YmVjayIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMTEtMDciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3Zm0yMGx2bEFPNlRmVg==", + "ZmloTVo4Q1IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8za1VLd1RKZEg4RnVXekY4cDZEZzlFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJpZCI6IjNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJuYW1lIjoiRGF2ZSBCcnViZWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNrVUt3VEpkSDhGdVd6RjhwNkRnOUUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI1MTcyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JIUUMwNTg1OTUwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yUmJSdzd6aU52OFZMdVVObWlNRkRvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMlJiUnc3emlOdjhWTHVVTm1pTUZEbyIsImlkIjoiMlJiUnc3emlOdjhWTHVVTm1pTUZEbyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUYWtlIEZpdmUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MlJiUnc3emlOdjhWTHVVTm1pTUZEbyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zajQ3R1dvNkd1NEtZMkZpT3NrekV3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2o0N0dXbzZHdTRLWTJGaU9za3pFdyIsImlkIjoiM2o0N0dXbzZHdTRLWTJGaU9za3pFdyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0NTI0Y2YwYTNjMDQ0Y2ZhMzY4Y2UyZTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZQ==", + "MDI0NTI0Y2YwYTNjMDQ0Y2ZhMzY4Y2UyZTMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQ1MjRjZjBhM2MwNDRjZmEzNjhjZTJlMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW1tZXIgQ29vbCBKYXp6IiwicmVsZWFzZV9kYXRlIjoiMjAxOC0wNy0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNqNDdHV282R3U0S1kyRmlPc2t6RXcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8za1VLd1RKZEg4RnVXekY4cDZEZzlFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJpZCI6IjNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJuYW1lIjoiRGF2ZSBCcnViZWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNrVUt3VEpkSDhGdVd6RjhwNkRnOUUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGlSWkFiWXZCcW54cmJzNksyNWFKNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80aVJaQWJZdkJxbnhyYnM2SzI1YUo3IiwiaWQiOiI0aVJaQWJZdkJxbnhyYnM2SzI1YUo3IiwibmFtZSI6IlRoZSBEYXZlIEJydWJlY2sgUXVhcnRldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0aVJaQWJZdkJxbnhyYnM2SzI1YUo3In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNTM0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xNjYwMDI4MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWxJT3NLUkdPRUZnY0tDeG5VRWtzdiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVsSU9zS1JHT0VGZ2NLQ3huVUVrc3YiLCJpZCI6IjVsSU9zS1JHT0VGZ2NLQ3huVUVrc3YiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGFrZSBGaXZlIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVsSU9zS1JHT0VGZ2NLQ3huVUVrc3YifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpcw==", + "dC80aVJaQWJZdkJxbnhyYnM2SzI1YUo3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRpUlpBYll2QnFueHJiczZLMjVhSjciLCJpZCI6IjRpUlpBYll2QnFueHJiczZLMjVhSjciLCJuYW1lIjoiVGhlIERhdmUgQnJ1YmVjayBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRpUlpBYll2QnFueHJiczZLMjVhSjcifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82aDltZzg1WW5wNEt4R3ZpV0FNaG5qIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNmg5bWc4NVlucDRLeEd2aVdBTWhuaiIsImlkIjoiNmg5bWc4NVlucDRLeEd2aVdBTWhuaiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4NGE5MjgzYTFmYThjODdlY2MxMDFmNWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODRhOTI4M2ExZmE4Yzg3ZWNjMTAxZjVkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4NGE5MjgzYTFmYThjODdlY2MxMDFmNWQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU29ueSBKYXp6IFRyaW9zIiwicmVsZWFzZV9kYXRlIjoiMjAwMS0xMC0yOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZoOW1nODVZbnA0S3hHdmlXQU1obmoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRTNuWHlmb2NmN3FmSEFJRk5iQnVqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJFM25YeWZvY2Y3cWZIQUlGTmJCdWoiLCJpZCI6IjJFM25YeWZvY2Y3cWZIQUlGTmJCdWoiLCJuYW1lIjoiQ2FybWVuIE1jUmFlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJFM25YeWZvY2Y3cWZIQUlGTmJCdWoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGlSWkFiWXZCcW54cmJzNksyNWFKNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80aVJaQWJZdkJxbnhyYnM2SzI1YUo3IiwiaWQiOiI0aVJaQWJZdkJxbnhyYnM2SzI1YUo3IiwibmFtZSI6IlRoZSBEYXZlIEJydWJlYw==", + "ayBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRpUlpBYll2QnFueHJiczZLMjVhSjcifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MTM3OTA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEwMDE2MzkzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82V3VGWU9WejVtamZUMVFVMWJlRGJpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNld1RllPVno1bWpmVDFRVTFiZURiaSIsImlkIjoiNld1RllPVno1bWpmVDFRVTFiZURiaSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUYWtlIEZpdmUgKHdpdGggVGhlIERhdmUgQnJ1YmVjayBRdWFydGV0KSAtIFNpbmdsZSBWZXJzaW9uIiwidHJhY2tfbnVtYmVyIjoxOCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2V3VGWU9WejVtamZUMVFVMWJlRGJpIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFWdUNBTnR6eHo1TnRtT0QyeDB5MmUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xVnVDQU50enh6NU50bU9EMngweTJlIiwiaWQiOiIxVnVDQU50enh6NU50bU9EMngweTJlIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIg==", + "OiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDE0Nzg5NDA4NzAwNjVkMGFiYzZiY2RiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjAxNDc4OTQwODcwMDY1ZDBhYmM2YmNkYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDE0Nzg5NDA4NzAwNjVkMGFiYzZiY2RiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bW1lciBKYXp6IiwicmVsZWFzZV9kYXRlIjoiMjAwOS0wNy0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFWdUNBTnR6eHo1TnRtT0QyeDB5MmUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80aVJaQWJZdkJxbnhyYnM2SzI1YUo3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRpUlpBYll2QnFueHJiczZLMjVhSjciLCJpZCI6IjRpUlpBYll2QnFueHJiczZLMjVhSjciLCJuYW1lIjoiVGhlIERhdmUgQnJ1YmVjayBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRpUlpBYll2QnFueHJiczZLMjVhSjcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI0ODAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTE1OTAwMTA4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80WE1BQmZKcFNJbGt1blhoQ2xEMWVCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNFhNQUJmSnBTSWxrdW5YaENsRDFlQiIsImlkIjoiNFhNQUJmSnBTSWxrdW5YaENsRDFlQiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUYWtlIEZpdmUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFhNQUJmSnBTSWxrdW5YaENsRDFlQiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8za1VLd1RKZEg4RnVXekY4cDZEZzlFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJpZCI6IjNrVUt3VEpkSDhGdVd6RjhwNkRnOUUiLCJuYQ==", + "bWUiOiJEYXZlIEJydWJlY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRMUUV4TGJoclM4OVQxV2JHdHN0NGQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80TFFFeExiaHJTODlUMVdiR3RzdDRkIiwiaWQiOiI0TFFFeExiaHJTODlUMVdiR3RzdDRkIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2UyNzZlZTEzNjA2NzIxNjM1ODg4OTQzNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlMjc2ZWUxMzYwNjcyMTYzNTg4ODk0MzcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWUyNzZlZTEzNjA2NzIxNjM1ODg4OTQzNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDb2x1bWJpYSBKYXp6IFByb2ZpbGUiLCJyZWxlYXNlX2RhdGUiOiIyMDA3LTA4LTA5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NExRRXhMYmhyUzg5VDFXYkd0c3Q0ZCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNrVUt3VEpkSDhGdVd6RjhwNkRnOUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSIsImlkIjoiM2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSIsIm5hbWUiOiJEYXZlIEJydWJlY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2tVS3dUSmRIOEZ1V3pGOHA2RGc5RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80aVJaQWJZdkJxbnhyYnM2SzI1YUo3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRpUlpBYll2QnFueHJiczZLMjVhSjciLCJpZCI6IjRpUlpBYll2QnFueHJiczZLMjVhSjciLCJuYW1lIjoiVGhlIERhdmUgQnJ1YmVjayBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRpUlpBYll2QnFueHJiczZLMjVhSjcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI0OTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dA==", + "ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTU5MDAwMjAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZLZm9qMkRDRk1WWGl1dGpZT2hrdTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82S2ZvajJEQ0ZNVlhpdXRqWU9oa3UzIiwiaWQiOiI2S2ZvajJEQ0ZNVlhpdXRqWU9oa3UzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRha2UgRml2ZSAtIEluc3RydW1lbnRhbCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2S2ZvajJEQ0ZNVlhpdXRqWU9oa3UzIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Take+Five%22+artist%3A%22Dave+Brubeck%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Sway%20Norah%20Jones&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Sway%20Norah%20Jones&type=track","offset":0,"previous":null,"total":14,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ArSFkv4OQOosOvYTrZNIl"},"href":"https://api.spotify.com/v1/albums/3ArSFkv4OQOosOvYTrZNIl","id":"3ArSFkv4OQOosOvYTrZNIl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c648a42b5dad72c8aafceeec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c648a42b5dad72c8aafceeec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c648a42b5dad72c8aafceeec"}],"is_playable":true,"name":"Come Away With Me (Super Deluxe Edition)","release_date":"2002-02-26","release_date_precision":"day","total_tracks":44,"type":"album","uri":"spotify:album:3ArSFkv4OQOosOvYTrZNIl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":198226,"explicit":false,"external_ids":{"isrc":"USBN20100889"},"external_urls":{"spotify":"https://open.spotify.com/track/6jGnykaS6TkWp15utXSAeI"},"href":"https://api.spotify.com/v1/tracks/6jGnykaS6TkWp15utXSAeI","id":"6jGnykaS6TkWp15utXSAeI","is_local":false,"is_playable":true,"name":"Come Away With Me","track_number":5,"type":"track","uri":"spotify:track:6jGnykaS6TkWp15utXSAeI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/7GaAXgbFSpcJOiLlFGYyOL"},"href":"https://api.spotify.com/v1/albums/7GaAXgbFSpcJOiLlFGYyOL","id":"7GaAXgbFSpcJOiLlFGYyOL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27364026be0e09c1beda2f67c32"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0264026be0e09c1beda2f67c32"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485164026be0e09c1beda2f67c32"}],"is_playable":true,"name":"Feels Like Home","release_date":"2004-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7GaAXgbFSpcJOiLlFGYyOL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":200626,"explicit":false,"external_ids":{"isrc":"USBN20300893"},"external_urls":{"spotify":"https://open.spotify.com/track/7zkLpY72g6lKQbiHDqri1S"},"href":"https://api.spotify.com/v1/tracks/7zkLpY72g6lKQbiHDqri1S","id":"7zkLpY72g6lKQbiHDqri1S","is_local":false,"is_playable":true,"name":"Sunrise","track_number":1,"type":"track","uri":"spotify:track:7zkLpY72g6lKQbiHDqri1S"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ArSFkv4OQOosOvYTrZNIl"},"href":"https://api.spotify.com/v1/albums/3ArSFkv4OQOosOvYTrZNIl","id":"3ArSFkv4OQOosOvYTrZNIl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c648a42b5dad72c8aafceeec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c648a42b5dad72c8aafceeec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c648a42b5dad72c8aafceeec"}],"is_playable":true,"name":"Come Away With Me (Super Deluxe Edition)","release_date":"2002-02-26","release_date_precision":"day","total_tracks":44,"type":"album","uri":"spotify:album:3ArSFkv4OQOosOvYTrZNIl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":154800,"explicit":false,"external_ids":{"isrc":"USBN20100532"},"external_urls":{"spotify":"https://open.spotify.com/track/1qzHqfvKrZWo6dVHM1dXrj"},"href":"https://api.spotify.com/v1/tracks/1qzHqfvKrZWo6dVHM1dXrj","id":"1qzHqfvKrZWo6dVHM1dXrj","is_local":false,"is_playable":true,"name":"Turn Me On","track_number":7,"type":"track","uri":"spotify:track:1qzHqfvKrZWo6dVHM1dXrj"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Uv86qWpGTxf7fU7lG5X6F"},"href":"https://api.spotify.com/v1/albums/4Uv86qWpGTxf7fU7lG5X6F","id":"4Uv86qWpGTxf7fU7lG5X6F","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27325b055377757b3cdd6f26b78"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0225b055377757b3cdd6f26b78"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485125b055377757b3cdd6f26b78"}],"is_playable":true,"name":"The College Dropout","release_date":"2004-02-10","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4Uv86qWpGTxf7fU7lG5X6F"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"disc_number":1,"duration_ms":182386,"explicit":false,"external_ids":{"isrc":"USDJ20400027"},"external_urls":{"spotify":"https://open.spotify.com/track/1th3G3okofWlvGWAAR7Y4V"},"href":"https://api.spotify.com/v1/tracks/1th3G3okofWlvGWAAR7Y4V","id":"1th3G3okofWlvGWAAR7Y4V","is_local":false,"is_playable":true,"name":"School Spirit","track_number":15,"type":"track","uri":"spotify:track:1th3G3okofWlvGWAAR7Y4V"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2sSGPbdZJkaSE2AbcGOACx"},"href":"https://api.spotify.com/v1/artists/2sSGPbdZJkaSE2AbcGOACx","id":"2sSGPbdZJkaSE2AbcGOACx","name":"The Mar\u00edas","type":"artist","uri":"spotify:artist:2sSGPbdZJkaSE2AbcGOACx"}],"external_urls":{"spotify":"https://open.spotify.com/album/03guxdOi12XJbnvxvxbpwG"},"href":"https://api.spotify.com/v1/albums/03guxdOi12XJbnvxvxbpwG","id":"03guxdOi12XJbnvxvxbpwG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738aa339341a0b0c813909c831"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028aa339341a0b0c813909c831"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518aa339341a0b0c813909c831"}],"is_playable":true,"name":"Submarine","release_date":"2024-05-31","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:03guxdOi12XJbnvxvxbpwG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2sSGPbdZJkaSE2AbcGOACx"},"href":"https://api.spotify.com/v1/artists/2sSGPbdZJkaSE2AbcGOACx","id":"2sSGPbdZJkaSE2AbcGOACx","name":"The Mar\u00edas","type":"artist","uri":"spotify:artist:2sSGPbdZJkaSE2AbcGOACx"}],"disc_number":1,"duration_ms":224840,"explicit":false,"external_ids":{"isrc":"USAT22400849"},"external_urls":{"spotify":"https://open.spotify.com/track/0InIeZW4P6VO7dUGRM4AKH"},"href":"https://api.spotify.com/v1/tracks/0InIeZW4P6VO7dUGRM4AKH","id":"0InIeZW4P6VO7dUGRM4AKH","is_local":false,"is_playable":true,"name":"Sienna","track_number":14,"type":"track","uri":"spotify:track:0InIeZW4P6VO7dUGRM4AKH"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1f5GqyOPo0CkotzzRwviBu"},"href":"https://api.spotify.com/v1/artists/1f5GqyOPo0CkotzzRwviBu","id":"1f5GqyOPo0CkotzzRwviBu","name":"The Lonely Island","type":"artist","uri":"spotify:artist:1f5GqyOPo0CkotzzRwviBu"}],"external_urls":{"spotify":"https://open.spotify.com/album/4IMJWEfkidwtzLanLMAtLP"},"href":"https://api.spotify.com/v1/albums/4IMJWEfkidwtzLanLMAtLP","id":"4IMJWEfkidwtzLanLMAtLP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27351adf6c40da8c3e2635893e9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0251adf6c40da8c3e2635893e9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485151adf6c40da8c3e2635893e9"}],"is_playable":true,"name":"Turtleneck & Chain (Explicit Version)","release_date":"2011-01-01","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:4IMJWEfkidwtzLanLMAtLP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1f5GqyOPo0CkotzzRwviBu"},"href":"https://api.spotify.com/v1/artists/1f5GqyOPo0CkotzzRwviBu","id":"1f5GqyOPo0CkotzzRwviBu","name":"The Lonely Island","type":"artist","uri":"spotify:artist:1f5GqyOPo0CkotzzRwviBu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6YHEMoNPbcheiWS2haGzkn"},"href":"https://api.spotify.com/v1/artists/6YHEMoNPbcheiWS2haGzkn","id":"6YHEMoNPbcheiWS2haGzkn","name":"Michael Bolton","type":"artist","uri":"spotify:artist:6YHEMoNPbcheiWS2haGzkn"}],"disc_number":1,"duration_ms":187746,"explicit":true,"external_ids":{"isrc":"USUM71105294"},"external_urls":{"spotify":"https://open.spotify.com/track/3O9nQmCkiA2VUAqQpkJZhD"},"href":"https://api.spotify.com/v1/tracks/3O9nQmCkiA2VUAqQpkJZhD","id":"3O9nQmCkiA2VUAqQpkJZhD","is_local":false,"is_playable":true,"name":"Jack Sparrow","track_number":4,"type":"track","uri":"spotify:track:3O9nQmCkiA2VUAqQpkJZhD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZotbHeyVQKxQCPDJuQ4SU"},"href":"https://api.spotify.com/v1/artists/3ZotbHeyVQKxQCPDJuQ4SU","id":"3ZotbHeyVQKxQCPDJuQ4SU","name":"Q-Tip","type":"artist","uri":"spotify:artist:3ZotbHeyVQKxQCPDJuQ4SU"}],"external_urls":{"spotify":"https://open.spotify.com/album/3asZSLOAAtCNJz5W2LGuFJ"},"href":"https://api.spotify.com/v1/albums/3asZSLOAAtCNJz5W2LGuFJ","id":"3asZSLOAAtCNJz5W2LGuFJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738257e9f4a030a290f54e851b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028257e9f4a030a290f54e851b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518257e9f4a030a290f54e851b"}],"is_playable":true,"name":"The Renaissance","release_date":"2008-11-04","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3asZSLOAAtCNJz5W2LGuFJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZotbHeyVQKxQCPDJuQ4SU"},"href":"https://api.spotify.com/v1/artists/3ZotbHeyVQKxQCPDJuQ4SU","id":"3ZotbHeyVQKxQCPDJuQ4SU","name":"Q-Tip","type":"artist","uri":"spotify:artist:3ZotbHeyVQKxQCPDJuQ4SU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":281040,"explicit":false,"external_ids":{"isrc":"USUM70840215"},"external_urls":{"spotify":"https://open.spotify.com/track/6N4OkCwoXQYx6bNbJ1eQqs"},"href":"https://api.spotify.com/v1/tracks/6N4OkCwoXQYx6bNbJ1eQqs","id":"6N4OkCwoXQYx6bNbJ1eQqs","is_local":false,"is_playable":true,"name":"Life Is Better","track_number":10,"type":"track","uri":"spotify:track:6N4OkCwoXQYx6bNbJ1eQqs"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2p1fiYHYiXz9qi0JJyxBzN"},"href":"https://api.spotify.com/v1/artists/2p1fiYHYiXz9qi0JJyxBzN","id":"2p1fiYHYiXz9qi0JJyxBzN","name":"Skepta","type":"artist","uri":"spotify:artist:2p1fiYHYiXz9qi0JJyxBzN"}],"external_urls":{"spotify":"https://open.spotify.com/album/58mKKCSrebioH3JkRYKfcq"},"href":"https://api.spotify.com/v1/albums/58mKKCSrebioH3JkRYKfcq","id":"58mKKCSrebioH3JkRYKfcq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273385fb8cb3ba7b72c269fb252"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02385fb8cb3ba7b72c269fb252"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851385fb8cb3ba7b72c269fb252"}],"is_playable":true,"name":"Friendly Fire","release_date":"2025-07-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:58mKKCSrebioH3JkRYKfcq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2p1fiYHYiXz9qi0JJyxBzN"},"href":"https://api.spotify.com/v1/artists/2p1fiYHYiXz9qi0JJyxBzN","id":"2p1fiYHYiXz9qi0JJyxBzN","name":"Skepta","type":"artist","uri":"spotify:artist:2p1fiYHYiXz9qi0JJyxBzN"}],"disc_number":1,"duration_ms":169846,"explicit":true,"external_ids":{"isrc":"GBARL2501084"},"external_urls":{"spotify":"https://open.spotify.com/track/1X9kEJ1M3ZxcGdckUbb47w"},"href":"https://api.spotify.com/v1/tracks/1X9kEJ1M3ZxcGdckUbb47w","id":"1X9kEJ1M3ZxcGdckUbb47w","is_local":false,"is_playable":true,"name":"Friendly Fire","track_number":1,"type":"track","uri":"spotify:track:1X9kEJ1M3ZxcGdckUbb47w"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZotbHeyVQKxQCPDJuQ4SU"},"href":"https://api.spotify.com/v1/artists/3ZotbHeyVQKxQCPDJuQ4SU","id":"3ZotbHeyVQKxQCPDJuQ4SU","name":"Q-Tip","type":"artist","uri":"spotify:artist:3ZotbHeyVQKxQCPDJuQ4SU"}],"external_urls":{"spotify":"https://open.spotify.com/album/6V5Ct3kX5Yk74z4MLZB6h9"},"href":"https://api.spotify.com/v1/albums/6V5Ct3kX5Yk74z4MLZB6h9","id":"6V5Ct3kX5Yk74z4MLZB6h9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734082856470fc5ed78827f267"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024082856470fc5ed78827f267"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514082856470fc5ed78827f267"}],"is_playable":true,"name":"The Renaissance","release_date":"2008-11-04","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6V5Ct3kX5Yk74z4MLZB6h9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZotbHeyVQKxQCPDJuQ4SU"},"href":"https://api.spotify.com/v1/artists/3ZotbHeyVQKxQCPDJuQ4SU","id":"3ZotbHeyVQKxQCPDJuQ4SU","name":"Q-Tip","type":"artist","uri":"spotify:artist:3ZotbHeyVQKxQCPDJuQ4SU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":281040,"explicit":false,"external_ids":{"isrc":"USUM70840215"},"external_urls":{"spotify":"https://open.spotify.com/track/4ihpHBBrKr6wpyAkhoyfmh"},"href":"https://api.spotify.com/v1/tracks/4ihpHBBrKr6wpyAkhoyfmh","id":"4ihpHBBrKr6wpyAkhoyfmh","is_local":false,"is_playable":true,"name":"Life Is Better","track_number":10,"type":"track","uri":"spotify:track:4ihpHBBrKr6wpyAkhoyfmh"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4John8fJ3LKqFho0pselVr"},"href":"https://api.spotify.com/v1/artists/4John8fJ3LKqFho0pselVr","id":"4John8fJ3LKqFho0pselVr","name":"CZARFACE","type":"artist","uri":"spotify:artist:4John8fJ3LKqFho0pselVr"}],"external_urls":{"spotify":"https://open.spotify.com/album/4DB0I6kc8VpP6mbdt0V2Ui"},"href":"https://api.spotify.com/v1/albums/4DB0I6kc8VpP6mbdt0V2Ui","id":"4DB0I6kc8VpP6mbdt0V2Ui","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b04d788bbd2869a0f966df23"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b04d788bbd2869a0f966df23"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b04d788bbd2869a0f966df23"}],"is_playable":true,"name":"Inspectah Deck + 7L & Esoteric = CZARFACE","release_date":"2013-02-19","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4DB0I6kc8VpP6mbdt0V2Ui"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4John8fJ3LKqFho0pselVr"},"href":"https://api.spotify.com/v1/artists/4John8fJ3LKqFho0pselVr","id":"4John8fJ3LKqFho0pselVr","name":"CZARFACE","type":"artist","uri":"spotify:artist:4John8fJ3LKqFho0pselVr"}],"disc_number":1,"duration_ms":177506,"explicit":false,"external_ids":{"isrc":"US4UZ1300014"},"external_urls":{"spotify":"https://open.spotify.com/track/4ysMFEVKoc2RU7Cqr022Qt"},"href":"https://api.spotify.com/v1/tracks/4ysMFEVKoc2RU7Cqr022Qt","id":"4ysMFEVKoc2RU7Cqr022Qt","is_local":false,"is_playable":true,"name":"Hazmat Rap","track_number":14,"type":"track","uri":"spotify:track:4ysMFEVKoc2RU7Cqr022Qt"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Sway%20Norah%20Jones&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Sway%20Norah%20Jones&type=track","offset":0,"previous":null,"total":14,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ArSFkv4OQOosOvYTrZNIl"},"href":"https://api.spotify.com/v1/albums/3ArSFkv4OQOosOvYTrZNIl","id":"3ArSFkv4OQOosOvYTrZNIl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c648a42b5dad72c8aafceeec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c648a42b5dad72c8aafceeec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c648a42b5dad72c8aafceeec"}],"is_playable":true,"name":"Come Away With Me (Super Deluxe Edition)","release_date":"2002-02-26","release_date_precision":"day","total_tracks":44,"type":"album","uri":"spotify:album:3ArSFkv4OQOosOvYTrZNIl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":198226,"explicit":false,"external_ids":{"isrc":"USBN20100889"},"external_urls":{"spotify":"https://open.spotify.com/track/6jGnykaS6TkWp15utXSAeI"},"href":"https://api.spotify.com/v1/tracks/6jGnykaS6TkWp15utXSAeI","id":"6jGnykaS6TkWp15utXSAeI","is_local":false,"is_playable":true,"name":"Come Away With Me","track_number":5,"type":"track","uri":"spotify:track:6jGnykaS6TkWp15utXSAeI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/7GaAXgbFSpcJOiLlFGYyOL"},"href":"https://api.spotify.com/v1/albums/7GaAXgbFSpcJOiLlFGYyOL","id":"7GaAXgbFSpcJOiLlFGYyOL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27364026be0e09c1beda2f67c32"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0264026be0e09c1beda2f67c32"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485164026be0e09c1beda2f67c32"}],"is_playable":true,"name":"Feels Like Home","release_date":"2004-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7GaAXgbFSpcJOiLlFGYyOL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":200626,"explicit":false,"external_ids":{"isrc":"USBN20300893"},"external_urls":{"spotify":"https://open.spotify.com/track/7zkLpY72g6lKQbiHDqri1S"},"href":"https://api.spotify.com/v1/tracks/7zkLpY72g6lKQbiHDqri1S","id":"7zkLpY72g6lKQbiHDqri1S","is_local":false,"is_playable":true,"name":"Sunrise","track_number":1,"type":"track","uri":"spotify:track:7zkLpY72g6lKQbiHDqri1S"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ArSFkv4OQOosOvYTrZNIl"},"href":"https://api.spotify.com/v1/albums/3ArSFkv4OQOosOvYTrZNIl","id":"3ArSFkv4OQOosOvYTrZNIl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c648a42b5dad72c8aafceeec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c648a42b5dad72c8aafceeec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c648a42b5dad72c8aafceeec"}],"is_playable":true,"name":"Come Away With Me (Super Deluxe Edition)","release_date":"2002-02-26","release_date_precision":"day","total_tracks":44,"type":"album","uri":"spotify:album:3ArSFkv4OQOosOvYTrZNIl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":154800,"explicit":false,"external_ids":{"isrc":"USBN20100532"},"external_urls":{"spotify":"https://open.spotify.com/track/1qzHqfvKrZWo6dVHM1dXrj"},"href":"https://api.spotify.com/v1/tracks/1qzHqfvKrZWo6dVHM1dXrj","id":"1qzHqfvKrZWo6dVHM1dXrj","is_local":false,"is_playable":true,"name":"Turn Me On","track_number":7,"type":"track","uri":"spotify:track:1qzHqfvKrZWo6dVHM1dXrj"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Uv86qWpGTxf7fU7lG5X6F"},"href":"https://api.spotify.com/v1/albums/4Uv86qWpGTxf7fU7lG5X6F","id":"4Uv86qWpGTxf7fU7lG5X6F","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27325b055377757b3cdd6f26b78"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0225b055377757b3cdd6f26b78"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485125b055377757b3cdd6f26b78"}],"is_playable":true,"name":"The College Dropout","release_date":"2004-02-10","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4Uv86qWpGTxf7fU7lG5X6F"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"disc_number":1,"duration_ms":182386,"explicit":false,"external_ids":{"isrc":"USDJ20400027"},"external_urls":{"spotify":"https://open.spotify.com/track/1th3G3okofWlvGWAAR7Y4V"},"href":"https://api.spotify.com/v1/tracks/1th3G3okofWlvGWAAR7Y4V","id":"1th3G3okofWlvGWAAR7Y4V","is_local":false,"is_playable":true,"name":"School Spirit","track_number":15,"type":"track","uri":"spotify:track:1th3G3okofWlvGWAAR7Y4V"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2sSGPbdZJkaSE2AbcGOACx"},"href":"https://api.spotify.com/v1/artists/2sSGPbdZJkaSE2AbcGOACx","id":"2sSGPbdZJkaSE2AbcGOACx","name":"The Mar\u00edas","type":"artist","uri":"spotify:artist:2sSGPbdZJkaSE2AbcGOACx"}],"external_urls":{"spotify":"https://open.spotify.com/album/03guxdOi12XJbnvxvxbpwG"},"href":"https://api.spotify.com/v1/albums/03guxdOi12XJbnvxvxbpwG","id":"03guxdOi12XJbnvxvxbpwG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738aa339341a0b0c813909c831"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028aa339341a0b0c813909c831"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518aa339341a0b0c813909c831"}],"is_playable":true,"name":"Submarine","release_date":"2024-05-31","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:03guxdOi12XJbnvxvxbpwG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2sSGPbdZJkaSE2AbcGOACx"},"href":"https://api.spotify.com/v1/artists/2sSGPbdZJkaSE2AbcGOACx","id":"2sSGPbdZJkaSE2AbcGOACx","name":"The Mar\u00edas","type":"artist","uri":"spotify:artist:2sSGPbdZJkaSE2AbcGOACx"}],"disc_number":1,"duration_ms":224840,"explicit":false,"external_ids":{"isrc":"USAT22400849"},"external_urls":{"spotify":"https://open.spotify.com/track/0InIeZW4P6VO7dUGRM4AKH"},"href":"https://api.spotify.com/v1/tracks/0InIeZW4P6VO7dUGRM4AKH","id":"0InIeZW4P6VO7dUGRM4AKH","is_local":false,"is_playable":true,"name":"Sienna","track_number":14,"type":"track","uri":"spotify:track:0InIeZW4P6VO7dUGRM4AKH"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1f5GqyOPo0CkotzzRwviBu"},"href":"https://api.spotify.com/v1/artists/1f5GqyOPo0CkotzzRwviBu","id":"1f5GqyOPo0CkotzzRwviBu","name":"The Lonely Island","type":"artist","uri":"spotify:artist:1f5GqyOPo0CkotzzRwviBu"}],"external_urls":{"spotify":"https://open.spotify.com/album/4IMJWEfkidwtzLanLMAtLP"},"href":"https://api.spotify.com/v1/albums/4IMJWEfkidwtzLanLMAtLP","id":"4IMJWEfkidwtzLanLMAtLP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27351adf6c40da8c3e2635893e9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0251adf6c40da8c3e2635893e9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485151adf6c40da8c3e2635893e9"}],"is_playable":true,"name":"Turtleneck & Chain (Explicit Version)","release_date":"2011-01-01","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:4IMJWEfkidwtzLanLMAtLP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1f5GqyOPo0CkotzzRwviBu"},"href":"https://api.spotify.com/v1/artists/1f5GqyOPo0CkotzzRwviBu","id":"1f5GqyOPo0CkotzzRwviBu","name":"The Lonely Island","type":"artist","uri":"spotify:artist:1f5GqyOPo0CkotzzRwviBu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6YHEMoNPbcheiWS2haGzkn"},"href":"https://api.spotify.com/v1/artists/6YHEMoNPbcheiWS2haGzkn","id":"6YHEMoNPbcheiWS2haGzkn","name":"Michael Bolton","type":"artist","uri":"spotify:artist:6YHEMoNPbcheiWS2haGzkn"}],"disc_number":1,"duration_ms":187746,"explicit":true,"external_ids":{"isrc":"USUM71105294"},"external_urls":{"spotify":"https://open.spotify.com/track/3O9nQmCkiA2VUAqQpkJZhD"},"href":"https://api.spotify.com/v1/tracks/3O9nQmCkiA2VUAqQpkJZhD","id":"3O9nQmCkiA2VUAqQpkJZhD","is_local":false,"is_playable":true,"name":"Jack Sparrow","track_number":4,"type":"track","uri":"spotify:track:3O9nQmCkiA2VUAqQpkJZhD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZotbHeyVQKxQCPDJuQ4SU"},"href":"https://api.spotify.com/v1/artists/3ZotbHeyVQKxQCPDJuQ4SU","id":"3ZotbHeyVQKxQCPDJuQ4SU","name":"Q-Tip","type":"artist","uri":"spotify:artist:3ZotbHeyVQKxQCPDJuQ4SU"}],"external_urls":{"spotify":"https://open.spotify.com/album/3asZSLOAAtCNJz5W2LGuFJ"},"href":"https://api.spotify.com/v1/albums/3asZSLOAAtCNJz5W2LGuFJ","id":"3asZSLOAAtCNJz5W2LGuFJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738257e9f4a030a290f54e851b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028257e9f4a030a290f54e851b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518257e9f4a030a290f54e851b"}],"is_playable":true,"name":"The Renaissance","release_date":"2008-11-04","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3asZSLOAAtCNJz5W2LGuFJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZotbHeyVQKxQCPDJuQ4SU"},"href":"https://api.spotify.com/v1/artists/3ZotbHeyVQKxQCPDJuQ4SU","id":"3ZotbHeyVQKxQCPDJuQ4SU","name":"Q-Tip","type":"artist","uri":"spotify:artist:3ZotbHeyVQKxQCPDJuQ4SU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":281040,"explicit":false,"external_ids":{"isrc":"USUM70840215"},"external_urls":{"spotify":"https://open.spotify.com/track/6N4OkCwoXQYx6bNbJ1eQqs"},"href":"https://api.spotify.com/v1/tracks/6N4OkCwoXQYx6bNbJ1eQqs","id":"6N4OkCwoXQYx6bNbJ1eQqs","is_local":false,"is_playable":true,"name":"Life Is Better","track_number":10,"type":"track","uri":"spotify:track:6N4OkCwoXQYx6bNbJ1eQqs"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2p1fiYHYiXz9qi0JJyxBzN"},"href":"https://api.spotify.com/v1/artists/2p1fiYHYiXz9qi0JJyxBzN","id":"2p1fiYHYiXz9qi0JJyxBzN","name":"Skepta","type":"artist","uri":"spotify:artist:2p1fiYHYiXz9qi0JJyxBzN"}],"external_urls":{"spotify":"https://open.spotify.com/album/58mKKCSrebioH3JkRYKfcq"},"href":"https://api.spotify.com/v1/albums/58mKKCSrebioH3JkRYKfcq","id":"58mKKCSrebioH3JkRYKfcq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273385fb8cb3ba7b72c269fb252"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02385fb8cb3ba7b72c269fb252"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851385fb8cb3ba7b72c269fb252"}],"is_playable":true,"name":"Friendly Fire","release_date":"2025-07-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:58mKKCSrebioH3JkRYKfcq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2p1fiYHYiXz9qi0JJyxBzN"},"href":"https://api.spotify.com/v1/artists/2p1fiYHYiXz9qi0JJyxBzN","id":"2p1fiYHYiXz9qi0JJyxBzN","name":"Skepta","type":"artist","uri":"spotify:artist:2p1fiYHYiXz9qi0JJyxBzN"}],"disc_number":1,"duration_ms":169846,"explicit":true,"external_ids":{"isrc":"GBARL2501084"},"external_urls":{"spotify":"https://open.spotify.com/track/1X9kEJ1M3ZxcGdckUbb47w"},"href":"https://api.spotify.com/v1/tracks/1X9kEJ1M3ZxcGdckUbb47w","id":"1X9kEJ1M3ZxcGdckUbb47w","is_local":false,"is_playable":true,"name":"Friendly Fire","track_number":1,"type":"track","uri":"spotify:track:1X9kEJ1M3ZxcGdckUbb47w"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZotbHeyVQKxQCPDJuQ4SU"},"href":"https://api.spotify.com/v1/artists/3ZotbHeyVQKxQCPDJuQ4SU","id":"3ZotbHeyVQKxQCPDJuQ4SU","name":"Q-Tip","type":"artist","uri":"spotify:artist:3ZotbHeyVQKxQCPDJuQ4SU"}],"external_urls":{"spotify":"https://open.spotify.com/album/6V5Ct3kX5Yk74z4MLZB6h9"},"href":"https://api.spotify.com/v1/albums/6V5Ct3kX5Yk74z4MLZB6h9","id":"6V5Ct3kX5Yk74z4MLZB6h9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734082856470fc5ed78827f267"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024082856470fc5ed78827f267"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514082856470fc5ed78827f267"}],"is_playable":true,"name":"The Renaissance","release_date":"2008-11-04","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6V5Ct3kX5Yk74z4MLZB6h9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZotbHeyVQKxQCPDJuQ4SU"},"href":"https://api.spotify.com/v1/artists/3ZotbHeyVQKxQCPDJuQ4SU","id":"3ZotbHeyVQKxQCPDJuQ4SU","name":"Q-Tip","type":"artist","uri":"spotify:artist:3ZotbHeyVQKxQCPDJuQ4SU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Kx7MNY7cI1ENniW7vT30N"},"href":"https://api.spotify.com/v1/artists/2Kx7MNY7cI1ENniW7vT30N","id":"2Kx7MNY7cI1ENniW7vT30N","name":"Norah Jones","type":"artist","uri":"spotify:artist:2Kx7MNY7cI1ENniW7vT30N"}],"disc_number":1,"duration_ms":281040,"explicit":false,"external_ids":{"isrc":"USUM70840215"},"external_urls":{"spotify":"https://open.spotify.com/track/4ihpHBBrKr6wpyAkhoyfmh"},"href":"https://api.spotify.com/v1/tracks/4ihpHBBrKr6wpyAkhoyfmh","id":"4ihpHBBrKr6wpyAkhoyfmh","is_local":false,"is_playable":true,"name":"Life Is Better","track_number":10,"type":"track","uri":"spotify:track:4ihpHBBrKr6wpyAkhoyfmh"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4John8fJ3LKqFho0pselVr"},"href":"https://api.spotify.com/v1/artists/4John8fJ3LKqFho0pselVr","id":"4John8fJ3LKqFho0pselVr","name":"CZARFACE","type":"artist","uri":"spotify:artist:4John8fJ3LKqFho0pselVr"}],"external_urls":{"spotify":"https://open.spotify.com/album/4DB0I6kc8VpP6mbdt0V2Ui"},"href":"https://api.spotify.com/v1/albums/4DB0I6kc8VpP6mbdt0V2Ui","id":"4DB0I6kc8VpP6mbdt0V2Ui","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b04d788bbd2869a0f966df23"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b04d788bbd2869a0f966df23"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b04d788bbd2869a0f966df23"}],"is_playable":true,"name":"Inspectah Deck + 7L & Esoteric = CZARFACE","release_date":"2013-02-19","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4DB0I6kc8VpP6mbdt0V2Ui"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4John8fJ3LKqFho0pselVr"},"href":"https://api.spotify.com/v1/artists/4John8fJ3LKqFho0pselVr","id":"4John8fJ3LKqFho0pselVr","name":"CZARFACE","type":"artist","uri":"spotify:artist:4John8fJ3LKqFho0pselVr"}],"disc_number":1,"duration_ms":177506,"explicit":false,"external_ids":{"isrc":"US4UZ1300014"},"external_urls":{"spotify":"https://open.spotify.com/track/4ysMFEVKoc2RU7Cqr022Qt"},"href":"https://api.spotify.com/v1/tracks/4ysMFEVKoc2RU7Cqr022Qt","id":"4ysMFEVKoc2RU7Cqr022Qt","is_local":false,"is_playable":true,"name":"Hazmat Rap","track_number":14,"type":"track","uri":"spotify:track:4ysMFEVKoc2RU7Cqr022Qt"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Sway+Norah+Jones&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Blue%20Bossa%22%20artist%3A%22Kenny%20Dorham%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Z8TRoOzgzgGFuSmk360LY"},"href":"https://api.spotify.com/v1/artists/0Z8TRoOzgzgGFuSmk360LY","id":"0Z8TRoOzgzgGFuSmk360LY","name":"Davidsen Duo","type":"artist","uri":"spotify:artist:0Z8TRoOzgzgGFuSmk360LY"}],"external_urls":{"spotify":"https://open.spotify.com/album/7x2386rrf5wCd3ZW6X19kA"},"href":"https://api.spotify.com/v1/albums/7x2386rrf5wCd3ZW6X19kA","id":"7x2386rrf5wCd3ZW6X19kA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27341f78d8c1ad74a14c01e24a3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0241f78d8c1ad74a14c01e24a3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485141f78d8c1ad74a14c01e24a3"}],"is_playable":true,"name":"Moments","release_date":"2005-02-28","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:7x2386rrf5wCd3ZW6X19kA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fMvylhnE23sAlyePKK8er"},"href":"https://api.spotify.com/v1/artists/2fMvylhnE23sAlyePKK8er","id":"2fMvylhnE23sAlyePKK8er","name":"Kenny Dorham","type":"artist","uri":"spotify:artist:2fMvylhnE23sAlyePKK8er"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0Z8TRoOzgzgGFuSmk360LY"},"href":"https://api.spotify.com/v1/artists/0Z8TRoOzgzgGFuSmk360LY","id":"0Z8TRoOzgzgGFuSmk360LY","name":"Davidsen Duo","type":"artist","uri":"spotify:artist:0Z8TRoOzgzgGFuSmk360LY"}],"disc_number":1,"duration_ms":162320,"explicit":false,"external_ids":{"isrc":"NOARG0506150"},"external_urls":{"spotify":"https://open.spotify.com/track/1z0ibdcLwz3TwZgUIWzXd5"},"href":"https://api.spotify.com/v1/tracks/1z0ibdcLwz3TwZgUIWzXd5","id":"1z0ibdcLwz3TwZgUIWzXd5","is_local":false,"is_playable":true,"name":"Blue Bossa","track_number":15,"type":"track","uri":"spotify:track:1z0ibdcLwz3TwZgUIWzXd5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1qXhFsIL769tMSqqFmyOYm"},"href":"https://api.spotify.com/v1/artists/1qXhFsIL769tMSqqFmyOYm","id":"1qXhFsIL769tMSqqFmyOYm","name":"Gianluca Damiano","type":"artist","uri":"spotify:artist:1qXhFsIL769tMSqqFmyOYm"}],"external_urls":{"spotify":"https://open.spotify.com/album/6KbkOwjRelHz9mNSQ38jKO"},"href":"https://api.spotify.com/v1/albums/6KbkOwjRelHz9mNSQ38jKO","id":"6KbkOwjRelHz9mNSQ38jKO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e99b11cd67b5603df4154708"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e99b11cd67b5603df4154708"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e99b11cd67b5603df4154708"}],"is_playable":true,"name":"Afternoon in Paris","release_date":"2022-07-29","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:6KbkOwjRelHz9mNSQ38jKO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fMvylhnE23sAlyePKK8er"},"href":"https://api.spotify.com/v1/artists/2fMvylhnE23sAlyePKK8er","id":"2fMvylhnE23sAlyePKK8er","name":"Kenny Dorham","type":"artist","uri":"spotify:artist:2fMvylhnE23sAlyePKK8er"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1qXhFsIL769tMSqqFmyOYm"},"href":"https://api.spotify.com/v1/artists/1qXhFsIL769tMSqqFmyOYm","id":"1qXhFsIL769tMSqqFmyOYm","name":"Gianluca Damiano","type":"artist","uri":"spotify:artist:1qXhFsIL769tMSqqFmyOYm"}],"disc_number":1,"duration_ms":261579,"explicit":false,"external_ids":{"isrc":"ITN9E2100267"},"external_urls":{"spotify":"https://open.spotify.com/track/0kvgsDsSjA3zkqQImZLhTt"},"href":"https://api.spotify.com/v1/tracks/0kvgsDsSjA3zkqQImZLhTt","id":"0kvgsDsSjA3zkqQImZLhTt","is_local":false,"is_playable":true,"name":"Blue Bossa","track_number":4,"type":"track","uri":"spotify:track:0kvgsDsSjA3zkqQImZLhTt"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fMvylhnE23sAlyePKK8er"},"href":"https://api.spotify.com/v1/artists/2fMvylhnE23sAlyePKK8er","id":"2fMvylhnE23sAlyePKK8er","name":"Kenny Dorham","type":"artist","uri":"spotify:artist:2fMvylhnE23sAlyePKK8er"}],"external_urls":{"spotify":"https://open.spotify.com/album/4XfhYsc5kry9QYsiTkqBwm"},"href":"https://api.spotify.com/v1/albums/4XfhYsc5kry9QYsiTkqBwm","id":"4XfhYsc5kry9QYsiTkqBwm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273731b8b11fc60d9f5377be17f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02731b8b11fc60d9f5377be17f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851731b8b11fc60d9f5377be17f"}],"is_playable":true,"name":"Blue Bossa (Live at the Blue Morocco in the Bronx, New York in 1967)","release_date":"2025-02-14","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4XfhYsc5kry9QYsiTkqBwm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fMvylhnE23sAlyePKK8er"},"href":"https://api.spotify.com/v1/artists/2fMvylhnE23sAlyePKK8er","id":"2fMvylhnE23sAlyePKK8er","name":"Kenny Dorham","type":"artist","uri":"spotify:artist:2fMvylhnE23sAlyePKK8er"}],"disc_number":1,"duration_ms":811364,"explicit":false,"external_ids":{"isrc":"USA2P2505987"},"external_urls":{"spotify":"https://open.spotify.com/track/6QEHAJDQSZSIWigmVQmDMq"},"href":"https://api.spotify.com/v1/tracks/6QEHAJDQSZSIWigmVQmDMq","id":"6QEHAJDQSZSIWigmVQmDMq","is_local":false,"is_playable":true,"name":"Blue Bossa (Live at the Blue Morocco in the Bronx, New York in 1967)","track_number":1,"type":"track","uri":"spotify:track:6QEHAJDQSZSIWigmVQmDMq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fMvylhnE23sAlyePKK8er"},"href":"https://api.spotify.com/v1/artists/2fMvylhnE23sAlyePKK8er","id":"2fMvylhnE23sAlyePKK8er","name":"Kenny Dorham","type":"artist","uri":"spotify:artist:2fMvylhnE23sAlyePKK8er"}],"external_urls":{"spotify":"https://open.spotify.com/album/01ifyxBTi2HumBn7f52YyO"},"href":"https://api.spotify.com/v1/albums/01ifyxBTi2HumBn7f52YyO","id":"01ifyxBTi2HumBn7f52YyO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27300e25283a57d1a0ad3b6cfb2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0200e25283a57d1a0ad3b6cfb2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485100e25283a57d1a0ad3b6cfb2"}],"is_playable":true,"name":"Bossa In The Bronx: Live from the Blue Morocco","release_date":"2025-05-30","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:01ifyxBTi2HumBn7f52YyO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fMvylhnE23sAlyePKK8er"},"href":"https://api.spotify.com/v1/artists/2fMvylhnE23sAlyePKK8er","id":"2fMvylhnE23sAlyePKK8er","name":"Kenny Dorham","type":"artist","uri":"spotify:artist:2fMvylhnE23sAlyePKK8er"}],"disc_number":1,"duration_ms":811364,"explicit":false,"external_ids":{"isrc":"USA2P2505096"},"external_urls":{"spotify":"https://open.spotify.com/track/6SX18CvytMhdsMFMR65rIi"},"href":"https://api.spotify.com/v1/tracks/6SX18CvytMhdsMFMR65rIi","id":"6SX18CvytMhdsMFMR65rIi","is_local":false,"is_playable":true,"name":"Blue Bossa (Live at the Blue Morocco in the Bronx, New York, 1967)","track_number":1,"type":"track","uri":"spotify:track:6SX18CvytMhdsMFMR65rIi"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJsdWUlMjBCb3NzYSUyMiUyMGFydGlzdCUzQSUyMktlbm55JTIwRG9yaGFtJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wWjhUUm9Pemd6Z0dGdVNtazM2MExZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBaOFRSb096Z3pnR0Z1U21rMzYwTFkiLCJpZCI6IjBaOFRSb096Z3pnR0Z1U21rMzYwTFkiLCJuYW1lIjoiRGF2aWRzZW4gRHVvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBaOFRSb096Z3pnR0Z1U21rMzYwTFkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83eDIzODZycmY1d0NkM1pXNlgxOWtBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3gyMzg2cnJmNXdDZDNaVzZYMTlrQSIsImlkIjoiN3gyMzg2cnJmNXdDZDNaVzZYMTlrQSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLg==", + "Y28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQxZjc4ZDhjMWFkNzRhMTRjMDFlMjRhMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0MWY3OGQ4YzFhZDc0YTE0YzAxZTI0YTMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQxZjc4ZDhjMWFkNzRhMTRjMDFlMjRhMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb21lbnRzIiwicmVsZWFzZV9kYXRlIjoiMjAwNS0wMi0yOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjd4MjM4NnJyZjV3Q2QzWlc2WDE5a0EifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yZk12eWxobkUyM3NBbHllUEtLOGVyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJmTXZ5bGhuRTIzc0FseWVQS0s4ZXIiLCJpZCI6IjJmTXZ5bGhuRTIzc0FseWVQS0s4ZXIiLCJuYW1lIjoiS2VubnkgRG9yaGFtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJmTXZ5bGhuRTIzc0FseWVQS0s4ZXIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFo4VFJvT3pnemdHRnVTbWszNjBMWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wWjhUUm9Pemd6Z0dGdVNtazM2MExZIiwiaWQiOiIwWjhUUm9Pemd6Z0dGdVNtazM2MExZIiwibmFtZSI6IkRhdmlkc2VuIER1byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowWjhUUm9Pemd6Z0dGdVNtazM2MExZIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2MjMyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5PQVJHMDUwNjE1MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXowaWJkY0x3ejNUd1pnVUlXelhkNSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzF6MGliZGNMd3ozVHdaZ1VJV3pYZDUiLCJpZCI6IjF6MGliZGNMd3ozVHdaZ1VJV3pYZDUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmx1ZSBCb3NzYSIsInRyYWNrX251bWJlciI6MTUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXowaWJkY0x3ejNUd1pnVUlXelhkNQ==", + "In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFxWGhGc0lMNzY5dE1TcXFGbXlPWW0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXFYaEZzSUw3Njl0TVNxcUZteU9ZbSIsImlkIjoiMXFYaEZzSUw3Njl0TVNxcUZteU9ZbSIsIm5hbWUiOiJHaWFubHVjYSBEYW1pYW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFxWGhGc0lMNzY5dE1TcXFGbXlPWW0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82S2JrT3dqUmVsSHo5bU5TUTM4aktPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNktia093alJlbEh6OW1OU1EzOGpLTyIsImlkIjoiNktia093alJlbEh6OW1OU1EzOGpLTyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlOTliMTFjZDY3YjU2MDNkZjQxNTQ3MDgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTk5YjExY2Q2N2I1NjAzZGY0MTU0NzA4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlOTliMTFjZDY3YjU2MDNkZjQxNTQ3MDgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWZ0ZXJub29uIGluIFBhcmlzIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0wNy0yOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nktia093alJlbEh6OW1OU1EzOGpLTyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJmTXZ5bGhuRTIzc0FseWVQS0s4ZXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmZNdnlsaG5FMjNzQWx5ZVBLSzhlciIsImlkIjoiMmZNdnlsaG5FMjNzQWx5ZVBLSzhlciIsIm5hbWUiOiJLZW5ueSBEb3JoYW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmZNdnlsaG5FMjNzQWx5ZVBLSzhlciJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xcVhoRnNJTDc2OXRNU3FxRm15T1ltIn0sImhyZWYiOiJodHRwczovL2FwaS5zcA==", + "b3RpZnkuY29tL3YxL2FydGlzdHMvMXFYaEZzSUw3Njl0TVNxcUZteU9ZbSIsImlkIjoiMXFYaEZzSUw3Njl0TVNxcUZteU9ZbSIsIm5hbWUiOiJHaWFubHVjYSBEYW1pYW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFxWGhGc0lMNzY5dE1TcXFGbXlPWW0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjYxNTc5LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiSVROOUUyMTAwMjY3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wa3Znc0RzU2pBM3prcVFJbVpMaFR0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGt2Z3NEc1NqQTN6a3FRSW1aTGhUdCIsImlkIjoiMGt2Z3NEc1NqQTN6a3FRSW1aTGhUdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCbHVlIEJvc3NhIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBrdmdzRHNTakEzemtxUUltWkxoVHQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJmTXZ5bGhuRTIzc0FseWVQS0s4ZXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmZNdnlsaG5FMjNzQWx5ZVBLSzhlciIsImlkIjoiMmZNdnlsaG5FMjNzQWx5ZVBLSzhlciIsIm5hbWUiOiJLZW5ueSBEb3JoYW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmZNdnlsaG5FMjNzQWx5ZVBLSzhlciJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRYZmhZc2M1a3J5OVFZc2lUa3FCd20ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80WGZoWXNjNWtyeTlRWXNpVGtxQndtIiwiaWQiOiI0WGZoWXNjNWtyeTlRWXNpVGtxQndtIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzczMWI4YjExZmM2MGQ5ZjUzNzdiZTE3ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3MzFiOGIxMWZjNjBkOWY1Mzc3YmUxN2YifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTczMWI4YjExZmM2MGQ5ZjUzNzdiZTE3ZiJ9XSwiaXNfcA==", + "bGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJsdWUgQm9zc2EgKExpdmUgYXQgdGhlIEJsdWUgTW9yb2NjbyBpbiB0aGUgQnJvbngsIE5ldyBZb3JrIGluIDE5NjcpIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMi0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFhmaFlzYzVrcnk5UVlzaVRrcUJ3bSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJmTXZ5bGhuRTIzc0FseWVQS0s4ZXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmZNdnlsaG5FMjNzQWx5ZVBLSzhlciIsImlkIjoiMmZNdnlsaG5FMjNzQWx5ZVBLSzhlciIsIm5hbWUiOiJLZW5ueSBEb3JoYW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmZNdnlsaG5FMjNzQWx5ZVBLSzhlciJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo4MTEzNjQsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0EyUDI1MDU5ODcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZRRUhBSkRRU1pTSVdpZ21WUW1ETXEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82UUVIQUpEUVNaU0lXaWdtVlFtRE1xIiwiaWQiOiI2UUVIQUpEUVNaU0lXaWdtVlFtRE1xIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJsdWUgQm9zc2EgKExpdmUgYXQgdGhlIEJsdWUgTW9yb2NjbyBpbiB0aGUgQnJvbngsIE5ldyBZb3JrIGluIDE5NjcpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZRRUhBSkRRU1pTSVdpZ21WUW1ETXEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmZNdnlsaG5FMjNzQWx5ZVBLSzhlciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yZk12eWxobkUyM3NBbHllUEtLOGVyIiwiaWQiOiIyZk12eWxobkUyM3NBbHllUEtLOGVyIiwibmFtZSI6Iktlbm55IERvcmhhbSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyZk12eWxobkUyM3NBbHllUEtLOGVyIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMDFpZnl4QlRpMkh1bUJuN2Y1Mll5TyJ9LCJocmVmIjoiaA==", + "dHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDFpZnl4QlRpMkh1bUJuN2Y1Mll5TyIsImlkIjoiMDFpZnl4QlRpMkh1bUJuN2Y1Mll5TyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwMGUyNTI4M2E1N2QxYTBhZDNiNmNmYjIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDBlMjUyODNhNTdkMWEwYWQzYjZjZmIyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwMGUyNTI4M2E1N2QxYTBhZDNiNmNmYjIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQm9zc2EgSW4gVGhlIEJyb254OiBMaXZlIGZyb20gdGhlIEJsdWUgTW9yb2NjbyIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDUtMzAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjAxaWZ5eEJUaTJIdW1CbjdmNTJZeU8ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yZk12eWxobkUyM3NBbHllUEtLOGVyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJmTXZ5bGhuRTIzc0FseWVQS0s4ZXIiLCJpZCI6IjJmTXZ5bGhuRTIzc0FseWVQS0s4ZXIiLCJuYW1lIjoiS2VubnkgRG9yaGFtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJmTXZ5bGhuRTIzc0FseWVQS0s4ZXIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6ODExMzY0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBMlAyNTA1MDk2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82U1gxOEN2eXRNaGRzTUZNUjY1cklpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNlNYMThDdnl0TWhkc01GTVI2NXJJaSIsImlkIjoiNlNYMThDdnl0TWhkc01GTVI2NXJJaSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCbHVlIEJvc3NhIChMaXZlIGF0IHRoZSBCbHVlIE1vcm9jY28gaW4gdGhlIEJyb254LCBOZXcgWW9yaywgMTk2NykiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NlNYMThDdnl0TWhkc01GTVI2NXJJaSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Blue+Bossa%22+artist%3A%22Kenny+Dorham%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Moonlight%20in%20Vermont%22%20artist%3A%22Johnny%20Smith%22&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=track%3A%22Moonlight%20in%20Vermont%22%20artist%3A%22Johnny%20Smith%22&type=track","offset":0,"previous":null,"total":17,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2N3DoTjaVvmRZIx6AIkOv5"},"href":"https://api.spotify.com/v1/artists/2N3DoTjaVvmRZIx6AIkOv5","id":"2N3DoTjaVvmRZIx6AIkOv5","name":"Stan Getz Quintet","type":"artist","uri":"spotify:artist:2N3DoTjaVvmRZIx6AIkOv5"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"external_urls":{"spotify":"https://open.spotify.com/album/2nD2XmdAaogJHbWlREIu3O"},"href":"https://api.spotify.com/v1/albums/2nD2XmdAaogJHbWlREIu3O","id":"2nD2XmdAaogJHbWlREIu3O","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736dae122a620b6a1b8068712f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026dae122a620b6a1b8068712f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516dae122a620b6a1b8068712f"}],"is_playable":true,"name":"Moonlight On Vermont - The Roost Recordings","release_date":"2010-01-08","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:2nD2XmdAaogJHbWlREIu3O"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"disc_number":1,"duration_ms":195746,"explicit":false,"external_ids":{"isrc":"NLG620419757"},"external_urls":{"spotify":"https://open.spotify.com/track/3GijK6y7FQ2p5YMEgN85RH"},"href":"https://api.spotify.com/v1/tracks/3GijK6y7FQ2p5YMEgN85RH","id":"3GijK6y7FQ2p5YMEgN85RH","is_local":false,"is_playable":true,"name":"Moonlight In Vermont","track_number":8,"type":"track","uri":"spotify:track:3GijK6y7FQ2p5YMEgN85RH"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"external_urls":{"spotify":"https://open.spotify.com/album/46m2vVGJn0cSaVBsHMzYgW"},"href":"https://api.spotify.com/v1/albums/46m2vVGJn0cSaVBsHMzYgW","id":"46m2vVGJn0cSaVBsHMzYgW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273584c7e3b0105b93dda775a58"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02584c7e3b0105b93dda775a58"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851584c7e3b0105b93dda775a58"}],"is_playable":true,"name":"Moonlight In Vermont","release_date":"1956-01-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:46m2vVGJn0cSaVBsHMzYgW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"disc_number":1,"duration_ms":195693,"explicit":false,"external_ids":{"isrc":"GBAYE5200123"},"external_urls":{"spotify":"https://open.spotify.com/track/18CUQDqPQzbtk06xp2TG7A"},"href":"https://api.spotify.com/v1/tracks/18CUQDqPQzbtk06xp2TG7A","id":"18CUQDqPQzbtk06xp2TG7A","is_local":false,"is_playable":true,"name":"Moonlight in Vermont","track_number":3,"type":"track","uri":"spotify:track:18CUQDqPQzbtk06xp2TG7A"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/52zwSjXRQJor9U8Ti84m64"},"href":"https://api.spotify.com/v1/albums/52zwSjXRQJor9U8Ti84m64","id":"52zwSjXRQJor9U8Ti84m64","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ab863ae53a71afb5fbfb888d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ab863ae53a71afb5fbfb888d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ab863ae53a71afb5fbfb888d"}],"is_playable":true,"name":"Complete Roost Recordings","release_date":"1997-11-10","release_date_precision":"day","total_tracks":59,"type":"album","uri":"spotify:album:52zwSjXRQJor9U8Ti84m64"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"disc_number":3,"duration_ms":195760,"explicit":false,"external_ids":{"isrc":"GBAYE5200009"},"external_urls":{"spotify":"https://open.spotify.com/track/1ST91fDj40GKh4dIrc20CP"},"href":"https://api.spotify.com/v1/tracks/1ST91fDj40GKh4dIrc20CP","id":"1ST91fDj40GKh4dIrc20CP","is_local":false,"is_playable":true,"name":"Moonlight in Vermont","track_number":14,"type":"track","uri":"spotify:track:1ST91fDj40GKh4dIrc20CP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"external_urls":{"spotify":"https://open.spotify.com/album/7qRRW8VHzLTf7R65ePC7OQ"},"href":"https://api.spotify.com/v1/albums/7qRRW8VHzLTf7R65ePC7OQ","id":"7qRRW8VHzLTf7R65ePC7OQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273047f4764bf0727ca3cde64de"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02047f4764bf0727ca3cde64de"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851047f4764bf0727ca3cde64de"}],"is_playable":true,"name":"Moonlight In Vermont","release_date":"1956-01-01","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:7qRRW8VHzLTf7R65ePC7OQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"disc_number":1,"duration_ms":195693,"explicit":false,"external_ids":{"isrc":"GBAYE5200123"},"external_urls":{"spotify":"https://open.spotify.com/track/3UGt7hMXkidiYgV2XW2KFK"},"href":"https://api.spotify.com/v1/tracks/3UGt7hMXkidiYgV2XW2KFK","id":"3UGt7hMXkidiYgV2XW2KFK","is_local":false,"is_playable":true,"name":"Moonlight in Vermont","track_number":3,"type":"track","uri":"spotify:track:3UGt7hMXkidiYgV2XW2KFK"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"external_urls":{"spotify":"https://open.spotify.com/album/61wwrS1tDNzvCBBX1gHJi7"},"href":"https://api.spotify.com/v1/albums/61wwrS1tDNzvCBBX1gHJi7","id":"61wwrS1tDNzvCBBX1gHJi7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27383aa07b18e66ee69b579a8e4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0283aa07b18e66ee69b579a8e4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485183aa07b18e66ee69b579a8e4"}],"is_playable":true,"name":"Spring Is Here - The Guitar Genius Of","release_date":"1952-01-01","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:61wwrS1tDNzvCBBX1gHJi7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"disc_number":1,"duration_ms":196946,"explicit":false,"external_ids":{"isrc":"GBBLY0602556"},"external_urls":{"spotify":"https://open.spotify.com/track/35o1DxdvVjHUKPRNVRMSxQ"},"href":"https://api.spotify.com/v1/tracks/35o1DxdvVjHUKPRNVRMSxQ","id":"35o1DxdvVjHUKPRNVRMSxQ","is_local":false,"is_playable":true,"name":"Moonlight In Vermont","track_number":3,"type":"track","uri":"spotify:track:35o1DxdvVjHUKPRNVRMSxQ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Dsh4yEiSawGiE7JZ5yvM3"},"href":"https://api.spotify.com/v1/albums/6Dsh4yEiSawGiE7JZ5yvM3","id":"6Dsh4yEiSawGiE7JZ5yvM3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273510da1f865b0a22ea114973e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02510da1f865b0a22ea114973e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851510da1f865b0a22ea114973e"}],"is_playable":true,"name":"Music Legends Stan Getz: The Jazz Master","release_date":"2026-05-22","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:6Dsh4yEiSawGiE7JZ5yvM3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FMucZsEnCxs5pqBjHjIc8"},"href":"https://api.spotify.com/v1/artists/0FMucZsEnCxs5pqBjHjIc8","id":"0FMucZsEnCxs5pqBjHjIc8","name":"Stan Getz","type":"artist","uri":"spotify:artist:0FMucZsEnCxs5pqBjHjIc8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"disc_number":1,"duration_ms":143800,"explicit":false,"external_ids":{"isrc":"FR6F32660920"},"external_urls":{"spotify":"https://open.spotify.com/track/6Gc94erZ1Hi7CC79SMDHzJ"},"href":"https://api.spotify.com/v1/tracks/6Gc94erZ1Hi7CC79SMDHzJ","id":"6Gc94erZ1Hi7CC79SMDHzJ","is_local":false,"is_playable":true,"name":"Moonlight in Vermont","track_number":9,"type":"track","uri":"spotify:track:6Gc94erZ1Hi7CC79SMDHzJ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"external_urls":{"spotify":"https://open.spotify.com/album/2T0oVRgZ39wkFqk3K6VuxK"},"href":"https://api.spotify.com/v1/albums/2T0oVRgZ39wkFqk3K6VuxK","id":"2T0oVRgZ39wkFqk3K6VuxK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273550fc411f1b0390343375b39"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02550fc411f1b0390343375b39"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851550fc411f1b0390343375b39"}],"is_playable":true,"name":"The Last Night at Shaner's (Live)","release_date":"2024-07-23","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:2T0oVRgZ39wkFqk3K6VuxK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/38A8T54Gkz9CBdaHHKa2Q9"},"href":"https://api.spotify.com/v1/artists/38A8T54Gkz9CBdaHHKa2Q9","id":"38A8T54Gkz9CBdaHHKa2Q9","name":"Neil Bridge","type":"artist","uri":"spotify:artist:38A8T54Gkz9CBdaHHKa2Q9"},{"external_urls":{"spotify":"https://open.spotify.com/artist/743KxXuT5BpA8r46U7v4wN"},"href":"https://api.spotify.com/v1/artists/743KxXuT5BpA8r46U7v4wN","id":"743KxXuT5BpA8r46U7v4wN","name":"Dick Patterson","type":"artist","uri":"spotify:artist:743KxXuT5BpA8r46U7v4wN"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4GqxFxjy33dmrSubWLlraK"},"href":"https://api.spotify.com/v1/artists/4GqxFxjy33dmrSubWLlraK","id":"4GqxFxjy33dmrSubWLlraK","name":"Derryl Goes","type":"artist","uri":"spotify:artist:4GqxFxjy33dmrSubWLlraK"}],"disc_number":1,"duration_ms":244218,"explicit":false,"external_ids":{"isrc":"USHM82497647"},"external_urls":{"spotify":"https://open.spotify.com/track/7M72Nc68IQlj0Q20HQf6J5"},"href":"https://api.spotify.com/v1/tracks/7M72Nc68IQlj0Q20HQf6J5","id":"7M72Nc68IQlj0Q20HQf6J5","is_local":false,"is_playable":true,"name":"Moonlight in Vermont - Live","track_number":9,"type":"track","uri":"spotify:track:7M72Nc68IQlj0Q20HQf6J5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dqWIuN3IVCmVMUPEWJdbD"},"href":"https://api.spotify.com/v1/artists/3dqWIuN3IVCmVMUPEWJdbD","id":"3dqWIuN3IVCmVMUPEWJdbD","name":"Art Van Damme Quintet","type":"artist","uri":"spotify:artist:3dqWIuN3IVCmVMUPEWJdbD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3uSfj0UcDqCFHkqFOUkOm8"},"href":"https://api.spotify.com/v1/artists/3uSfj0UcDqCFHkqFOUkOm8","id":"3uSfj0UcDqCFHkqFOUkOm8","name":"The String Orchestra Hubert Deuringer","type":"artist","uri":"spotify:artist:3uSfj0UcDqCFHkqFOUkOm8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1BJN2XI6GjcNw9CPL6jIvy"},"href":"https://api.spotify.com/v1/artists/1BJN2XI6GjcNw9CPL6jIvy","id":"1BJN2XI6GjcNw9CPL6jIvy","name":"Willli Lehmann","type":"artist","uri":"spotify:artist:1BJN2XI6GjcNw9CPL6jIvy"}],"external_urls":{"spotify":"https://open.spotify.com/album/7FMCXC5uZx5RAavbKAFgqr"},"href":"https://api.spotify.com/v1/albums/7FMCXC5uZx5RAavbKAFgqr","id":"7FMCXC5uZx5RAavbKAFgqr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a8ed03e3699f83ecbfb84570"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a8ed03e3699f83ecbfb84570"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a8ed03e3699f83ecbfb84570"}],"is_playable":true,"name":"Art Van Damme with Strings","release_date":"2015-06-05","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:7FMCXC5uZx5RAavbKAFgqr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dqWIuN3IVCmVMUPEWJdbD"},"href":"https://api.spotify.com/v1/artists/3dqWIuN3IVCmVMUPEWJdbD","id":"3dqWIuN3IVCmVMUPEWJdbD","name":"Art Van Damme Quintet","type":"artist","uri":"spotify:artist:3dqWIuN3IVCmVMUPEWJdbD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3uSfj0UcDqCFHkqFOUkOm8"},"href":"https://api.spotify.com/v1/artists/3uSfj0UcDqCFHkqFOUkOm8","id":"3uSfj0UcDqCFHkqFOUkOm8","name":"The String Orchestra Hubert Deuringer","type":"artist","uri":"spotify:artist:3uSfj0UcDqCFHkqFOUkOm8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1BJN2XI6GjcNw9CPL6jIvy"},"href":"https://api.spotify.com/v1/artists/1BJN2XI6GjcNw9CPL6jIvy","id":"1BJN2XI6GjcNw9CPL6jIvy","name":"Willli Lehmann","type":"artist","uri":"spotify:artist:1BJN2XI6GjcNw9CPL6jIvy"}],"disc_number":1,"duration_ms":239291,"explicit":false,"external_ids":{"isrc":"DEPI81401419"},"external_urls":{"spotify":"https://open.spotify.com/track/7pYd0FAdMbzGaGrEsscXPa"},"href":"https://api.spotify.com/v1/tracks/7pYd0FAdMbzGaGrEsscXPa","id":"7pYd0FAdMbzGaGrEsscXPa","is_local":false,"is_playable":true,"name":"Moonlight in Vermont","track_number":10,"type":"track","uri":"spotify:track:7pYd0FAdMbzGaGrEsscXPa"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"external_urls":{"spotify":"https://open.spotify.com/album/4olYtti4j5EjMPGrUv0EFL"},"href":"https://api.spotify.com/v1/albums/4olYtti4j5EjMPGrUv0EFL","id":"4olYtti4j5EjMPGrUv0EFL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273223cdb36a2b6723ac80b3425"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02223cdb36a2b6723ac80b3425"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851223cdb36a2b6723ac80b3425"}],"is_playable":true,"name":"Whispering Strings","release_date":"2007-07-07","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:4olYtti4j5EjMPGrUv0EFL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"disc_number":1,"duration_ms":194460,"explicit":false,"external_ids":{"isrc":"GBN8H2429762"},"external_urls":{"spotify":"https://open.spotify.com/track/7E1vPKwJZTThRtAMTVStr2"},"href":"https://api.spotify.com/v1/tracks/7E1vPKwJZTThRtAMTVStr2","id":"7E1vPKwJZTThRtAMTVStr2","is_local":false,"is_playable":true,"name":"Moonlight in Vermont","track_number":8,"type":"track","uri":"spotify:track:7E1vPKwJZTThRtAMTVStr2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"external_urls":{"spotify":"https://open.spotify.com/album/2tkWpA7MrIuQfUxdoSYkEB"},"href":"https://api.spotify.com/v1/albums/2tkWpA7MrIuQfUxdoSYkEB","id":"2tkWpA7MrIuQfUxdoSYkEB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bc7c4782d345413f50443eaa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bc7c4782d345413f50443eaa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bc7c4782d345413f50443eaa"}],"is_playable":true,"name":"Strings in the Breeze","release_date":"2007-07-07","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:2tkWpA7MrIuQfUxdoSYkEB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u7Tz2oLTRPG9Cn7PcuZ2q"},"href":"https://api.spotify.com/v1/artists/3u7Tz2oLTRPG9Cn7PcuZ2q","id":"3u7Tz2oLTRPG9Cn7PcuZ2q","name":"Johnny Smith","type":"artist","uri":"spotify:artist:3u7Tz2oLTRPG9Cn7PcuZ2q"}],"disc_number":1,"duration_ms":194052,"explicit":false,"external_ids":{"isrc":"GBN8H2429833"},"external_urls":{"spotify":"https://open.spotify.com/track/6sx28huTQOMpDSu4txPBcd"},"href":"https://api.spotify.com/v1/tracks/6sx28huTQOMpDSu4txPBcd","id":"6sx28huTQOMpDSu4txPBcd","is_local":false,"is_playable":true,"name":"Moonlight in Vermont","track_number":13,"type":"track","uri":"spotify:track:6sx28huTQOMpDSu4txPBcd"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1vb25saWdodCUyMGluJTIwVmVybW9udCUyMiUyMGFydGlzdCUzQSUyMkpvaG5ueSUyMFNtaXRoJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9zZWFyY2g/b2Zmc2V0PTEwJmxpbWl0PTEwJnF1ZXJ5PXRyYWNrJTNBJTIyTW9vbmxpZ2h0JTIwaW4lMjBWZXJtb250JTIyJTIwYXJ0aXN0JTNBJTIySm9obm55JTIwU21pdGglMjImdHlwZT10cmFjayIsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoxNywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk4zRG9UamFWdm1SWkl4NkFJa092NSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTjNEb1RqYVZ2bVJaSXg2QUlrT3Y1IiwiaWQiOiIyTjNEb1RqYVZ2bVJaSXg2QUlrT3Y1IiwibmFtZSI6IlN0YW4gR2V0eiBRdWludGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJOM0RvVGphVnZtUlpJeDZBSWtPdjUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3U3VHoyb0xUUlBHOUNuN1BjdVoycSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zdTdUejJvTFRSUEc5Q243UGN1WjJxIiwiaWQiOiIzdTdUejJvTFRSUEc5Q243UGN1WjJxIiwibmFtZSI6IkpvaG5ueSBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdTdUejJvTFRSUEc5Q243UGN1WjJxIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMm5EMlhtZEFhb2dKSGJXbFJFSXUzTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJuRDJYbWRBYW9nSkhiV2xSRUl1M08iLCJpZCI6IjJuRDJYbWRBYW9nSkhiV2xSRUl1M08iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmRhZTEyMmE2MjBiNmExYjgwNjg3MTJmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZkYWUxMjJhNjIwYjZhMWI4MDY4NzEyZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOg==", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2ZGFlMTIyYTYyMGI2YTFiODA2ODcxMmYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9vbmxpZ2h0IE9uIFZlcm1vbnQgLSBUaGUgUm9vc3QgUmVjb3JkaW5ncyIsInJlbGVhc2VfZGF0ZSI6IjIwMTAtMDEtMDgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToybkQyWG1kQWFvZ0pIYldsUkVJdTNPIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3U3VHoyb0xUUlBHOUNuN1BjdVoycSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zdTdUejJvTFRSUEc5Q243UGN1WjJxIiwiaWQiOiIzdTdUejJvTFRSUEc5Q243UGN1WjJxIiwibmFtZSI6IkpvaG5ueSBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdTdUejJvTFRSUEc5Q243UGN1WjJxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NTc0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzYyMDQxOTc1NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0dpaks2eTdGUTJwNVlNRWdOODVSSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNHaWpLNnk3RlEycDVZTUVnTjg1UkgiLCJpZCI6IjNHaWpLNnk3RlEycDVZTUVnTjg1UkgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9vbmxpZ2h0IEluIFZlcm1vbnQiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0dpaks2eTdGUTJwNVlNRWdOODVSSCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdTdUejJvTFRSUEc5Q243UGN1WjJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJpZCI6IjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJuYW1lIjoiSm9obm55IFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80Nm0ydlZHSm4wY1NhVkJzSE16WWdXIn0sImhyZWYiOg==", + "Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80Nm0ydlZHSm4wY1NhVkJzSE16WWdXIiwiaWQiOiI0Nm0ydlZHSm4wY1NhVkJzSE16WWdXIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzU4NGM3ZTNiMDEwNWI5M2RkYTc3NWE1OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1ODRjN2UzYjAxMDViOTNkZGE3NzVhNTgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTU4NGM3ZTNiMDEwNWI5M2RkYTc3NWE1OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb29ubGlnaHQgSW4gVmVybW9udCIsInJlbGVhc2VfZGF0ZSI6IjE5NTYtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0Nm0ydlZHSm4wY1NhVkJzSE16WWdXIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3U3VHoyb0xUUlBHOUNuN1BjdVoycSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zdTdUejJvTFRSUEc5Q243UGN1WjJxIiwiaWQiOiIzdTdUejJvTFRSUEc5Q243UGN1WjJxIiwibmFtZSI6IkpvaG5ueSBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdTdUejJvTFRSUEc5Q243UGN1WjJxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NTY5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQVlFNTIwMDEyMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMThDVVFEcVBRemJ0azA2eHAyVEc3QSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzE4Q1VRRHFQUXpidGswNnhwMlRHN0EiLCJpZCI6IjE4Q1VRRHFQUXpidGswNnhwMlRHN0EiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9vbmxpZ2h0IGluIFZlcm1vbnQiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MThDVVFEcVBRemJ0azA2eHAyVEc3QSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tLw==", + "YXJ0aXN0LzBGTXVjWnNFbkN4czVwcUJqSGpJYzgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEZNdWNac0VuQ3hzNXBxQmpIakljOCIsImlkIjoiMEZNdWNac0VuQ3hzNXBxQmpIakljOCIsIm5hbWUiOiJTdGFuIEdldHoiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEZNdWNac0VuQ3hzNXBxQmpIakljOCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzUyendTalhSUUpvcjlVOFRpODRtNjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81Mnp3U2pYUlFKb3I5VThUaTg0bTY0IiwiaWQiOiI1Mnp3U2pYUlFKb3I5VThUaTg0bTY0IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FiODYzYWU1M2E3MWFmYjVmYmZiODg4ZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhYjg2M2FlNTNhNzFhZmI1ZmJmYjg4OGQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFiODYzYWU1M2E3MWFmYjVmYmZiODg4ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDb21wbGV0ZSBSb29zdCBSZWNvcmRpbmdzIiwicmVsZWFzZV9kYXRlIjoiMTk5Ny0xMS0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjU5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjUyendTalhSUUpvcjlVOFRpODRtNjQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wRk11Y1pzRW5DeHM1cHFCakhqSWM4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBGTXVjWnNFbkN4czVwcUJqSGpJYzgiLCJpZCI6IjBGTXVjWnNFbkN4czVwcUJqSGpJYzgiLCJuYW1lIjoiU3RhbiBHZXR6IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBGTXVjWnNFbkN4czVwcUJqSGpJYzgifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3U3VHoyb0xUUlBHOUNuN1BjdVoycSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zdTdUejJvTFRSUEc5Q243UGN1WjJxIiwiaWQiOiIzdTdUejJvTFRSUEc5Q243UGN1WjJxIiwibmFtZSI6IkpvaG5ueSBTbWl0aCIsInR5cA==", + "ZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEifV0sImRpc2NfbnVtYmVyIjozLCJkdXJhdGlvbl9tcyI6MTk1NzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBWUU1MjAwMDA5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xU1Q5MWZEajQwR0toNGRJcmMyMENQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVNUOTFmRGo0MEdLaDRkSXJjMjBDUCIsImlkIjoiMVNUOTFmRGo0MEdLaDRkSXJjMjBDUCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb29ubGlnaHQgaW4gVmVybW9udCIsInRyYWNrX251bWJlciI6MTQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MVNUOTFmRGo0MEdLaDRkSXJjMjBDUCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdTdUejJvTFRSUEc5Q243UGN1WjJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJpZCI6IjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJuYW1lIjoiSm9obm55IFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83cVJSVzhWSHpMVGY3UjY1ZVBDN09RIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3FSUlc4Vkh6TFRmN1I2NWVQQzdPUSIsImlkIjoiN3FSUlc4Vkh6TFRmN1I2NWVQQzdPUSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwNDdmNDc2NGJmMDcyN2NhM2NkZTY0ZGUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDQ3ZjQ3NjRiZjA3MjdjYTNjZGU2NGRlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwNDdmNDc2NGJmMDcyN2NhM2NkZTY0ZGUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9vbmxpZ2h0IEluIFZlcm1vbnQiLCJyZWxlYXNlX2RhdGUiOiIxOTU2LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbg==", + "IjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3cVJSVzhWSHpMVGY3UjY1ZVBDN09RIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3U3VHoyb0xUUlBHOUNuN1BjdVoycSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zdTdUejJvTFRSUEc5Q243UGN1WjJxIiwiaWQiOiIzdTdUejJvTFRSUEc5Q243UGN1WjJxIiwibmFtZSI6IkpvaG5ueSBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdTdUejJvTFRSUEc5Q243UGN1WjJxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NTY5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQVlFNTIwMDEyMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM1VHdDdoTVhraWRpWWdWMlhXMktGSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNVR3Q3aE1Ya2lkaVlnVjJYVzJLRksiLCJpZCI6IjNVR3Q3aE1Ya2lkaVlnVjJYVzJLRksiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9vbmxpZ2h0IGluIFZlcm1vbnQiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M1VHdDdoTVhraWRpWWdWMlhXMktGSyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdTdUejJvTFRSUEc5Q243UGN1WjJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJpZCI6IjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJuYW1lIjoiSm9obm55IFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82MXd3clMxdEROenZDQkJYMWdISmk3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjF3d3JTMXRETnp2Q0JCWDFnSEppNyIsImlkIjoiNjF3d3JTMXRETnp2Q0JCWDFnSEppNyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4M2FhMDdiMThlNjZlZTY5YjU3OQ==", + "YThlNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4M2FhMDdiMThlNjZlZTY5YjU3OWE4ZTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTgzYWEwN2IxOGU2NmVlNjliNTc5YThlNCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTcHJpbmcgSXMgSGVyZSAtIFRoZSBHdWl0YXIgR2VuaXVzIE9mIiwicmVsZWFzZV9kYXRlIjoiMTk1Mi0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjYxd3dyUzF0RE56dkNCQlgxZ0hKaTcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdTdUejJvTFRSUEc5Q243UGN1WjJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJpZCI6IjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJuYW1lIjoiSm9obm55IFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk2OTQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JCTFkwNjAyNTU2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zNW8xRHhkdlZqSFVLUFJOVlJNU3hRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzVvMUR4ZHZWakhVS1BSTlZSTVN4USIsImlkIjoiMzVvMUR4ZHZWakhVS1BSTlZSTVN4USIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb29ubGlnaHQgSW4gVmVybW9udCIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozNW8xRHhkdlZqSFVLUFJOVlJNU3hRIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBGTXVjWnNFbkN4czVwcUJqSGpJYzgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEZNdWNac0VuQ3hzNXBxQmpIakljOCIsImlkIjoiMEZNdWNac0VuQ3hzNXBxQmpIakljOCIsIm5hbWUiOiJTdGFuIEdldHoiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIg==", + "OiJzcG90aWZ5OmFydGlzdDowRk11Y1pzRW5DeHM1cHFCakhqSWM4In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkRzaDR5RWlTYXdHaUU3Slo1eXZNMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZEc2g0eUVpU2F3R2lFN0paNXl2TTMiLCJpZCI6IjZEc2g0eUVpU2F3R2lFN0paNXl2TTMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTEwZGExZjg2NWIwYTIyZWExMTQ5NzNlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUxMGRhMWY4NjViMGEyMmVhMTE0OTczZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTEwZGExZjg2NWIwYTIyZWExMTQ5NzNlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik11c2ljIExlZ2VuZHMgU3RhbiBHZXR6OiBUaGUgSmF6eiBNYXN0ZXIiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA1LTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkRzaDR5RWlTYXdHaUU3Slo1eXZNMyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBGTXVjWnNFbkN4czVwcUJqSGpJYzgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEZNdWNac0VuQ3hzNXBxQmpIakljOCIsImlkIjoiMEZNdWNac0VuQ3hzNXBxQmpIakljOCIsIm5hbWUiOiJTdGFuIEdldHoiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEZNdWNac0VuQ3hzNXBxQmpIakljOCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdTdUejJvTFRSUEc5Q243UGN1WjJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJpZCI6IjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJuYW1lIjoiSm9obm55IFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQzODAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiRlI2RjMyNjYwOTIwIn0sIg==", + "ZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZHYzk0ZXJaMUhpN0NDNzlTTURIekoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82R2M5NGVyWjFIaTdDQzc5U01ESHpKIiwiaWQiOiI2R2M5NGVyWjFIaTdDQzc5U01ESHpKIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1vb25saWdodCBpbiBWZXJtb250IiwidHJhY2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZHYzk0ZXJaMUhpN0NDNzlTTURIekoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3U3VHoyb0xUUlBHOUNuN1BjdVoycSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zdTdUejJvTFRSUEc5Q243UGN1WjJxIiwiaWQiOiIzdTdUejJvTFRSUEc5Q243UGN1WjJxIiwibmFtZSI6IkpvaG5ueSBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdTdUejJvTFRSUEc5Q243UGN1WjJxIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlQwb1ZSZ1ozOXdrRnFrM0s2VnV4SyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJUMG9WUmdaMzl3a0ZxazNLNlZ1eEsiLCJpZCI6IjJUMG9WUmdaMzl3a0ZxazNLNlZ1eEsiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTUwZmM0MTFmMWIwMzkwMzQzMzc1YjM5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjU1MGZjNDExZjFiMDM5MDM0MzM3NWIzOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTUwZmM0MTFmMWIwMzkwMzQzMzc1YjM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBMYXN0IE5pZ2h0IGF0IFNoYW5lcidzIChMaXZlKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDctMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyVDBvVlJnWjM5d2tGcWszSzZWdXhLIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcA==", + "b3RpZnkuY29tL2FydGlzdC8zdTdUejJvTFRSUEc5Q243UGN1WjJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJpZCI6IjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJuYW1lIjoiSm9obm55IFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzhBOFQ1NEdrejlDQmRhSEhLYTJROSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zOEE4VDU0R2t6OUNCZGFISEthMlE5IiwiaWQiOiIzOEE4VDU0R2t6OUNCZGFISEthMlE5IiwibmFtZSI6Ik5laWwgQnJpZGdlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjM4QThUNTRHa3o5Q0JkYUhIS2EyUTkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzQzS3hYdVQ1QnBBOHI0NlU3djR3TiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83NDNLeFh1VDVCcEE4cjQ2VTd2NHdOIiwiaWQiOiI3NDNLeFh1VDVCcEE4cjQ2VTd2NHdOIiwibmFtZSI6IkRpY2sgUGF0dGVyc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc0M0t4WHVUNUJwQThyNDZVN3Y0d04ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEdxeEZ4ankzM2RtclN1YldMbHJhSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80R3F4RnhqeTMzZG1yU3ViV0xscmFLIiwiaWQiOiI0R3F4RnhqeTMzZG1yU3ViV0xscmFLIiwibmFtZSI6IkRlcnJ5bCBHb2VzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRHcXhGeGp5MzNkbXJTdWJXTGxyYUsifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ0MjE4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNITTgyNDk3NjQ3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83TTcyTmM2OElRbGowUTIwSFFmNko1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN003Mk5jNjhJUWxqMFEyMEhRZjZKNSIsImlkIjoiN003Mk5jNjhJUWxqMFEyMEhRZjZKNSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb29ubGlnaHQgaW4gVmVybW9udCAtIExpdmUiLCJ0cg==", + "YWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3TTcyTmM2OElRbGowUTIwSFFmNko1In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNkcVdJdU4zSVZDbVZNVVBFV0pkYkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RxV0l1TjNJVkNtVk1VUEVXSmRiRCIsImlkIjoiM2RxV0l1TjNJVkNtVk1VUEVXSmRiRCIsIm5hbWUiOiJBcnQgVmFuIERhbW1lIFF1aW50ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2RxV0l1TjNJVkNtVk1VUEVXSmRiRCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdVNmajBVY0RxQ0ZIa3FGT1VrT204In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1U2ZqMFVjRHFDRkhrcUZPVWtPbTgiLCJpZCI6IjN1U2ZqMFVjRHFDRkhrcUZPVWtPbTgiLCJuYW1lIjoiVGhlIFN0cmluZyBPcmNoZXN0cmEgSHViZXJ0IERldXJpbmdlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdVNmajBVY0RxQ0ZIa3FGT1VrT204In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFCSk4yWEk2R2pjTnc5Q1BMNmpJdnkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUJKTjJYSTZHamNOdzlDUEw2akl2eSIsImlkIjoiMUJKTjJYSTZHamNOdzlDUEw2akl2eSIsIm5hbWUiOiJXaWxsbGkgTGVobWFubiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxQkpOMlhJNkdqY053OUNQTDZqSXZ5In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN0ZNQ1hDNXVaeDVSQWF2YktBRmdxciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdGTUNYQzV1Wng1UkFhdmJLQUZncXIiLCJpZCI6IjdGTUNYQzV1Wng1UkFhdmJLQUZncXIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYThlZDAzZTM2OTlmODNlY2JmYjg0NTcwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmE4ZWQwM2UzNjk5ZjgzZWNiZmI4NDU3MCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOg==", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhOGVkMDNlMzY5OWY4M2VjYmZiODQ1NzAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQXJ0IFZhbiBEYW1tZSB3aXRoIFN0cmluZ3MiLCJyZWxlYXNlX2RhdGUiOiIyMDE1LTA2LTA1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0ZNQ1hDNXVaeDVSQWF2YktBRmdxciJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNkcVdJdU4zSVZDbVZNVVBFV0pkYkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RxV0l1TjNJVkNtVk1VUEVXSmRiRCIsImlkIjoiM2RxV0l1TjNJVkNtVk1VUEVXSmRiRCIsIm5hbWUiOiJBcnQgVmFuIERhbW1lIFF1aW50ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2RxV0l1TjNJVkNtVk1VUEVXSmRiRCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdVNmajBVY0RxQ0ZIa3FGT1VrT204In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1U2ZqMFVjRHFDRkhrcUZPVWtPbTgiLCJpZCI6IjN1U2ZqMFVjRHFDRkhrcUZPVWtPbTgiLCJuYW1lIjoiVGhlIFN0cmluZyBPcmNoZXN0cmEgSHViZXJ0IERldXJpbmdlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdVNmajBVY0RxQ0ZIa3FGT1VrT204In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFCSk4yWEk2R2pjTnc5Q1BMNmpJdnkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUJKTjJYSTZHamNOdzlDUEw2akl2eSIsImlkIjoiMUJKTjJYSTZHamNOdzlDUEw2akl2eSIsIm5hbWUiOiJXaWxsbGkgTGVobWFubiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxQkpOMlhJNkdqY053OUNQTDZqSXZ5In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzOTI5MSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkRFUEk4MTQwMTQxOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN3BZZDBGQWRNYnpHYUdyRXNzY1hQYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdwWWQwRkFkTWJ6R2FHckVzc2NYUGEiLCJpZCI6IjdwWWQwRkFkTWJ6R2FHcg==", + "RXNzY1hQYSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb29ubGlnaHQgaW4gVmVybW9udCIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N3BZZDBGQWRNYnpHYUdyRXNzY1hQYSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdTdUejJvTFRSUEc5Q243UGN1WjJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJpZCI6IjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJuYW1lIjoiSm9obm55IFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80b2xZdHRpNGo1RWpNUEdyVXYwRUZMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNG9sWXR0aTRqNUVqTVBHclV2MEVGTCIsImlkIjoiNG9sWXR0aTRqNUVqTVBHclV2MEVGTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyMjNjZGIzNmEyYjY3MjNhYzgwYjM0MjUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMjIzY2RiMzZhMmI2NzIzYWM4MGIzNDI1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyMjNjZGIzNmEyYjY3MjNhYzgwYjM0MjUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2hpc3BlcmluZyBTdHJpbmdzIiwicmVsZWFzZV9kYXRlIjoiMjAwNy0wNy0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRvbFl0dGk0ajVFak1QR3JVdjBFRkwifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdTdUejJvTFRSUEc5Q243UGN1WjJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJpZCI6IjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJuYW1lIjoiSm9obm55IFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6Ig==", + "c3BvdGlmeTphcnRpc3Q6M3U3VHoyb0xUUlBHOUNuN1BjdVoycSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTQ0NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQk44SDI0Mjk3NjIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdFMXZQS3dKWlRUaFJ0QU1UVlN0cjIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83RTF2UEt3SlpUVGhSdEFNVFZTdHIyIiwiaWQiOiI3RTF2UEt3SlpUVGhSdEFNVFZTdHIyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1vb25saWdodCBpbiBWZXJtb250IiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdFMXZQS3dKWlRUaFJ0QU1UVlN0cjIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3U3VHoyb0xUUlBHOUNuN1BjdVoycSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zdTdUejJvTFRSUEc5Q243UGN1WjJxIiwiaWQiOiIzdTdUejJvTFRSUEc5Q243UGN1WjJxIiwibmFtZSI6IkpvaG5ueSBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdTdUejJvTFRSUEc5Q243UGN1WjJxIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMnRrV3BBN01ySXVRZlV4ZG9TWWtFQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJ0a1dwQTdNckl1UWZVeGRvU1lrRUIiLCJpZCI6IjJ0a1dwQTdNckl1UWZVeGRvU1lrRUIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYmM3YzQ3ODJkMzQ1NDEzZjUwNDQzZWFhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJjN2M0NzgyZDM0NTQxM2Y1MDQ0M2VhYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYmM3YzQ3ODJkMzQ1NDEzZjUwNDQzZWFhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0cmluZ3MgaW4gdGhlIEJyZWV6ZSIsInJlbGVhc2VfZGF0ZSI6IjIwMDctMDctMDciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhYw==", + "a3MiOjIyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJ0a1dwQTdNckl1UWZVeGRvU1lrRUIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdTdUejJvTFRSUEc5Q243UGN1WjJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJpZCI6IjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEiLCJuYW1lIjoiSm9obm55IFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN1N1R6Mm9MVFJQRzlDbjdQY3VaMnEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk0MDUyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JOOEgyNDI5ODMzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82c3gyOGh1VFFPTXBEU3U0dHhQQmNkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNnN4MjhodVRRT01wRFN1NHR4UEJjZCIsImlkIjoiNnN4MjhodVRRT01wRFN1NHR4UEJjZCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb29ubGlnaHQgaW4gVmVybW9udCIsInRyYWNrX251bWJlciI6MTMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NnN4MjhodVRRT01wRFN1NHR4UEJjZCJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Moonlight+in+Vermont%22+artist%3A%22Johnny+Smith%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Softly%20As%20in%20a%20Morning%20Sunrise%22%20artist%3A%22Sonny%20Rollins%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"external_urls":{"spotify":"https://open.spotify.com/album/2uu6trC0IdVMMeslfF8nCC"},"href":"https://api.spotify.com/v1/albums/2uu6trC0IdVMMeslfF8nCC","id":"2uu6trC0IdVMMeslfF8nCC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eb3ad8502031bc27561e6977"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eb3ad8502031bc27561e6977"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eb3ad8502031bc27561e6977"}],"is_playable":true,"name":"Elegance: The Birth Of The Modern Jazz Quartet","release_date":"1954","release_date_precision":"year","total_tracks":14,"type":"album","uri":"spotify:album:2uu6trC0IdVMMeslfF8nCC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"disc_number":1,"duration_ms":209400,"explicit":false,"external_ids":{"isrc":"USSJ10300732"},"external_urls":{"spotify":"https://open.spotify.com/track/4vWMrM0AwlhRlkAdQtC2zn"},"href":"https://api.spotify.com/v1/tracks/4vWMrM0AwlhRlkAdQtC2zn","id":"4vWMrM0AwlhRlkAdQtC2zn","is_local":false,"is_playable":true,"name":"Softly As In A Morning Sunrise","track_number":1,"type":"track","uri":"spotify:track:4vWMrM0AwlhRlkAdQtC2zn"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"}],"external_urls":{"spotify":"https://open.spotify.com/album/4lZ0JM0RUD4jddNbD63O7b"},"href":"https://api.spotify.com/v1/albums/4lZ0JM0RUD4jddNbD63O7b","id":"4lZ0JM0RUD4jddNbD63O7b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273caee211dd19e1336c45ba1c3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02caee211dd19e1336c45ba1c3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851caee211dd19e1336c45ba1c3"}],"is_playable":true,"name":"A Night At The Village Vanguard (Live)","release_date":"1957","release_date_precision":"year","total_tracks":7,"type":"album","uri":"spotify:album:4lZ0JM0RUD4jddNbD63O7b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"}],"disc_number":1,"duration_ms":399360,"explicit":false,"external_ids":{"isrc":"USBN28600110"},"external_urls":{"spotify":"https://open.spotify.com/track/3ybRszkVXeMWxWAec3NMJH"},"href":"https://api.spotify.com/v1/tracks/3ybRszkVXeMWxWAec3NMJH","id":"3ybRszkVXeMWxWAec3NMJH","is_local":false,"is_playable":true,"name":"Softly As In A Morning Sunrise - Live At The Village Vanguard/1957 - Evening Take","track_number":4,"type":"track","uri":"spotify:track:3ybRszkVXeMWxWAec3NMJH"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"external_urls":{"spotify":"https://open.spotify.com/album/05Xl8SCySp3AD6TeLHlSKW"},"href":"https://api.spotify.com/v1/albums/05Xl8SCySp3AD6TeLHlSKW","id":"05Xl8SCySp3AD6TeLHlSKW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731a4e3848a90ef148983295d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021a4e3848a90ef148983295d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511a4e3848a90ef148983295d7"}],"is_playable":true,"name":"Concorde (RVG Remaster)","release_date":"1955","release_date_precision":"year","total_tracks":6,"type":"album","uri":"spotify:album:05Xl8SCySp3AD6TeLHlSKW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"disc_number":1,"duration_ms":476893,"explicit":false,"external_ids":{"isrc":"USC4R0820044"},"external_urls":{"spotify":"https://open.spotify.com/track/4HjQG92cOaGXrIQOboNOU2"},"href":"https://api.spotify.com/v1/tracks/4HjQG92cOaGXrIQOboNOU2","id":"4HjQG92cOaGXrIQOboNOU2","is_local":false,"is_playable":true,"name":"Softly As In A Morning Sunrise - RVG Remaster 2008","track_number":5,"type":"track","uri":"spotify:track:4HjQG92cOaGXrIQOboNOU2"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"}],"external_urls":{"spotify":"https://open.spotify.com/album/1quvTirsaf1u35HegD1iL3"},"href":"https://api.spotify.com/v1/albums/1quvTirsaf1u35HegD1iL3","id":"1quvTirsaf1u35HegD1iL3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27352f7c285e28b4687bd2bac16"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0252f7c285e28b4687bd2bac16"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485152f7c285e28b4687bd2bac16"}],"is_playable":true,"name":"The Best Of Sonny Rollins","release_date":"1989-01-01","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:1quvTirsaf1u35HegD1iL3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"}],"disc_number":1,"duration_ms":476266,"explicit":false,"external_ids":{"isrc":"USBN28600111"},"external_urls":{"spotify":"https://open.spotify.com/track/3vxEn9WriaaAv5vsDuz7cM"},"href":"https://api.spotify.com/v1/tracks/3vxEn9WriaaAv5vsDuz7cM","id":"3vxEn9WriaaAv5vsDuz7cM","is_local":false,"is_playable":true,"name":"Softly, As In A Morning Sunrise - Live At The Village Vanguard/1957 - Evening Take","track_number":8,"type":"track","uri":"spotify:track:3vxEn9WriaaAv5vsDuz7cM"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"external_urls":{"spotify":"https://open.spotify.com/album/4SQ03iwnOPvzgClDLWS5oZ"},"href":"https://api.spotify.com/v1/albums/4SQ03iwnOPvzgClDLWS5oZ","id":"4SQ03iwnOPvzgClDLWS5oZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dd8e0649c102f608e07bb5e2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dd8e0649c102f608e07bb5e2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dd8e0649c102f608e07bb5e2"}],"is_playable":true,"name":"The Complete Last Concert","release_date":"2005-03-29","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:4SQ03iwnOPvzgClDLWS5oZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"disc_number":1,"duration_ms":386466,"explicit":false,"external_ids":{"isrc":"USAT20105848"},"external_urls":{"spotify":"https://open.spotify.com/track/3UkNjYoO81SVJFNkrkkjgX"},"href":"https://api.spotify.com/v1/tracks/3UkNjYoO81SVJFNkrkkjgX","id":"3UkNjYoO81SVJFNkrkkjgX","is_local":false,"is_playable":true,"name":"Softly as in a Morning Sunrise - Live at Lincoln Center","track_number":1,"type":"track","uri":"spotify:track:3UkNjYoO81SVJFNkrkkjgX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"}],"external_urls":{"spotify":"https://open.spotify.com/album/6PPu8p0UEjVNibyjyO2LMc"},"href":"https://api.spotify.com/v1/albums/6PPu8p0UEjVNibyjyO2LMc","id":"6PPu8p0UEjVNibyjyO2LMc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273af626b7b61f0d9bb046f787b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02af626b7b61f0d9bb046f787b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851af626b7b61f0d9bb046f787b"}],"is_playable":true,"name":"Summer Jazz: Sonny Rollins","release_date":"2026-07-17","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:6PPu8p0UEjVNibyjyO2LMc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"}],"disc_number":1,"duration_ms":351000,"explicit":false,"external_ids":{"isrc":"USBN28600110"},"external_urls":{"spotify":"https://open.spotify.com/track/7JV67BlR6GNB0a1zEckmbX"},"href":"https://api.spotify.com/v1/tracks/7JV67BlR6GNB0a1zEckmbX","id":"7JV67BlR6GNB0a1zEckmbX","is_local":false,"is_playable":true,"name":"Softly As In A Morning Sunrise - Live At The Village Vanguard/1957 - Evening Take","track_number":9,"type":"track","uri":"spotify:track:7JV67BlR6GNB0a1zEckmbX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ZsJnvskaNpZ03ynI0mqlH"},"href":"https://api.spotify.com/v1/albums/4ZsJnvskaNpZ03ynI0mqlH","id":"4ZsJnvskaNpZ03ynI0mqlH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ef03ae25d72bacfa673b688c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ef03ae25d72bacfa673b688c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ef03ae25d72bacfa673b688c"}],"is_playable":true,"name":"A Night At The Village Vanguard (The Complete Masters)","release_date":"1957","release_date_precision":"year","total_tracks":18,"type":"album","uri":"spotify:album:4ZsJnvskaNpZ03ynI0mqlH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VEzN9lxvG6KPR3QQGsebR"},"href":"https://api.spotify.com/v1/artists/1VEzN9lxvG6KPR3QQGsebR","id":"1VEzN9lxvG6KPR3QQGsebR","name":"Sonny Rollins","type":"artist","uri":"spotify:artist:1VEzN9lxvG6KPR3QQGsebR"}],"disc_number":1,"duration_ms":471093,"explicit":false,"external_ids":{"isrc":"USUM72401221"},"external_urls":{"spotify":"https://open.spotify.com/track/6xcIBTUOeeK4IN8a3xctqc"},"href":"https://api.spotify.com/v1/tracks/6xcIBTUOeeK4IN8a3xctqc","id":"6xcIBTUOeeK4IN8a3xctqc","is_local":false,"is_playable":true,"name":"Softly As In A Morning Sunrise - Afternoon Take / Live At The Village Vanguard/1957","track_number":3,"type":"track","uri":"spotify:track:6xcIBTUOeeK4IN8a3xctqc"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"external_urls":{"spotify":"https://open.spotify.com/album/3rNvZsfWGtp7QOuWxjTefQ"},"href":"https://api.spotify.com/v1/albums/3rNvZsfWGtp7QOuWxjTefQ","id":"3rNvZsfWGtp7QOuWxjTefQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b90a596b37d22d8629377a9a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b90a596b37d22d8629377a9a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b90a596b37d22d8629377a9a"}],"is_playable":true,"name":"Jazz en Buenos Aires","release_date":"2026-04-20","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:3rNvZsfWGtp7QOuWxjTefQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"disc_number":1,"duration_ms":415298,"explicit":false,"external_ids":{"isrc":"ARA822600623"},"external_urls":{"spotify":"https://open.spotify.com/track/4T0V16huZZCY9B0IUnkpgT"},"href":"https://api.spotify.com/v1/tracks/4T0V16huZZCY9B0IUnkpgT","id":"4T0V16huZZCY9B0IUnkpgT","is_local":false,"is_playable":true,"name":"Softly, As In A Morning Sunrise","track_number":1,"type":"track","uri":"spotify:track:4T0V16huZZCY9B0IUnkpgT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"external_urls":{"spotify":"https://open.spotify.com/album/43RPkPEqVB0XBdkLBjjavx"},"href":"https://api.spotify.com/v1/albums/43RPkPEqVB0XBdkLBjjavx","id":"43RPkPEqVB0XBdkLBjjavx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27380f6f68640a31ab44458746e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0280f6f68640a31ab44458746e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485180f6f68640a31ab44458746e"}],"is_playable":true,"name":"Concorde","release_date":"1987-01-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:43RPkPEqVB0XBdkLBjjavx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"disc_number":1,"duration_ms":474773,"explicit":false,"external_ids":{"isrc":"USFI85500063"},"external_urls":{"spotify":"https://open.spotify.com/track/16XAI9RVFlEWZXPkmYmJ7f"},"href":"https://api.spotify.com/v1/tracks/16XAI9RVFlEWZXPkmYmJ7f","id":"16XAI9RVFlEWZXPkmYmJ7f","is_local":false,"is_playable":true,"name":"Softly, As In A Morning Sunrise","track_number":5,"type":"track","uri":"spotify:track:16XAI9RVFlEWZXPkmYmJ7f"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"external_urls":{"spotify":"https://open.spotify.com/album/0RYC5cXuyYy0RmgwsFgqdq"},"href":"https://api.spotify.com/v1/albums/0RYC5cXuyYy0RmgwsFgqdq","id":"0RYC5cXuyYy0RmgwsFgqdq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735580a0647931e20ddd950290"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025580a0647931e20ddd950290"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515580a0647931e20ddd950290"}],"is_playable":true,"name":"Beginnings","release_date":"2003-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:0RYC5cXuyYy0RmgwsFgqdq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7wBFjZMHsC6nfV0HOSd6uI"},"href":"https://api.spotify.com/v1/artists/7wBFjZMHsC6nfV0HOSd6uI","id":"7wBFjZMHsC6nfV0HOSd6uI","name":"The Modern Jazz Quartet","type":"artist","uri":"spotify:artist:7wBFjZMHsC6nfV0HOSd6uI"}],"disc_number":1,"duration_ms":209400,"explicit":false,"external_ids":{"isrc":"USSJ10300732"},"external_urls":{"spotify":"https://open.spotify.com/track/3TlbJROJN9NBISWR4Gi9B1"},"href":"https://api.spotify.com/v1/tracks/3TlbJROJN9NBISWR4Gi9B1","id":"3TlbJROJN9NBISWR4Gi9B1","is_local":false,"is_playable":true,"name":"Softly As In A Morning Sunrise","track_number":1,"type":"track","uri":"spotify:track:3TlbJROJN9NBISWR4Gi9B1"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNvZnRseSUyMEFzJTIwaW4lMjBhJTIwTW9ybmluZyUyMFN1bnJpc2UlMjIlMjBhcnRpc3QlM0ElMjJTb25ueSUyMFJvbGxpbnMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSIsImlkIjoiN3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSIsIm5hbWUiOiJUaGUgTW9kZXJuIEphenogUXVhcnRldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3d0JGalpNSHNDNm5mVjBIT1NkNnVJIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMnV1NnRyQzBJZFZNTWVzbGZGOG5DQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJ1dTZ0ckMwSWRWTU1lc2xmRjhuQ0MiLCJpZCI6IjJ1dTZ0ckMwSWRWTU1lc2xmRjhuQ0MiLCJpbWFnZXMiOlt7ImhlaWdo", + "dCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZWIzYWQ4NTAyMDMxYmMyNzU2MWU2OTc3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmViM2FkODUwMjAzMWJjMjc1NjFlNjk3NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZWIzYWQ4NTAyMDMxYmMyNzU2MWU2OTc3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVsZWdhbmNlOiBUaGUgQmlydGggT2YgVGhlIE1vZGVybiBKYXp6IFF1YXJ0ZXQiLCJyZWxlYXNlX2RhdGUiOiIxOTU0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJ1dTZ0ckMwSWRWTU1lc2xmRjhuQ0MifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83d0JGalpNSHNDNm5mVjBIT1NkNnVJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJpZCI6Ijd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJuYW1lIjoiVGhlIE1vZGVybiBKYXp6IFF1YXJ0ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDk0MDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NKMTAzMDA3MzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzR2V01yTTBBd2xoUmxrQWRRdEMyem4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80dldNck0wQXdsaFJsa0FkUXRDMnpuIiwiaWQiOiI0dldNck0wQXdsaFJsa0FkUXRDMnpuIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvZnRseSBBcyBJbiBBIE1vcm5pbmcgU3VucmlzZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0dldNck0wQXdsaFJsa0FkUXRDMnpuIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tLw==", + "djEvYXJ0aXN0cy8xVkV6TjlseHZHNktQUjNRUUdzZWJSIiwiaWQiOiIxVkV6TjlseHZHNktQUjNRUUdzZWJSIiwibmFtZSI6IlNvbm55IFJvbGxpbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVZFek45bHh2RzZLUFIzUVFHc2ViUiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRsWjBKTTBSVUQ0amRkTmJENjNPN2IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80bFowSk0wUlVENGpkZE5iRDYzTzdiIiwiaWQiOiI0bFowSk0wUlVENGpkZE5iRDYzTzdiIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2NhZWUyMTFkZDE5ZTEzMzZjNDViYTFjMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjYWVlMjExZGQxOWUxMzM2YzQ1YmExYzMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWNhZWUyMTFkZDE5ZTEzMzZjNDViYTFjMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBIE5pZ2h0IEF0IFRoZSBWaWxsYWdlIFZhbmd1YXJkIChMaXZlKSIsInJlbGVhc2VfZGF0ZSI6IjE5NTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0bFowSk0wUlVENGpkZE5iRDYzTzdiIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVZFek45bHh2RzZLUFIzUVFHc2ViUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xVkV6TjlseHZHNktQUjNRUUdzZWJSIiwiaWQiOiIxVkV6TjlseHZHNktQUjNRUUdzZWJSIiwibmFtZSI6IlNvbm55IFJvbGxpbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVZFek45bHh2RzZLUFIzUVFHc2ViUiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozOTkzNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0JOMjg2MDAxMTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzN5YlJzemtWWGVNV3hXQWVjM05NSkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zeWJSc3prVlhlTVd4V0FlYzNOTUpIIiwiaWQiOiIzeWJSc3prVg==", + "WGVNV3hXQWVjM05NSkgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU29mdGx5IEFzIEluIEEgTW9ybmluZyBTdW5yaXNlIC0gTGl2ZSBBdCBUaGUgVmlsbGFnZSBWYW5ndWFyZC8xOTU3IC0gRXZlbmluZyBUYWtlIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjN5YlJzemtWWGVNV3hXQWVjM05NSkgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83d0JGalpNSHNDNm5mVjBIT1NkNnVJIiwiaWQiOiI3d0JGalpNSHNDNm5mVjBIT1NkNnVJIiwibmFtZSI6IlRoZSBNb2Rlcm4gSmF6eiBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wNVhsOFNDeVNwM0FENlRlTEhsU0tXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDVYbDhTQ3lTcDNBRDZUZUxIbFNLVyIsImlkIjoiMDVYbDhTQ3lTcDNBRDZUZUxIbFNLVyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYTRlMzg0OGE5MGVmMTQ4OTgzMjk1ZDcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWE0ZTM4NDhhOTBlZjE0ODk4MzI5NWQ3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYTRlMzg0OGE5MGVmMTQ4OTgzMjk1ZDcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29uY29yZGUgKFJWRyBSZW1hc3RlcikiLCJyZWxlYXNlX2RhdGUiOiIxOTU1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MDVYbDhTQ3lTcDNBRDZUZUxIbFNLVyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3dCRmpaTUhzQzZuZlYwSE9TZDZ1SQ==", + "IiwiaWQiOiI3d0JGalpNSHNDNm5mVjBIT1NkNnVJIiwibmFtZSI6IlRoZSBNb2Rlcm4gSmF6eiBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDc2ODkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNDNFIwODIwMDQ0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80SGpRRzkyY09hR1hySVFPYm9OT1UyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNEhqUUc5MmNPYUdYcklRT2JvTk9VMiIsImlkIjoiNEhqUUc5MmNPYUdYcklRT2JvTk9VMiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb2Z0bHkgQXMgSW4gQSBNb3JuaW5nIFN1bnJpc2UgLSBSVkcgUmVtYXN0ZXIgMjAwOCIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0SGpRRzkyY09hR1hySVFPYm9OT1UyIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsImlkIjoiMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsIm5hbWUiOiJTb25ueSBSb2xsaW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xcXV2VGlyc2FmMXUzNUhlZ0QxaUwzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMXF1dlRpcnNhZjF1MzVIZWdEMWlMMyIsImlkIjoiMXF1dlRpcnNhZjF1MzVIZWdEMWlMMyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1MmY3YzI4NWUyOGI0Njg3YmQyYmFjMTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTJmN2MyODVlMjhiNDY4N2JkMmJhYzE2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1MmY3YzI4NWUyOGI0Njg3YmQyYmFjMQ==", + "NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgQmVzdCBPZiBTb25ueSBSb2xsaW5zIiwicmVsZWFzZV9kYXRlIjoiMTk4OS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXF1dlRpcnNhZjF1MzVIZWdEMWlMMyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsImlkIjoiMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsIm5hbWUiOiJTb25ueSBSb2xsaW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDc2MjY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNCTjI4NjAwMTExIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zdnhFbjlXcmlhYUF2NXZzRHV6N2NNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM3Z4RW45V3JpYWFBdjV2c0R1ejdjTSIsImlkIjoiM3Z4RW45V3JpYWFBdjV2c0R1ejdjTSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb2Z0bHksIEFzIEluIEEgTW9ybmluZyBTdW5yaXNlIC0gTGl2ZSBBdCBUaGUgVmlsbGFnZSBWYW5ndWFyZC8xOTU3IC0gRXZlbmluZyBUYWtlIiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjN2eEVuOVdyaWFhQXY1dnNEdXo3Y00ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83d0JGalpNSHNDNm5mVjBIT1NkNnVJIiwiaWQiOiI3d0JGalpNSHNDNm5mVjBIT1NkNnVJIiwibmFtZSI6IlRoZSBNb2Rlcm4gSmF6eiBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80U1EwM2l3bk9QdnpnQ2xETFdTNW9aIn0sImhyZWYiOiJodHRwczovLw==", + "YXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80U1EwM2l3bk9QdnpnQ2xETFdTNW9aIiwiaWQiOiI0U1EwM2l3bk9QdnpnQ2xETFdTNW9aIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2RkOGUwNjQ5YzEwMmY2MDhlMDdiYjVlMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkZDhlMDY0OWMxMDJmNjA4ZTA3YmI1ZTIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWRkOGUwNjQ5YzEwMmY2MDhlMDdiYjVlMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgQ29tcGxldGUgTGFzdCBDb25jZXJ0IiwicmVsZWFzZV9kYXRlIjoiMjAwNS0wMy0yOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRTUTAzaXduT1B2emdDbERMV1M1b1oifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83d0JGalpNSHNDNm5mVjBIT1NkNnVJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJpZCI6Ijd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJuYW1lIjoiVGhlIE1vZGVybiBKYXp6IFF1YXJ0ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozODY0NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FUMjAxMDU4NDgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNVa05qWW9PODFTVkpGTmtya2tqZ1gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zVWtOallvTzgxU1ZKRk5rcmtramdYIiwiaWQiOiIzVWtOallvTzgxU1ZKRk5rcmtramdYIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvZnRseSBhcyBpbiBhIE1vcm5pbmcgU3VucmlzZSAtIExpdmUgYXQgTGluY29sbiBDZW50ZXIiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M1VrTmpZb084MVNWSkZOa3Jra2pnWCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdQ==", + "cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsImlkIjoiMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsIm5hbWUiOiJTb25ueSBSb2xsaW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82UFB1OHAwVUVqVk5pYnlqeU8yTE1jIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNlBQdThwMFVFalZOaWJ5anlPMkxNYyIsImlkIjoiNlBQdThwMFVFalZOaWJ5anlPMkxNYyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhZjYyNmI3YjYxZjBkOWJiMDQ2Zjc4N2IifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWY2MjZiN2I2MWYwZDliYjA0NmY3ODdiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhZjYyNmI3YjYxZjBkOWJiMDQ2Zjc4N2IifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VtbWVyIEpheno6IFNvbm55IFJvbGxpbnMiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA3LTE3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlBQdThwMFVFalZOaWJ5anlPMkxNYyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsImlkIjoiMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsIm5hbWUiOiJTb25ueSBSb2xsaW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzUxMDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNCTjI4NjAwMTEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83SlY2Nw==", + "QmxSNkdOQjBhMXpFY2ttYlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83SlY2N0JsUjZHTkIwYTF6RWNrbWJYIiwiaWQiOiI3SlY2N0JsUjZHTkIwYTF6RWNrbWJYIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvZnRseSBBcyBJbiBBIE1vcm5pbmcgU3VucmlzZSAtIExpdmUgQXQgVGhlIFZpbGxhZ2UgVmFuZ3VhcmQvMTk1NyAtIEV2ZW5pbmcgVGFrZSIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3SlY2N0JsUjZHTkIwYTF6RWNrbWJYIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsImlkIjoiMVZFek45bHh2RzZLUFIzUVFHc2ViUiIsIm5hbWUiOiJTb25ueSBSb2xsaW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFWRXpOOWx4dkc2S1BSM1FRR3NlYlIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80WnNKbnZza2FOcFowM3luSTBtcWxIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNFpzSm52c2thTnBaMDN5bkkwbXFsSCIsImlkIjoiNFpzSm52c2thTnBaMDN5bkkwbXFsSCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlZjAzYWUyNWQ3MmJhY2ZhNjczYjY4OGMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZWYwM2FlMjVkNzJiYWNmYTY3M2I2ODhjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlZjAzYWUyNWQ3MmJhY2ZhNjczYjY4OGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQSBOaWdodCBBdCBUaGUgVmlsbGFnZSBWYW5ndWFyZCAoVGhlIENvbXBsZXRlIE1hc3RlcnMpIiwicmVsZWFzZV9kYXRlIjoiMTk1NyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0WnNKbnZza2FOcFowM3luSTBtcWxIIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Ig==", + "aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xVkV6TjlseHZHNktQUjNRUUdzZWJSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFWRXpOOWx4dkc2S1BSM1FRR3NlYlIiLCJpZCI6IjFWRXpOOWx4dkc2S1BSM1FRR3NlYlIiLCJuYW1lIjoiU29ubnkgUm9sbGlucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxVkV6TjlseHZHNktQUjNRUUdzZWJSIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQ3MTA5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MjQwMTIyMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnhjSUJUVU9lZUs0SU44YTN4Y3RxYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ4Y0lCVFVPZWVLNElOOGEzeGN0cWMiLCJpZCI6IjZ4Y0lCVFVPZWVLNElOOGEzeGN0cWMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU29mdGx5IEFzIEluIEEgTW9ybmluZyBTdW5yaXNlIC0gQWZ0ZXJub29uIFRha2UgLyBMaXZlIEF0IFRoZSBWaWxsYWdlIFZhbmd1YXJkLzE5NTciLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NnhjSUJUVU9lZUs0SU44YTN4Y3RxYyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83d0JGalpNSHNDNm5mVjBIT1NkNnVJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJpZCI6Ijd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJuYW1lIjoiVGhlIE1vZGVybiBKYXp6IFF1YXJ0ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNyTnZac2ZXR3RwN1FPdVd4alRlZlEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zck52WnNmV0d0cDdRT3VXeGpUZWZRIiwiaWQiOiIzck52WnNmV0d0cDdRT3VXeGpUZWZRIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I5MGE1OTZiMzdkMjJkODYyOTM3N2E5YSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zYw==", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmI5MGE1OTZiMzdkMjJkODYyOTM3N2E5YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjkwYTU5NmIzN2QyMmQ4NjI5Mzc3YTlhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkphenogZW4gQnVlbm9zIEFpcmVzIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNC0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNyTnZac2ZXR3RwN1FPdVd4alRlZlEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83d0JGalpNSHNDNm5mVjBIT1NkNnVJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJpZCI6Ijd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJuYW1lIjoiVGhlIE1vZGVybiBKYXp6IFF1YXJ0ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MTUyOTgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJBUkE4MjI2MDA2MjMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRUMFYxNmh1WlpDWTlCMElVbmtwZ1QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80VDBWMTZodVpaQ1k5QjBJVW5rcGdUIiwiaWQiOiI0VDBWMTZodVpaQ1k5QjBJVW5rcGdUIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvZnRseSwgQXMgSW4gQSBNb3JuaW5nIFN1bnJpc2UiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFQwVjE2aHVaWkNZOUIwSVVua3BnVCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83d0JGalpNSHNDNm5mVjBIT1NkNnVJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJpZCI6Ijd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkiLCJuYW1lIjoiVGhlIE1vZGVybiBKYXp6IFF1YXJ0ZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3dCRmpaTUhzQzZuZlYwSE9TZDZ1SQ==", + "In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNDNSUGtQRXFWQjBYQmRrTEJqamF2eCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzQzUlBrUEVxVkIwWEJka0xCamphdngiLCJpZCI6IjQzUlBrUEVxVkIwWEJka0xCamphdngiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODBmNmY2ODY0MGEzMWFiNDQ0NTg3NDZlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjgwZjZmNjg2NDBhMzFhYjQ0NDU4NzQ2ZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODBmNmY2ODY0MGEzMWFiNDQ0NTg3NDZlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbmNvcmRlIiwicmVsZWFzZV9kYXRlIjoiMTk4Ny0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NDNSUGtQRXFWQjBYQmRrTEJqamF2eCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSIsImlkIjoiN3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSIsIm5hbWUiOiJUaGUgTW9kZXJuIEphenogUXVhcnRldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3d0JGalpNSHNDNm5mVjBIT1NkNnVJIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQ3NDc3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRkk4NTUwMDA2MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMTZYQUk5UlZGbEVXWlhQa21ZbUo3ZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzE2WEFJOVJWRmxFV1pYUGttWW1KN2YiLCJpZCI6IjE2WEFJOVJWRmxFV1pYUGttWW1KN2YiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU29mdGx5LCBBcyBJbiBBIE1vcm5pbmcgU3VucmlzZSIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxNlhBSTlSVkZsRVdaWFBrbQ==", + "WW1KN2YifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83d0JGalpNSHNDNm5mVjBIT1NkNnVJIiwiaWQiOiI3d0JGalpNSHNDNm5mVjBIT1NkNnVJIiwibmFtZSI6IlRoZSBNb2Rlcm4gSmF6eiBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wUllDNWNYdXlZeTBSbWd3c0ZncWRxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMFJZQzVjWHV5WXkwUm1nd3NGZ3FkcSIsImlkIjoiMFJZQzVjWHV5WXkwUm1nd3NGZ3FkcSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1NTgwYTA2NDc5MzFlMjBkZGQ5NTAyOTAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTU4MGEwNjQ3OTMxZTIwZGRkOTUwMjkwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1NTgwYTA2NDc5MzFlMjBkZGQ5NTAyOTAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmVnaW5uaW5ncyIsInJlbGVhc2VfZGF0ZSI6IjIwMDMtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowUllDNWNYdXlZeTBSbWd3c0ZncWRxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3dCRmpaTUhzQzZuZlYwSE9TZDZ1SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83d0JGalpNSHNDNm5mVjBIT1NkNnVJIiwiaWQiOiI3d0JGalpNSHNDNm5mVjBIT1NkNnVJIiwibmFtZSI6IlRoZSBNb2Rlcm4gSmF6eiBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd3QkZqWk1Ic0M2bmZWMEhPU2Q2dUkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA5NDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTSjEwMzAwNzMyIg==", + "fSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNUbGJKUk9KTjlOQklTV1I0R2k5QjEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zVGxiSlJPSk45TkJJU1dSNEdpOUIxIiwiaWQiOiIzVGxiSlJPSk45TkJJU1dSNEdpOUIxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvZnRseSBBcyBJbiBBIE1vcm5pbmcgU3VucmlzZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozVGxiSlJPSk45TkJJU1dSNEdpOUIxIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Softly+As+in+a+Morning+Sunrise%22+artist%3A%22Sonny+Rollins%22&type=track&limit=10" + } +] diff --git a/eval/fixtures/discover-new/anthropic.json b/eval/fixtures/discover-new/anthropic.json new file mode 100644 index 0000000..c078b0c --- /dev/null +++ b/eval/fixtures/discover-new/anthropic.json @@ -0,0 +1,72 @@ +[ + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"query\":\"something I do not know yet but will probably like\",\"history\":[],\"prior_recommendations\":[],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"required_candidate_count\":35}"}],"model":"claude-sonnet-5","output_config":{"effort":"low","format":{"schema":{"$defs":{"CandidateOutput":{"type":"object","description":"One bounded candidate in the intent response.","title":"CandidateOutput","properties":{"title":{"type":"string","title":"Title","description":"{maxLength: 200, minLength: 1}"},"artist":{"type":"string","title":"Artist","description":"{maxLength: 200, minLength: 1}"}},"additionalProperties":false,"required":["title","artist"]},"Familiarity":{"type":"string","enum":["familiar","mix","new"],"description":"How strongly a request should favor known or unknown music.","title":"Familiarity"}},"type":"object","description":"Bounded structured output for the intent call.","title":"IntentOutput","properties":{"mood":{"type":"array","title":"Mood","items":{"type":"string"},"description":"{maxItems: 6}"},"activity":{"anyOf":[{"type":"string","description":"{maxLength: 100}"},{"type":"null"}],"title":"Activity","description":"{default: None}"},"era":{"type":"array","title":"Era","items":{"type":"string"},"description":"{maxItems: 5}"},"languages":{"type":"array","title":"Languages","items":{"type":"string"},"description":"{maxItems: 8}"},"genres":{"type":"array","title":"Genres","items":{"type":"string"},"description":"{maxItems: 8}"},"familiarity":{"$ref":"#/$defs/Familiarity"},"is_refinement":{"type":"boolean","title":"Is Refinement"},"intent_summary":{"type":"string","title":"Intent Summary","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"},"candidates":{"type":"array","title":"Candidates","items":{"$ref":"#/$defs/CandidateOutput"},"description":"{maxItems: 50, minItems: 10}"}},"additionalProperties":false,"required":["familiarity","is_refinement","intent_summary","candidates"]},"type":"json_schema"}},"system":[{"type":"text","text":"You are the intent interpreter and candidate generator for a music discovery system. Your\njob is to understand one listener request, use the supplied taste evidence carefully, and\npropose real recordings that another service can resolve against Spotify. Return only data\nthat conforms to the provided output schema. Do not add prose before or after the\nstructured response.\n\nInterpret the request in context. The variable input can contain a current query, a bounded\nconversation history, recommendations from an earlier response, and a compact taste\nprofile. Treat the current query as authoritative. Use history only to resolve references,\ncontinuity, or explicit changes such as \"more like the third one\" or \"less energetic.\"\nPrior recommendations are evidence about what the listener has just seen, not proof that\nthe listener likes every item. The Spotify taste profile is evidence of listening behavior,\nnot a complete identity and not permission to stereotype the listener.\n\nPopulate every schema field honestly. Mood is a short bounded list of useful musical or\nemotional qualities. Activity is a concise listening context when one is stated or strongly\nimplied, otherwise null. Era contains only time periods that matter to the request.\nLanguages contains requested or strongly implied vocal languages; use an empty list when\nlanguage is irrelevant or the music can be instrumental. Genres should be specific enough\nto guide selection without inventing a false precision. Familiarity must be familiar, mix,\nor new. Use familiar when the listener asks for comfort, favorites, known songs, or\nreliable crowd recognition. Use new when the listener asks for discovery, obscurity,\nunfamiliar music, or a departure from their habits. Use mix for a balanced bridge or when\nthe request does not justify either extreme.\n\nSet is_refinement to true only when the listener is revising, narrowing, extending, or\nreferring to an earlier recommendation result in the supplied conversation. A standalone\nrequest is not a refinement merely because history exists. The intent summary must be one\nplain-English sentence that tells the listener how the request was understood. It must not\nmention internal models, candidate generation, schemas, retrieval, or Spotify search\nbehavior.\n\nGenerate the exact candidate count requested in the variable input. Each candidate contains\nonly a track title and the credited artist name most likely to identify the recording.\nChoose recordings that plausibly exist in Spotify's catalog. Use canonical spellings. Do\nnot fabricate tracks, mash up titles and artists, translate titles, or use descriptive\nplaceholders. Avoid remixes, live versions, remasters, edits, sped-up versions, slowed\nversions, karaoke versions, covers, and tribute recordings unless the user explicitly asks\nfor them. When several recordings share a title, choose the artist credit that makes the\nintended recording unambiguous.\n\nCandidate quality matters more than superficial variety. Every candidate should fit the\ninterpreted mood, activity, era, language, genre, and familiarity. Still, spread the set\nacross artists. Do not let one artist dominate the candidate list, even when that artist\nappears prominently in the taste profile. Avoid duplicate titles by the same artist and\navoid multiple editions of the same recording. Use a range of strong fits so a later\nranking step has meaningful choices rather than thirty near-identical songs.\n\nWhen familiarity leans new, novelty means plausibly new to this listener, not obscure.\nKnown tracks are excluded after grounding, so novelty relative to the taste profile is\nenforced downstream; do not chase rarity. Name each artist's signature track, biggest\nsingle, or a similarly famous recording from their catalog: a title you have seen written\ndown many times, spelled exactly as released. Never guess a title that merely sounds like\nthe artist; if no specific famous title comes to mind for an artist, pick a different\nartist whose hit you can name with certainty. Famous artists adjacent to the taste profile\nare welcome; their best-known work is still new to a listener who does not play them.\nPrefer the anthems of the profile's own scenes and neighboring scenes over global chart\nhits: the certainty bar stays the same, but a scene's signature tracks fit the taste far\nbetter than whatever topped the general charts.\nRetain understandable bridges through genre, scene, production style, instrumentation,\nenergy, era, or songwriting. The profile is not exhaustive, so never claim that a\ncandidate is definitely unknown. When familiarity is\nfamiliar, candidates may include supplied top or saved tracks, but remain responsive to the\ncurrent request. When familiarity is mix, combine recognizable anchors with real,\nconfidently identifiable adjacent discoveries rather than splitting into unrelated halves.\n\nUse musical knowledge conservatively. Base selection on durable, commonly knowable\nattributes of recordings. Do not invent listening statistics, personal memories, release\nstories, chart facts, cultural identities, lyrical meanings, or audio features. Do not\ninfer sensitive traits from taste. Explicit safety or content constraints in the request\nare binding. If a request is broad, create a coherent interpretation instead of asking a\nquestion. If constraints conflict, prioritize explicit exclusions, then the current query,\nthen history, then taste evidence.\n\nThe downstream resolver first tries an exact field-filtered search and then a fuzzy\nbare-text search. Help it succeed with correct title and artist spelling. It will reject\nweak title or artist matches, so substituting a vaguely related track wastes a candidate.\nPrefer a confidently identifiable recording over an obscure item whose title or credit you\ncannot state accurately. Do not include Spotify identifiers, album names, explanations,\nscores, or justifications in candidate objects.\n\nBefore returning, silently check that the response matches the schema, the candidate list\nhas exactly the requested size, familiarity uses the allowed value, is_refinement reflects\nconversation continuity, the intent summary is one line, spellings are credible, artist\ndistribution is broad, and no candidate violates an explicit exclusion. Return strictly the\nstructured response and nothing else.\n","cache_control":{"type":"ephemeral"}}]}", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJtb2RlbCI6ImNsYXVkZS1zb25uZXQtNSIsImlkIjoibXNnXzAxMUNkdWZITHFyTEg3MWgxaFhXVW1HRyIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsIg==", + "Y29udGVudCI6W3sidHlwZSI6InRleHQiLCJ0ZXh0Ijoie1wibW9vZFwiOltcImVuZXJnZXRpY1wiLFwiZXhwbG9yYXRvcnlcIixcInVwYmVhdFwiLFwiZ3Jvb3Z5XCIsXCJhZHZlbnR1cm91c1wiXSxcImFjdGl2aXR5XCI6bnVsbCxcImVyYVwiOltdLFwibGFuZ3VhZ2VzXCI6W10sXCJnZW5yZXNcIjpbXCJkcnVtIGFuZCBiYXNzXCIsXCJsaXF1aWQgZG5iXCIsXCJuZXVyb2Z1bmtcIixcImFsdC1wb3BcIixcImhpcCBob3BcIixcInNvdWxcIixcImNsYXNzaWMgcm9ja1wiXSxcImZhbWlsaWFyaXR5XCI6XCJuZXdcIixcImlzX3JlZmluZW1lbnRcIjpmYWxzZSxcImludGVudF9zdW1tYXJ5XCI6XCJPcGVuLWVuZGVkIGRpc2NvdmVyeSByZXF1ZXN0LCBzbyBJIHBpY2tlZCBjb25maWRlbnQsIHdlbGwta25vd24gdHJhY2tzIGZyb20gYXJ0aXN0cyBhbmQgc2NlbmVzIG5lYXIgeW91ciBkcnVtIGFuZCBiYXNzLCBhbHQtcG9wLCBoaXAgaG9wLCBhbmQgY2xhc3NpYyByb2NrIHRhc3RlcyB0aGF0IHlvdSBsaWtlbHkgaGF2ZW4ndCBoZWFyZCB5ZXQuXCIsXCJjYW5kaWRhdGVzXCI6W3tcInRpdGxlXCI6XCJCb2R5IExvb3BcIixcImFydGlzdFwiOlwiTFNCXCJ9LHtcInRpdGxlXCI6XCJDdXQgU29tZSBTbGFja1wiLFwiYXJ0aXN0XCI6XCJCb3VcIn0se1widGl0bGVcIjpcIldhcmVob3VzZSBQcm9qZWN0XCIsXCJhcnRpc3RcIjpcIkV0aGVyd29vZFwifSx7XCJ0aXRsZVwiOlwiVHJvdWJsZVwiLFwiYXJ0aXN0XCI6XCJLYW5pbmVcIn0se1widGl0bGVcIjpcIldpc2ggWW91IFdlbGxcIixcImFydGlzdFwiOlwiSGlnaCBDb250cmFzdFwifSx7XCJ0aXRsZVwiOlwiU3BlZWQgVHJpYWxzXCIsXCJhcnRpc3RcIjpcIkdvbGRpZVwifSx7XCJ0aXRsZVwiOlwiSW5uZXIgQ2l0eSBMaWZlXCIsXCJhcnRpc3RcIjpcIkdvbGRpZVwifSx7XCJ0aXRsZVwiOlwiV2F0Y2hpbmcgV2luZG93c1wiLFwiYXJ0aXN0XCI6XCJKIERpbGxhXCJ9LHtcInRpdGxlXCI6XCJBbHJpZ2h0XCIsXCJhcnRpc3RcIjpcIktlbmRyaWNrIExhbWFyXCJ9LHtcInRpdGxlXCI6XCJMb2NhdGlvblwiLFwiYXJ0aXN0XCI6XCJEYXZlXCJ9LHtcInRpdGxlXCI6XCJMYWRicm9rZSBHcm92ZVwiLFwiYXJ0aXN0XCI6XCJBSiBUcmFjZXlcIn0se1widGl0bGVcIjpcIk93biBJdFwiLFwiYXJ0aXN0XCI6XCJTdG9ybXp5XCJ9LHtcInRpdGxlXCI6XCJWb3NzaSBCb3BcIixcImFydGlzdFwiOlwiU3Rvcm16eVwifSx7XCJ0aXRsZVwiOlwiUmVkYm9uZVwiLFwiYXJ0aXN0XCI6XCJDaGlsZGlzaCBHYW1iaW5vXCJ9LHtcInRpdGxlXCI6XCJCZXN0IFBhcnRcIixcImFydGlzdFwiOlwiRGFuaWVsIENhZXNhclwifSx7XCJ0aXRsZVwiOlwiUGVhY2hlc1wiLFwiYXJ0aXN0XCI6XA==", + "Ikp1c3RpbiBCaWViZXJcIn0se1widGl0bGVcIjpcIk5pZ2h0c1wiLFwiYXJ0aXN0XCI6XCJGcmFuayBPY2VhblwifSx7XCJ0aXRsZVwiOlwiTG9zdFwiLFwiYXJ0aXN0XCI6XCJGcmFuayBPY2VhblwifSx7XCJ0aXRsZVwiOlwiRnJlYWtzXCIsXCJhcnRpc3RcIjpcIkZyZW5jaCBNb250YW5hXCJ9LHtcInRpdGxlXCI6XCJIVU1CTEUuXCIsXCJhcnRpc3RcIjpcIktlbmRyaWNrIExhbWFyXCJ9LHtcInRpdGxlXCI6XCJNb25leSBUcmVlc1wiLFwiYXJ0aXN0XCI6XCJLZW5kcmljayBMYW1hclwifSx7XCJ0aXRsZVwiOlwiU2lja28gTW9kZVwiLFwiYXJ0aXN0XCI6XCJUcmF2aXMgU2NvdHRcIn0se1widGl0bGVcIjpcIlN1bmZsb3dlclwiLFwiYXJ0aXN0XCI6XCJQb3N0IE1hbG9uZVwifSx7XCJ0aXRsZVwiOlwiMzAwNVwiLFwiYXJ0aXN0XCI6XCJDaGlsZGlzaCBHYW1iaW5vXCJ9LHtcInRpdGxlXCI6XCJTd2VhdGVyIFdlYXRoZXJcIixcImFydGlzdFwiOlwiVGhlIE5laWdoYm91cmhvb2RcIn0se1widGl0bGVcIjpcIkVsZWN0cmljIEZlZWxcIixcImFydGlzdFwiOlwiTUdNVFwifSx7XCJ0aXRsZVwiOlwiVGltZSB0byBQcmV0ZW5kXCIsXCJhcnRpc3RcIjpcIk1HTVRcIn0se1widGl0bGVcIjpcIlR3byBXZWVrc1wiLFwiYXJ0aXN0XCI6XCJGS0EgdHdpZ3NcIn0se1widGl0bGVcIjpcIk1pZG5pZ2h0IENpdHlcIixcImFydGlzdFwiOlwiTTgzXCJ9LHtcInRpdGxlXCI6XCJZb3V0aFwiLFwiYXJ0aXN0XCI6XCJEYXVnaHRlclwifSx7XCJ0aXRsZVwiOlwiU2tpbm55IExvdmVcIixcImFydGlzdFwiOlwiQm9uIEl2ZXJcIn0se1widGl0bGVcIjpcIkdvb2V5XCIsXCJhcnRpc3RcIjpcIkdsYXNzIEFuaW1hbHNcIn0se1widGl0bGVcIjpcIkhlYXQgV2F2ZXNcIixcImFydGlzdFwiOlwiR2xhc3MgQW5pbWFsc1wifSx7XCJ0aXRsZVwiOlwiTGFuZHNsaWRlXCIsXCJhcnRpc3RcIjpcIkZsZWV0d29vZCBNYWNcIn0se1widGl0bGVcIjpcIkdvIFlvdXIgT3duIFdheVwiLFwiYXJ0aXN0XCI6XCJGbGVldHdvb2QgTWFjXCJ9XX0ifV0sInN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NTAwNywiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjozMDQ2LCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MzA0NiwiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjk5OSwib3V0cHV0X3Rva2Vuc19kZXRhaWxzIjp7InRoaW5raW5nX3Rva2VucyI6MH0sInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaQ==", + "bmZlcmVuY2VfZ2VvIjoiZ2xvYmFsIn19" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"intent\":{\"mood\":[\"energetic\",\"exploratory\",\"upbeat\",\"groovy\",\"adventurous\"],\"activity\":null,\"era\":[],\"languages\":[],\"genres\":[\"drum and bass\",\"liquid dnb\",\"neurofunk\",\"alt-pop\",\"hip hop\",\"soul\",\"classic rock\"],\"familiarity\":\"new\",\"intent_summary\":\"Open-ended discovery request, so I picked confident, well-known tracks from artists and scenes near your drum and bass, alt-pop, hip hop, and classic rock tastes that you likely haven't heard yet.\"},\"grounded_pool\":[{\"track_id\":\"0O7xFEqePrcTUgOi4qe0uB\",\"title\":\"Inner City Life\",\"artists\":[\"Goldie\"]},{\"track_id\":\"3iVcZ5G6tvkXZkZKlMpIUs\",\"title\":\"Alright\",\"artists\":[\"Kendrick Lamar\"]},{\"track_id\":\"6KFWubocLBhrLs31RpEdR9\",\"title\":\"Location (feat. Burna Boy)\",\"artists\":[\"Dave\",\"Burna Boy\"]},{\"track_id\":\"7AODNxFNPnKaz4hURLzw5l\",\"title\":\"Ladbroke Grove\",\"artists\":[\"AJ Tracey\"]},{\"track_id\":\"4QPEwDdOMhY7rNS05mTyMR\",\"title\":\"Own It (feat. Ed Sheeran & Burna Boy)\",\"artists\":[\"Stormzy\",\"Burna Boy\",\"Ed Sheeran\"]},{\"track_id\":\"5DXKtoZLm31msT7tNGNHLG\",\"title\":\"Vossi Bop\",\"artists\":[\"Stormzy\"]},{\"track_id\":\"3vQ4T78TTMOjQXGfXVKQJo\",\"title\":\"Redbone\",\"artists\":[\"Childish Gambino\"]},{\"track_id\":\"1Q7EgiMOuwDcB0PJC6AzON\",\"title\":\"Best Part (feat. H.E.R.)\",\"artists\":[\"Daniel Caesar\",\"H.E.R.\"]},{\"track_id\":\"4iJyoBOLtHqaGxP12qzhQI\",\"title\":\"Peaches (feat. Daniel Caesar & Giveon)\",\"artists\":[\"Justin Bieber\",\"Daniel Caesar\",\"GIV\\u0112ON\"]},{\"track_id\":\"7eqoqGkKwgOaWNNHx90uEZ\",\"title\":\"Nights\",\"artists\":[\"Frank Ocean\"]},{\"track_id\":\"0wpYoahTjbbM3gFwQWRBfL\",\"title\":\"Freaks\",\"artists\":[\"French Montana\",\"Nicki Minaj\"]},{\"track_id\":\"7KXjTSCq5nL1LoYtL7XAwS\",\"title\":\"HUMBLE.\",\"artists\":[\"Kendrick Lamar\"]},{\"track_id\":\"74tLlkN3rgVzRqQJgPfink\",\"title\":\"Money Trees\",\"artists\":[\"Kendrick Lamar\",\"Jay Rock\"]},{\"track_id\":\"2xLMifQCjDGFmkHkpNLD9h\",\"title\":\"SICKO MODE\",\"artists\":[\"Travis Scott\"]},{\"track_id\":\"0wt9RjddODlWDetpuaXfRK\",\"title\":\"Sunflower (Remix) [with Swae Lee, Nicky Jam, and Prince Royce]\",\"artists\":[\"Post Malone\",\"Swae Lee\",\"Nicky Jam\",\"Prince Royce\",\"G.O.K.B.\"]},{\"track_id\":\"2X6b7zLdIxCejd6GqVcQ9M\",\"title\":\"3005\",\"artists\":[\"Childish Gambino\"]},{\"track_id\":\"2QjOHCTQ1Jl3zawyYOpxh6\",\"title\":\"Sweater Weather\",\"artists\":[\"The Neighbourhood\"]},{\"track_id\":\"3FtYbEfBqAlGO46NUDQSAt\",\"title\":\"Electric Feel\",\"artists\":[\"MGMT\"]},{\"track_id\":\"4iG2gAwKXsOcijVaVXzRPW\",\"title\":\"Time to Pretend\",\"artists\":[\"MGMT\"]},{\"track_id\":\"6V0LX0hP1S0qH513CChAKt\",\"title\":\"Two Weeks\",\"artists\":[\"FKA twigs\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"history\":[],\"requested_selection_count\":15,\"correction\":null}"}],"model":"claude-sonnet-5","output_config":{"effort":"medium","format":{"type":"json_schema","schema":{"$defs":{"RerankSelectionOutput":{"type":"object","description":"One validated object extracted from the rerank stream.","title":"RerankSelectionOutput","properties":{"track_id":{"type":"string","title":"Track Id","description":"{maxLength: 200, minLength: 1}"},"justification":{"type":"string","title":"Justification","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"}},"additionalProperties":false,"required":["track_id","justification"]}},"type":"object","description":"Complete bounded rerank output used for final validation.","title":"RerankOutput","properties":{"recommendations":{"type":"array","title":"Recommendations","items":{"$ref":"#/$defs/RerankSelectionOutput"},"minItems":1,"description":"{maxItems: 50}"}},"additionalProperties":false,"required":["recommendations"]}}},"system":[{"type":"text","text":"You are the final ranking component of a music discovery system. Select and order tracks\nonly from the grounded Spotify pool supplied in the variable input. Return only data that\nconforms to the provided JSON schema. Output strictly the JSON object required by that\nschema, with no markdown, no code fence, no introductory sentence, and no trailing\ncommentary.\n\nThe variable input contains the interpreted intent, a compact listener taste summary,\nbounded conversation history, and a grounded pool. Every pool entry includes a Spotify\ntrack id, title, and artist names. The pool is the complete set of allowed choices. Copy\ntrack_id values exactly. Never create, alter, guess, shorten, or normalize an id. Never\nselect a title that is absent from the pool, even if it would be a better recommendation.\nNever return the same track id twice.\n\nChoose up to the requested selection count, ordered from strongest to weakest\nrecommendation. Prefer a shorter set of honest strong fits over padding with clearly\nunsuitable material, but normally fill the requested count when the pool contains enough\nrelevant choices. Ranking should respond to the current intent first. Use the taste summary\nto personalize among plausible fits, not to override an explicit request. Use history to\nunderstand refinements and references. Treat prior assistant statements as conversation\ncontext rather than verified facts about a recording.\n\nRespect the interpreted mood, activity, era, languages, genres, and familiarity together. A\ntrack need not satisfy every soft descriptor equally, but the ordering should form a\ncoherent listening path. Put the clearest overall matches early. Consider transitions in\nenergy, texture, and familiarity when that creates a more useful sequence, while avoiding a\nmechanical pattern. Spread selections across artists where the grounded pool permits it. Do\nnot rank several editions of the same recording merely to fill space.\n\nFamiliarity affects ordering, but it does not grant access to information outside the\ninput. For familiar requests, favor grounded tracks that visibly connect to the supplied\ntaste evidence or prior recommendations. For new requests, favor credible adjacent\ndiscoveries and avoid leaning entirely on artists named in the taste summary. For mix\nrequests, use recognizable anchors and exploratory choices in a coherent balance. The\napplication may already have filtered known tracks, so do not claim that any selection is\ndefinitely new or previously unheard.\n\nWrite one concise, plain-English justification for each selection. It should connect the\ntrack to the stated intent and, only when supported, to an explicit item or pattern in the\nsupplied taste summary. Keep it to one line. Make the reason useful to the listener rather\nthan describing internal ranking operations. Good reasons identify a grounded connection\nsuch as pacing for the activity, a genre bridge, a requested era, a compatible vocal\nlanguage, a mood transition, or continuity with a named preference.\n\nBe exact and modest. Do not invent audio measurements, tempo values, key signatures,\ninstrumentation, lyrical subjects, release dates, artist biographies, chart history,\ncultural significance, collaborations, popularity, or claims about what the listener has\nheard. A title and artist name alone do not prove detailed sonic or lyrical facts. You may\nuse stable general musical knowledge when confident, but phrase the justification around\nthe supplied intent and visible evidence. If the inputs do not support a specific fact, use\na restrained reason such as \"A focused fit for the requested late-night electronic mood\"\nrather than manufacturing detail.\n\nDo not mention Spotify search, grounding, the candidate generator, language models,\nschemas, hidden scores, safety filters, cache state, or missing data in a justification. Do\nnot tell the listener that a track was selected because it was available in the pool. Do\nnot compare a selection with tracks that are not in the pool. Do not repeat the same\ngeneric sentence for every item. Avoid promotional language and absolute claims such as\n\"perfect,\" \"guaranteed,\" or \"the best.\"\n\nWhen the variable input says this is a correction attempt, treat the stated validation\nfailure as a strict constraint. Return a fresh complete JSON object, not a patch or\nexplanation. Correct invalid ids, duplicates, malformed fields, count problems, and\nformatting errors using only the supplied pool. The correction instruction never allows an\nout-of-pool id.\n\nThe response must be one JSON object with the exact top-level field required by the schema.\nEach array item must contain exactly a track_id and justification in the required types.\nPreserve the requested ranking order in the array. Use valid JSON quoting and escaping. Do\nnot emit comments, dangling commas, alternate keys, null justifications, numeric ids, or\nadditional properties.\n\nBefore returning, silently verify every track_id against the supplied pool, ensure all ids\nare unique, ensure the number of items does not exceed the requested count, confirm each\njustification is honest and one line, confirm the ranking follows the current intent, and\nconfirm the entire response is valid against the provided JSON schema. Return only the\nJSON object.\n","cache_control":{"type":"ephemeral"}}],"stream":true}", + "response_body_base64": "event: message_start
data: {"type":"message_start","message":{"model":"claude-sonnet-5","id":"msg_011CdufJVKcGfDeLqfDXNC22","type":"message","role":"assistant","content":[],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":6385,"cache_creation_input_tokens":2168,"cache_read_input_tokens":0,"cache_creation":{"ephemeral_5m_input_tokens":2168,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"global"}}   }

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: ping
data: {"type": "ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"{"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"rec"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ommendations\":[{\"track"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"_id\":\"0O"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"7x"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"FEqePrcTUgOi4"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"qe0uB\",\"justification\":\"A landmark drum and bass cut that lines up direct"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ly with the energetic, exploratory mood you're after.\"},{\"track_id\":\"2X6b7zLd"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"IxCejd6GqVcQ9"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"M\",\"justification\":\"Childish Gambino is a strong thread in your listening, and this groovy alt-pop track offers a fresh angle on"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" that artist.\"},{\"track_id\":\"3vQ4T78TTMOj"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"QXGfXVKQJo\",\"justification\":\"An upbeat, fun"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"k-leaning Gambino track that bridges your soul and alt-pop leanings with a discovery-friendly vibe.\"},{\"track_id\":\"7e"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"qoqGkKwgOaWN"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"NHx90uEZ\",\"justification\":\"Frank Ocean shows up repeatedly in your taste"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" profile, and this soulful groove fits the adventurous mood nicely.\"},{\"track_id\":\"6V0LX0"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"hP1S0qH513CChAKt\",\"justification\":\"An"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" adventurous, textured alt-pop track that keeps the energetic momentum going while exploring new terrain.\"},{\"track_id\":\"3FtYbE"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"fBqAlGO46NUDQ"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"SAt\",\"justification\":\"A groovy, upbeat synth-pop staple that offers a fresh discovery adjacent to your alt-pop and indie le"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"anings.\"},{\"track_id\":\"4iG2gAwKXsOc"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ijVaVXzRPW\",\"justification\":\"Another MG"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"MT anchor with an exploratory, energetic feel that complements the mood you're chasing.\"},{\"track_"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"id\":\"7KXjTSCq5nL1Lo"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"YtL7XAwS\",\"justification\":\"Kendrick Lamar is central to your top"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" tracks, and this hip hop anthem brings a confident, driving energy.\"},{\"track_id\":\"74tLlk"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"N3rgVzRqQJgPf"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ink\",\"justification\":\"A groovy, classic Kendrick collaboration that extends your hip hop familiarity into a slightly different mode"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":".\"},{\"track_id\":\"3iVcZ5G6tvkX"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ZkZKlMpIUs\",\"justification\":\"An upbeat, soc"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ially charged Kendrick track that keeps the exploratory hip hop thread alive.\"},{\"track_id\":\"2xLMif"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"QCjDGFmkHkpN"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"LD9h\",\"justification\":\"A high-energy hip hop cut that offers an adventurous discovery beyond your usual artists.\"},{\"track_id\":\"7AOD"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"NxFNPnKaz4hUR"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Lzw5l\",\"justification\":\"A UK bass-adjacent track that bridges your drum and bass roots with an energ"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"etic hip hop edge.\"},{\"track_id\":\"5DXKtoZLm31ms"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"T7tNGNHLG\",\"justification\":\"Stormzy connects to your BACKBON"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"E listening history and brings an upbeat, exploratory UK sound.\"},{\"track_id\":\"4QPEwD"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"dOMhY7rNS05mTy"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"MR\",\"justification\":\"A groovy Stormzy collaboration that extends the UK hip hop and soul crossover in"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" your taste.\"},{\"track_id\":\"2QjOHCTQ1Jl3z"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"awyYOpxh6\",\"justification\":\"An energetic alt-pop track that r"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ounds out the mix with a slightly different textural discovery.\"}]}"} }

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null,"stop_details":null},"usage":{"input_tokens":6385,"cache_creation_input_tokens":2168,"cache_read_input_tokens":0,"output_tokens":1074,"output_tokens_details":{"thinking_tokens":0}}               }

event: message_stop
data: {"type":"message_stop"       }

", + "response_chunks_base64": [ + "ZXZlbnQ6IG1lc3NhZ2Vfc3RhcnQKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9zdGFydCIsIm1lc3NhZ2U=", + "Ijp7Im1vZGVsIjoiY2xhdWRlLXNvbm5ldC01IiwiaWQiOiJtc2dfMDExQ2R1ZkpWS2NHZkRlTHFmRFhOQzIyIiwidHlwZSI6Im1lc3NhZ2UiLCJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6W10sInN0b3BfcmVhc29uIjpudWxsLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NjM4NSwiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjoyMTY4LCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MjE2OCwiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjEsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Imdsb2JhbCJ9fSAgIH0KCmV2ZW50OiBjb250ZW50X2Jsb2NrX3N0YXJ0CmRhdGE6IHsidHlwZSI6ImNvbnRlbnRfYmxvY2tfc3RhcnQiLCJpbmRleCI6MCwiY29udGVudF9ibG9jayI6eyJ0eXBlIjoidGV4dCIsInRleHQiOiIifX0KCg==", + "ZXZlbnQ6IHBpbmcKZGF0YTogeyJ0eXBlIjogInBpbmcifQoKZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ7In0gICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInJlYyJ9ICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvbW1lbmRhdGlvbnNcIjpbe1widHJhY2sifSAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJfaWRcIjpcIjBPIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI3eCJ9IH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJGRXFlUHJjVFVnT2k0In0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJxZTB1QlwiLFwianVzdGlmaWNhdGlvblwiOlwiQSBsYW5kbWFyayBkcnVtIGFuZCBiYXNzIGN1dCB0aGF0IGxpbmVzIHVwIGRpcmVjdCJ9ICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJseSB3aXRoIHRoZSBlbmVyZ2V0aWMsIGV4cGxvcmF0b3J5IG1vb2QgeW91J3JlIGFmdGVyLlwifSx7XCJ0cmFja19pZFwiOlwiMlg2Yjd6TGQifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJJeENlamQ2R3FWY1E5In0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJNXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJDaGlsZGlzaCBHYW1iaW5vIGlzIGEgc3Ryb25nIHRocmVhZCBpbiB5b3VyIGxpc3RlbmluZywgYW5kIHRoaXMgZ3Jvb3Z5IGFsdC1wb3AgdHJhY2sgb2ZmZXJzIGEgZnJlc2ggYW5nbGUgb24ifSAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgdGhhdCBhcnRpc3QuXCJ9LHtcInRyYWNrX2lkXCI6XCIzdlE0VDc4VFRNT2oifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJRWEdmWFZLUUpvXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBbiB1cGJlYXQsIGZ1biJ9ICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJrLWxlYW5pbmcgR2FtYmlubyB0cmFjayB0aGF0IGJyaWRnZXMgeW91ciBzb3VsIGFuZCBhbHQtcG9wIGxlYW5pbmdzIHdpdGggYSBkaXNjb3ZlcnktZnJpZW5kbHkgdmliZS5cIn0se1widHJhY2tfaWRcIjpcIjdlIn0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJxb3FHa0t3Z09hV04ifSAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJOSHg5MHVFWlwiLFwianVzdGlmaWNhdGlvblwiOlwiRnJhbmsgT2NlYW4gc2hvd3MgdXAgcmVwZWF0ZWRseSBpbiB5b3VyIHRhc3RlIn0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgcHJvZmlsZSwgYW5kIHRoaXMgc291bGZ1bCBncm9vdmUgZml0cyB0aGUgYWR2ZW50dXJvdXMgbW9vZCBuaWNlbHkuXCJ9LHtcInRyYWNrX2lkXCI6XCI2VjBMWDAifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJoUDFTMHFINTEzQ0NoQUt0XCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBbiJ9ICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgYWR2ZW50dXJvdXMsIHRleHR1cmVkIGFsdC1wb3AgdHJhY2sgdGhhdCBrZWVwcyB0aGUgZW5lcmdldGljIG1vbWVudHVtIGdvaW5nIHdoaWxlIGV4cGxvcmluZyBuZXcgdGVycmFpbi5cIn0se1widHJhY2tfaWRcIjpcIjNGdFliRSJ9ICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJmQnFBbEdPNDZOVURRIn0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJTQXRcIixcImp1c3RpZmljYXRpb25cIjpcIkEgZ3Jvb3Z5LCB1cGJlYXQgc3ludGgtcG9wIHN0YXBsZSB0aGF0IG9mZmVycyBhIGZyZXNoIGRpc2NvdmVyeSBhZGphY2VudCB0byB5b3VyIGFsdC1wb3AgYW5kIGluZGllIGxlIn0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJhbmluZ3MuXCJ9LHtcInRyYWNrX2lkXCI6XCI0aUcyZ0F3S1hzT2MifSAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpalZhVlh6UlBXXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBbm90aGVyIE1HIn0gICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJNVCBhbmNob3Igd2l0aCBhbiBleHBsb3JhdG9yeSwgZW5lcmdldGljIGZlZWwgdGhhdCBjb21wbGVtZW50cyB0aGUgbW9vZCB5b3UncmUgY2hhc2luZy5cIn0se1widHJhY2tfIn0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpZFwiOlwiN0tYalRTQ3E1bkwxTG8ifX0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJZdEw3WEF3U1wiLFwianVzdGlmaWNhdGlvblwiOlwiS2VuZHJpY2sgTGFtYXIgaXMgY2VudHJhbCB0byB5b3VyIHRvcCJ9ICAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgdHJhY2tzLCBhbmQgdGhpcyBoaXAgaG9wIGFudGhlbSBicmluZ3MgYSBjb25maWRlbnQsIGRyaXZpbmcgZW5lcmd5LlwifSx7XCJ0cmFja19pZFwiOlwiNzR0TGxrIn19Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJOM3JnVnpScVFKZ1BmIn0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpbmtcIixcImp1c3RpZmljYXRpb25cIjpcIkEgZ3Jvb3Z5LCBjbGFzc2ljIEtlbmRyaWNrIGNvbGxhYm9yYXRpb24gdGhhdCBleHRlbmRzIHlvdXIgaGlwIGhvcCBmYW1pbGlhcml0eSBpbnRvIGEgc2xpZ2h0bHkgZGlmZmVyZW50IG1vZGUifSAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIuXCJ9LHtcInRyYWNrX2lkXCI6XCIzaVZjWjVHNnR2a1gifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJaa1pLbE1wSVVzXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBbiB1cGJlYXQsIHNvYyJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpYWxseSBjaGFyZ2VkIEtlbmRyaWNrIHRyYWNrIHRoYXQga2VlcHMgdGhlIGV4cGxvcmF0b3J5IGhpcCBob3AgdGhyZWFkIGFsaXZlLlwifSx7XCJ0cmFja19pZFwiOlwiMnhMTWlmIn0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJRQ2pER0Zta0hrcE4ifSAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJMRDloXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIGhpZ2gtZW5lcmd5IGhpcCBob3AgY3V0IHRoYXQgb2ZmZXJzIGFuIGFkdmVudHVyb3VzIGRpc2NvdmVyeSBiZXlvbmQgeW91ciB1c3VhbCBhcnRpc3RzLlwifSx7XCJ0cmFja19pZFwiOlwiN0FPRCJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJOeEZOUG5LYXo0aFVSIn0gICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJMenc1bFwiLFwianVzdGlmaWNhdGlvblwiOlwiQSBVSyBiYXNzLWFkamFjZW50IHRyYWNrIHRoYXQgYnJpZGdlcyB5b3VyIGRydW0gYW5kIGJhc3Mgcm9vdHMgd2l0aCBhbiBlbmVyZyJ9ICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJldGljIGhpcCBob3AgZWRnZS5cIn0se1widHJhY2tfaWRcIjpcIjVEWEt0b1pMbTMxbXMifSAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJUN3ROR05ITEdcIixcImp1c3RpZmljYXRpb25cIjpcIlN0b3JtenkgY29ubmVjdHMgdG8geW91ciBCQUNLQk9OIn0gICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJFIGxpc3RlbmluZyBoaXN0b3J5IGFuZCBicmluZ3MgYW4gdXBiZWF0LCBleHBsb3JhdG9yeSBVSyBzb3VuZC5cIn0se1widHJhY2tfaWRcIjpcIjRRUEV3RCJ9IH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJkT01oWTdyTlMwNW1UeSJ9ICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJNUlwiLFwianVzdGlmaWNhdGlvblwiOlwiQSBncm9vdnkgU3Rvcm16eSBjb2xsYWJvcmF0aW9uIHRoYXQgZXh0ZW5kcyB0aGUgVUsgaGlwIGhvcCBhbmQgc291bCBjcm9zc292ZXIgaW4ifSAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgeW91ciB0YXN0ZS5cIn0se1widHJhY2tfaWRcIjpcIjJRak9IQ1RRMUpsM3oifSAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJhd3lZT3B4aDZcIixcImp1c3RpZmljYXRpb25cIjpcIkFuIGVuZXJnZXRpYyBhbHQtcG9wIHRyYWNrIHRoYXQgciJ9ICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvdW5kcyBvdXQgdGhlIG1peCB3aXRoIGEgc2xpZ2h0bHkgZGlmZmVyZW50IHRleHR1cmFsIGRpc2NvdmVyeS5cIn1dfSJ9IH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RvcApkYXRhOiB7InR5cGUiOiJjb250ZW50X2Jsb2NrX3N0b3AiLCJpbmRleCI6MH0KCg==", + "ZXZlbnQ6IG1lc3NhZ2VfZGVsdGEKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9kZWx0YSIsImRlbHRhIjp7InN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGx9LCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjYzODUsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MjE2OCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjAsIm91dHB1dF90b2tlbnMiOjEwNzQsIm91dHB1dF90b2tlbnNfZGV0YWlscyI6eyJ0aGlua2luZ190b2tlbnMiOjB9fSAgICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IG1lc3NhZ2Vfc3RvcApkYXRhOiB7InR5cGUiOiJtZXNzYWdlX3N0b3AiICAgICAgIH0KCg==" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + } +] diff --git a/eval/fixtures/discover-new/spotify.json b/eval/fixtures/discover-new/spotify.json new file mode 100644 index 0000000..5e7587f --- /dev/null +++ b/eval/fixtures/discover-new/spotify.json @@ -0,0 +1,616 @@ +[ + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=", + "response_chunks_base64": [ + "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=0" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJvZHklMjBMb29wJTIyJTIwYXJ0aXN0JTNBJTIyTFNCJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJvZHklMjBMb29wJTIyJTIwYXJ0aXN0JTNBJTIyTFNCJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Body+Loop%22+artist%3A%22LSB%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRyb3VibGUlMjIlMjBhcnRpc3QlM0ElMjJLYW5pbmUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRyb3VibGUlMjIlMjBhcnRpc3QlM0ElMjJLYW5pbmUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Trouble%22+artist%3A%22Kanine%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhcmVob3VzZSUyMFByb2plY3QlMjIlMjBhcnRpc3QlM0ElMjJFdGhlcndvb2QlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhcmVob3VzZSUyMFByb2plY3QlMjIlMjBhcnRpc3QlM0ElMjJFdGhlcndvb2QlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Warehouse+Project%22+artist%3A%22Etherwood%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkN1dCUyMFNvbWUlMjBTbGFjayUyMiUyMGFydGlzdCUzQSUyMkJvdSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkN1dCUyMFNvbWUlMjBTbGFjayUyMiUyMGFydGlzdCUzQSUyMkJvdSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Cut+Some+Slack%22+artist%3A%22Bou%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNwZWVkJTIwVHJpYWxzJTIyJTIwYXJ0aXN0JTNBJTIyR29sZGllJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNwZWVkJTIwVHJpYWxzJTIyJTIwYXJ0aXN0JTNBJTIyR29sZGllJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Speed+Trials%22+artist%3A%22Goldie%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldpc2glMjBZb3UlMjBXZWxsJTIyJTIwYXJ0aXN0JTNBJTIySGlnaCUyMENvbnRyYXN0JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldpc2glMjBZb3UlMjBXZWxsJTIyJTIwYXJ0aXN0JTNBJTIySGlnaCUyMENvbnRyYXN0JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Wish+You+Well%22+artist%3A%22High+Contrast%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Body%20Loop%20LSB&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Body%20Loop%20LSB&type=track","offset":0,"previous":null,"total":11,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0qix882rEdbDhiOax0KmIM"},"href":"https://api.spotify.com/v1/artists/0qix882rEdbDhiOax0KmIM","id":"0qix882rEdbDhiOax0KmIM","name":"JacJak","type":"artist","uri":"spotify:artist:0qix882rEdbDhiOax0KmIM"}],"external_urls":{"spotify":"https://open.spotify.com/album/6rK2FpV4Ff1nWwppJMEYoT"},"href":"https://api.spotify.com/v1/albums/6rK2FpV4Ff1nWwppJMEYoT","id":"6rK2FpV4Ff1nWwppJMEYoT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b8d7b89ef6652e47e238dcb0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b8d7b89ef6652e47e238dcb0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b8d7b89ef6652e47e238dcb0"}],"is_playable":true,"name":"On Loop","release_date":"2026-05-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6rK2FpV4Ff1nWwppJMEYoT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0qix882rEdbDhiOax0KmIM"},"href":"https://api.spotify.com/v1/artists/0qix882rEdbDhiOax0KmIM","id":"0qix882rEdbDhiOax0KmIM","name":"JacJak","type":"artist","uri":"spotify:artist:0qix882rEdbDhiOax0KmIM"}],"disc_number":1,"duration_ms":179956,"explicit":false,"external_ids":{"isrc":"IT0J26101243"},"external_urls":{"spotify":"https://open.spotify.com/track/1A1wX4KXAq6OvLO8d1qWeB"},"href":"https://api.spotify.com/v1/tracks/1A1wX4KXAq6OvLO8d1qWeB","id":"1A1wX4KXAq6OvLO8d1qWeB","is_local":false,"is_playable":true,"name":"On Loop","track_number":1,"type":"track","uri":"spotify:track:1A1wX4KXAq6OvLO8d1qWeB"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4MCBfE4596Uoi2O4DtmEMz"},"href":"https://api.spotify.com/v1/artists/4MCBfE4596Uoi2O4DtmEMz","id":"4MCBfE4596Uoi2O4DtmEMz","name":"Juice WRLD","type":"artist","uri":"spotify:artist:4MCBfE4596Uoi2O4DtmEMz"}],"external_urls":{"spotify":"https://open.spotify.com/album/51ojViy1d9Siz28EF08d49"},"href":"https://api.spotify.com/v1/albums/51ojViy1d9Siz28EF08d49","id":"51ojViy1d9Siz28EF08d49","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dec09ac32f6565ce5ff307e9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dec09ac32f6565ce5ff307e9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dec09ac32f6565ce5ff307e9"}],"is_playable":true,"name":"The Pre-Party (Extended)","release_date":"2024-10-14","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:51ojViy1d9Siz28EF08d49"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4MCBfE4596Uoi2O4DtmEMz"},"href":"https://api.spotify.com/v1/artists/4MCBfE4596Uoi2O4DtmEMz","id":"4MCBfE4596Uoi2O4DtmEMz","name":"Juice WRLD","type":"artist","uri":"spotify:artist:4MCBfE4596Uoi2O4DtmEMz"}],"disc_number":1,"duration_ms":152183,"explicit":true,"external_ids":{"isrc":"USUG12407286"},"external_urls":{"spotify":"https://open.spotify.com/track/3GqB3q2lYK3qsvhghx92rS"},"href":"https://api.spotify.com/v1/tracks/3GqB3q2lYK3qsvhghx92rS","id":"3GqB3q2lYK3qsvhghx92rS","is_local":false,"is_playable":true,"name":"Cavalier","track_number":2,"type":"track","uri":"spotify:track:3GqB3q2lYK3qsvhghx92rS"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ABk515kENDyATUdpCKVfW"},"href":"https://api.spotify.com/v1/artists/0ABk515kENDyATUdpCKVfW","id":"0ABk515kENDyATUdpCKVfW","name":"Westside Gunn","type":"artist","uri":"spotify:artist:0ABk515kENDyATUdpCKVfW"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nfJMRoIjyRwk3ZTHNm0PY"},"href":"https://api.spotify.com/v1/albums/6nfJMRoIjyRwk3ZTHNm0PY","id":"6nfJMRoIjyRwk3ZTHNm0PY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a29bd588f4caf84bd4cd6f8b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a29bd588f4caf84bd4cd6f8b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a29bd588f4caf84bd4cd6f8b"}],"is_playable":true,"name":"Pray for Paris","release_date":"2020-04-17","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6nfJMRoIjyRwk3ZTHNm0PY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ABk515kENDyATUdpCKVfW"},"href":"https://api.spotify.com/v1/artists/0ABk515kENDyATUdpCKVfW","id":"0ABk515kENDyATUdpCKVfW","name":"Westside Gunn","type":"artist","uri":"spotify:artist:0ABk515kENDyATUdpCKVfW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/67gqUXxHedeUGDTxwBzdjS"},"href":"https://api.spotify.com/v1/artists/67gqUXxHedeUGDTxwBzdjS","id":"67gqUXxHedeUGDTxwBzdjS","name":"Conway the Machine","type":"artist","uri":"spotify:artist:67gqUXxHedeUGDTxwBzdjS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5Matrg5du62bXwer29cU5T"},"href":"https://api.spotify.com/v1/artists/5Matrg5du62bXwer29cU5T","id":"5Matrg5du62bXwer29cU5T","name":"Benny The Butcher","type":"artist","uri":"spotify:artist:5Matrg5du62bXwer29cU5T"}],"disc_number":1,"duration_ms":284302,"explicit":true,"external_ids":{"isrc":"USUYG1305212"},"external_urls":{"spotify":"https://open.spotify.com/track/2TMmxS4qWwfZ5h2xwaDFsY"},"href":"https://api.spotify.com/v1/tracks/2TMmxS4qWwfZ5h2xwaDFsY","id":"2TMmxS4qWwfZ5h2xwaDFsY","is_local":false,"is_playable":true,"name":"George Bondo (feat. Conway the Machine & Benny The Butcher)","track_number":3,"type":"track","uri":"spotify:track:2TMmxS4qWwfZ5h2xwaDFsY"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4MzJMcHQBl9SIYSjwWn8QW"},"href":"https://api.spotify.com/v1/artists/4MzJMcHQBl9SIYSjwWn8QW","id":"4MzJMcHQBl9SIYSjwWn8QW","name":"Spiritbox","type":"artist","uri":"spotify:artist:4MzJMcHQBl9SIYSjwWn8QW"}],"external_urls":{"spotify":"https://open.spotify.com/album/5z9EQ9ABAqMmUVnOo7pDHt"},"href":"https://api.spotify.com/v1/albums/5z9EQ9ABAqMmUVnOo7pDHt","id":"5z9EQ9ABAqMmUVnOo7pDHt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c152ab62538b31f737911b8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c152ab62538b31f737911b8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c152ab62538b31f737911b8"}],"is_playable":true,"name":"Cellar Door","release_date":"2023-10-13","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:5z9EQ9ABAqMmUVnOo7pDHt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4MzJMcHQBl9SIYSjwWn8QW"},"href":"https://api.spotify.com/v1/artists/4MzJMcHQBl9SIYSjwWn8QW","id":"4MzJMcHQBl9SIYSjwWn8QW","name":"Spiritbox","type":"artist","uri":"spotify:artist:4MzJMcHQBl9SIYSjwWn8QW"}],"disc_number":1,"duration_ms":283957,"explicit":false,"external_ids":{"isrc":"QMRSZ2301311"},"external_urls":{"spotify":"https://open.spotify.com/track/2GWtLHhqPjvZt1aWiBDsTU"},"href":"https://api.spotify.com/v1/tracks/2GWtLHhqPjvZt1aWiBDsTU","id":"2GWtLHhqPjvZt1aWiBDsTU","is_local":false,"is_playable":true,"name":"Cellar Door","track_number":1,"type":"track","uri":"spotify:track:2GWtLHhqPjvZt1aWiBDsTU"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7EWU4FhUJM1sZQgQKdENeT"},"href":"https://api.spotify.com/v1/artists/7EWU4FhUJM1sZQgQKdENeT","id":"7EWU4FhUJM1sZQgQKdENeT","name":"Hopsin","type":"artist","uri":"spotify:artist:7EWU4FhUJM1sZQgQKdENeT"}],"external_urls":{"spotify":"https://open.spotify.com/album/5kRhn7K8D7txVpIGGWfVCu"},"href":"https://api.spotify.com/v1/albums/5kRhn7K8D7txVpIGGWfVCu","id":"5kRhn7K8D7txVpIGGWfVCu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734f1dab8c832d312591947bf9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024f1dab8c832d312591947bf9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514f1dab8c832d312591947bf9"}],"is_playable":true,"name":"Ill Mind of Hopsin 5 - Single","release_date":"2012-07-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5kRhn7K8D7txVpIGGWfVCu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7EWU4FhUJM1sZQgQKdENeT"},"href":"https://api.spotify.com/v1/artists/7EWU4FhUJM1sZQgQKdENeT","id":"7EWU4FhUJM1sZQgQKdENeT","name":"Hopsin","type":"artist","uri":"spotify:artist:7EWU4FhUJM1sZQgQKdENeT"}],"disc_number":1,"duration_ms":289004,"explicit":true,"external_ids":{"isrc":"USUYG1019176"},"external_urls":{"spotify":"https://open.spotify.com/track/7dDLHlyZJBqEWSndlPWyCT"},"href":"https://api.spotify.com/v1/tracks/7dDLHlyZJBqEWSndlPWyCT","id":"7dDLHlyZJBqEWSndlPWyCT","is_local":false,"is_playable":true,"name":"Ill Mind of Hopsin 5","track_number":1,"type":"track","uri":"spotify:track:7dDLHlyZJBqEWSndlPWyCT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"}],"external_urls":{"spotify":"https://open.spotify.com/album/6seO2kGWhFKbe61aNvdB12"},"href":"https://api.spotify.com/v1/albums/6seO2kGWhFKbe61aNvdB12","id":"6seO2kGWhFKbe61aNvdB12","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfcd61a7e812238851963b32"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfcd61a7e812238851963b32"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfcd61a7e812238851963b32"}],"is_playable":true,"name":"Drug Dealers Anonymous","release_date":"2016-06-23","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6seO2kGWhFKbe61aNvdB12"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3nFkdlSjzX9mRTtwJOzDYB"},"href":"https://api.spotify.com/v1/artists/3nFkdlSjzX9mRTtwJOzDYB","id":"3nFkdlSjzX9mRTtwJOzDYB","name":"JA\u0178-Z","type":"artist","uri":"spotify:artist:3nFkdlSjzX9mRTtwJOzDYB"}],"disc_number":1,"duration_ms":253786,"explicit":true,"external_ids":{"isrc":"USUM71605133"},"external_urls":{"spotify":"https://open.spotify.com/track/1b6rmL3VXBgYTbn61kM8wT"},"href":"https://api.spotify.com/v1/tracks/1b6rmL3VXBgYTbn61kM8wT","id":"1b6rmL3VXBgYTbn61kM8wT","is_local":false,"is_playable":true,"name":"Drug Dealers Anonymous","track_number":1,"type":"track","uri":"spotify:track:1b6rmL3VXBgYTbn61kM8wT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"}],"external_urls":{"spotify":"https://open.spotify.com/album/3N7agGkKrdlEHBrzSDTNmG"},"href":"https://api.spotify.com/v1/albums/3N7agGkKrdlEHBrzSDTNmG","id":"3N7agGkKrdlEHBrzSDTNmG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735c403000feeddc6a725c0bd1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025c403000feeddc6a725c0bd1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515c403000feeddc6a725c0bd1"}],"is_playable":true,"name":"Malice 'N Wonderland","release_date":"2009-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:3N7agGkKrdlEHBrzSDTNmG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1W3FSF1BLpY3hlVIgvenLz"},"href":"https://api.spotify.com/v1/artists/1W3FSF1BLpY3hlVIgvenLz","id":"1W3FSF1BLpY3hlVIgvenLz","name":"THE-DREAM","type":"artist","uri":"spotify:artist:1W3FSF1BLpY3hlVIgvenLz"}],"disc_number":1,"duration_ms":256546,"explicit":true,"external_ids":{"isrc":"USCA20904839"},"external_urls":{"spotify":"https://open.spotify.com/track/1E8wif6bVXurUgxV8Gfwrw"},"href":"https://api.spotify.com/v1/tracks/1E8wif6bVXurUgxV8Gfwrw","id":"1E8wif6bVXurUgxV8Gfwrw","is_local":false,"is_playable":true,"name":"Gangsta Luv","track_number":6,"type":"track","uri":"spotify:track:1E8wif6bVXurUgxV8Gfwrw"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7otNm1oGn1kmJpFIZ3ts21"},"href":"https://api.spotify.com/v1/albums/7otNm1oGn1kmJpFIZ3ts21","id":"7otNm1oGn1kmJpFIZ3ts21","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734a382db9121b0722a768adba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024a382db9121b0722a768adba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514a382db9121b0722a768adba"}],"is_playable":true,"name":"Old School RnB","release_date":"2026-08-08","release_date_precision":"day","total_tracks":64,"type":"album","uri":"spotify:album:7otNm1oGn1kmJpFIZ3ts21"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1W3FSF1BLpY3hlVIgvenLz"},"href":"https://api.spotify.com/v1/artists/1W3FSF1BLpY3hlVIgvenLz","id":"1W3FSF1BLpY3hlVIgvenLz","name":"THE-DREAM","type":"artist","uri":"spotify:artist:1W3FSF1BLpY3hlVIgvenLz"}],"disc_number":1,"duration_ms":257133,"explicit":true,"external_ids":{"isrc":"USCA20904839"},"external_urls":{"spotify":"https://open.spotify.com/track/2ZxhxgA1CjNzG4mlI5M3Lm"},"href":"https://api.spotify.com/v1/tracks/2ZxhxgA1CjNzG4mlI5M3Lm","id":"2ZxhxgA1CjNzG4mlI5M3Lm","is_local":false,"is_playable":true,"name":"Gangsta Luv","track_number":45,"type":"track","uri":"spotify:track:2ZxhxgA1CjNzG4mlI5M3Lm"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3BQZ4iBTEt3weXvWVAihR3"},"href":"https://api.spotify.com/v1/albums/3BQZ4iBTEt3weXvWVAihR3","id":"3BQZ4iBTEt3weXvWVAihR3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738a9d2f67c71c87a5cbdb40b2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028a9d2f67c71c87a5cbdb40b2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518a9d2f67c71c87a5cbdb40b2"}],"is_playable":true,"name":"Hip Hop Club Banger","release_date":"2026-08-01","release_date_precision":"day","total_tracks":70,"type":"album","uri":"spotify:album:3BQZ4iBTEt3weXvWVAihR3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1W3FSF1BLpY3hlVIgvenLz"},"href":"https://api.spotify.com/v1/artists/1W3FSF1BLpY3hlVIgvenLz","id":"1W3FSF1BLpY3hlVIgvenLz","name":"THE-DREAM","type":"artist","uri":"spotify:artist:1W3FSF1BLpY3hlVIgvenLz"}],"disc_number":1,"duration_ms":257133,"explicit":true,"external_ids":{"isrc":"USCA20904839"},"external_urls":{"spotify":"https://open.spotify.com/track/287rQtNbV4NsBvlZmvJCRT"},"href":"https://api.spotify.com/v1/tracks/287rQtNbV4NsBvlZmvJCRT","id":"287rQtNbV4NsBvlZmvJCRT","is_local":false,"is_playable":true,"name":"Gangsta Luv","track_number":34,"type":"track","uri":"spotify:track:287rQtNbV4NsBvlZmvJCRT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7jnEJXIT7Ur1VLF1BC48eD"},"href":"https://api.spotify.com/v1/artists/7jnEJXIT7Ur1VLF1BC48eD","id":"7jnEJXIT7Ur1VLF1BC48eD","name":"My Boy Arlo","type":"artist","uri":"spotify:artist:7jnEJXIT7Ur1VLF1BC48eD"}],"external_urls":{"spotify":"https://open.spotify.com/album/0TMwChd09CEYj3qSyTofL1"},"href":"https://api.spotify.com/v1/albums/0TMwChd09CEYj3qSyTofL1","id":"0TMwChd09CEYj3qSyTofL1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731d0cd3b0e276e850909988ee"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021d0cd3b0e276e850909988ee"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511d0cd3b0e276e850909988ee"}],"is_playable":true,"name":"URL To Her Body","release_date":"2025-12-31","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0TMwChd09CEYj3qSyTofL1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7jnEJXIT7Ur1VLF1BC48eD"},"href":"https://api.spotify.com/v1/artists/7jnEJXIT7Ur1VLF1BC48eD","id":"7jnEJXIT7Ur1VLF1BC48eD","name":"My Boy Arlo","type":"artist","uri":"spotify:artist:7jnEJXIT7Ur1VLF1BC48eD"}],"disc_number":1,"duration_ms":216758,"explicit":false,"external_ids":{"isrc":"QZFYX2611590"},"external_urls":{"spotify":"https://open.spotify.com/track/3be5225YmWfELtUIQ6c6HA"},"href":"https://api.spotify.com/v1/tracks/3be5225YmWfELtUIQ6c6HA","id":"3be5225YmWfELtUIQ6c6HA","is_local":false,"is_playable":true,"name":"URL To Her Body","track_number":1,"type":"track","uri":"spotify:track:3be5225YmWfELtUIQ6c6HA"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Body%20Loop%20LSB&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Body%20Loop%20LSB&type=track","offset":0,"previous":null,"total":11,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0qix882rEdbDhiOax0KmIM"},"href":"https://api.spotify.com/v1/artists/0qix882rEdbDhiOax0KmIM","id":"0qix882rEdbDhiOax0KmIM","name":"JacJak","type":"artist","uri":"spotify:artist:0qix882rEdbDhiOax0KmIM"}],"external_urls":{"spotify":"https://open.spotify.com/album/6rK2FpV4Ff1nWwppJMEYoT"},"href":"https://api.spotify.com/v1/albums/6rK2FpV4Ff1nWwppJMEYoT","id":"6rK2FpV4Ff1nWwppJMEYoT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b8d7b89ef6652e47e238dcb0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b8d7b89ef6652e47e238dcb0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b8d7b89ef6652e47e238dcb0"}],"is_playable":true,"name":"On Loop","release_date":"2026-05-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6rK2FpV4Ff1nWwppJMEYoT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0qix882rEdbDhiOax0KmIM"},"href":"https://api.spotify.com/v1/artists/0qix882rEdbDhiOax0KmIM","id":"0qix882rEdbDhiOax0KmIM","name":"JacJak","type":"artist","uri":"spotify:artist:0qix882rEdbDhiOax0KmIM"}],"disc_number":1,"duration_ms":179956,"explicit":false,"external_ids":{"isrc":"IT0J26101243"},"external_urls":{"spotify":"https://open.spotify.com/track/1A1wX4KXAq6OvLO8d1qWeB"},"href":"https://api.spotify.com/v1/tracks/1A1wX4KXAq6OvLO8d1qWeB","id":"1A1wX4KXAq6OvLO8d1qWeB","is_local":false,"is_playable":true,"name":"On Loop","track_number":1,"type":"track","uri":"spotify:track:1A1wX4KXAq6OvLO8d1qWeB"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4MCBfE4596Uoi2O4DtmEMz"},"href":"https://api.spotify.com/v1/artists/4MCBfE4596Uoi2O4DtmEMz","id":"4MCBfE4596Uoi2O4DtmEMz","name":"Juice WRLD","type":"artist","uri":"spotify:artist:4MCBfE4596Uoi2O4DtmEMz"}],"external_urls":{"spotify":"https://open.spotify.com/album/51ojViy1d9Siz28EF08d49"},"href":"https://api.spotify.com/v1/albums/51ojViy1d9Siz28EF08d49","id":"51ojViy1d9Siz28EF08d49","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dec09ac32f6565ce5ff307e9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dec09ac32f6565ce5ff307e9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dec09ac32f6565ce5ff307e9"}],"is_playable":true,"name":"The Pre-Party (Extended)","release_date":"2024-10-14","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:51ojViy1d9Siz28EF08d49"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4MCBfE4596Uoi2O4DtmEMz"},"href":"https://api.spotify.com/v1/artists/4MCBfE4596Uoi2O4DtmEMz","id":"4MCBfE4596Uoi2O4DtmEMz","name":"Juice WRLD","type":"artist","uri":"spotify:artist:4MCBfE4596Uoi2O4DtmEMz"}],"disc_number":1,"duration_ms":152183,"explicit":true,"external_ids":{"isrc":"USUG12407286"},"external_urls":{"spotify":"https://open.spotify.com/track/3GqB3q2lYK3qsvhghx92rS"},"href":"https://api.spotify.com/v1/tracks/3GqB3q2lYK3qsvhghx92rS","id":"3GqB3q2lYK3qsvhghx92rS","is_local":false,"is_playable":true,"name":"Cavalier","track_number":2,"type":"track","uri":"spotify:track:3GqB3q2lYK3qsvhghx92rS"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ABk515kENDyATUdpCKVfW"},"href":"https://api.spotify.com/v1/artists/0ABk515kENDyATUdpCKVfW","id":"0ABk515kENDyATUdpCKVfW","name":"Westside Gunn","type":"artist","uri":"spotify:artist:0ABk515kENDyATUdpCKVfW"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nfJMRoIjyRwk3ZTHNm0PY"},"href":"https://api.spotify.com/v1/albums/6nfJMRoIjyRwk3ZTHNm0PY","id":"6nfJMRoIjyRwk3ZTHNm0PY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a29bd588f4caf84bd4cd6f8b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a29bd588f4caf84bd4cd6f8b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a29bd588f4caf84bd4cd6f8b"}],"is_playable":true,"name":"Pray for Paris","release_date":"2020-04-17","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6nfJMRoIjyRwk3ZTHNm0PY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ABk515kENDyATUdpCKVfW"},"href":"https://api.spotify.com/v1/artists/0ABk515kENDyATUdpCKVfW","id":"0ABk515kENDyATUdpCKVfW","name":"Westside Gunn","type":"artist","uri":"spotify:artist:0ABk515kENDyATUdpCKVfW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/67gqUXxHedeUGDTxwBzdjS"},"href":"https://api.spotify.com/v1/artists/67gqUXxHedeUGDTxwBzdjS","id":"67gqUXxHedeUGDTxwBzdjS","name":"Conway the Machine","type":"artist","uri":"spotify:artist:67gqUXxHedeUGDTxwBzdjS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5Matrg5du62bXwer29cU5T"},"href":"https://api.spotify.com/v1/artists/5Matrg5du62bXwer29cU5T","id":"5Matrg5du62bXwer29cU5T","name":"Benny The Butcher","type":"artist","uri":"spotify:artist:5Matrg5du62bXwer29cU5T"}],"disc_number":1,"duration_ms":284302,"explicit":true,"external_ids":{"isrc":"USUYG1305212"},"external_urls":{"spotify":"https://open.spotify.com/track/2TMmxS4qWwfZ5h2xwaDFsY"},"href":"https://api.spotify.com/v1/tracks/2TMmxS4qWwfZ5h2xwaDFsY","id":"2TMmxS4qWwfZ5h2xwaDFsY","is_local":false,"is_playable":true,"name":"George Bondo (feat. Conway the Machine & Benny The Butcher)","track_number":3,"type":"track","uri":"spotify:track:2TMmxS4qWwfZ5h2xwaDFsY"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4MzJMcHQBl9SIYSjwWn8QW"},"href":"https://api.spotify.com/v1/artists/4MzJMcHQBl9SIYSjwWn8QW","id":"4MzJMcHQBl9SIYSjwWn8QW","name":"Spiritbox","type":"artist","uri":"spotify:artist:4MzJMcHQBl9SIYSjwWn8QW"}],"external_urls":{"spotify":"https://open.spotify.com/album/5z9EQ9ABAqMmUVnOo7pDHt"},"href":"https://api.spotify.com/v1/albums/5z9EQ9ABAqMmUVnOo7pDHt","id":"5z9EQ9ABAqMmUVnOo7pDHt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c152ab62538b31f737911b8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c152ab62538b31f737911b8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c152ab62538b31f737911b8"}],"is_playable":true,"name":"Cellar Door","release_date":"2023-10-13","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:5z9EQ9ABAqMmUVnOo7pDHt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4MzJMcHQBl9SIYSjwWn8QW"},"href":"https://api.spotify.com/v1/artists/4MzJMcHQBl9SIYSjwWn8QW","id":"4MzJMcHQBl9SIYSjwWn8QW","name":"Spiritbox","type":"artist","uri":"spotify:artist:4MzJMcHQBl9SIYSjwWn8QW"}],"disc_number":1,"duration_ms":283957,"explicit":false,"external_ids":{"isrc":"QMRSZ2301311"},"external_urls":{"spotify":"https://open.spotify.com/track/2GWtLHhqPjvZt1aWiBDsTU"},"href":"https://api.spotify.com/v1/tracks/2GWtLHhqPjvZt1aWiBDsTU","id":"2GWtLHhqPjvZt1aWiBDsTU","is_local":false,"is_playable":true,"name":"Cellar Door","track_number":1,"type":"track","uri":"spotify:track:2GWtLHhqPjvZt1aWiBDsTU"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7EWU4FhUJM1sZQgQKdENeT"},"href":"https://api.spotify.com/v1/artists/7EWU4FhUJM1sZQgQKdENeT","id":"7EWU4FhUJM1sZQgQKdENeT","name":"Hopsin","type":"artist","uri":"spotify:artist:7EWU4FhUJM1sZQgQKdENeT"}],"external_urls":{"spotify":"https://open.spotify.com/album/5kRhn7K8D7txVpIGGWfVCu"},"href":"https://api.spotify.com/v1/albums/5kRhn7K8D7txVpIGGWfVCu","id":"5kRhn7K8D7txVpIGGWfVCu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734f1dab8c832d312591947bf9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024f1dab8c832d312591947bf9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514f1dab8c832d312591947bf9"}],"is_playable":true,"name":"Ill Mind of Hopsin 5 - Single","release_date":"2012-07-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5kRhn7K8D7txVpIGGWfVCu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7EWU4FhUJM1sZQgQKdENeT"},"href":"https://api.spotify.com/v1/artists/7EWU4FhUJM1sZQgQKdENeT","id":"7EWU4FhUJM1sZQgQKdENeT","name":"Hopsin","type":"artist","uri":"spotify:artist:7EWU4FhUJM1sZQgQKdENeT"}],"disc_number":1,"duration_ms":289004,"explicit":true,"external_ids":{"isrc":"USUYG1019176"},"external_urls":{"spotify":"https://open.spotify.com/track/7dDLHlyZJBqEWSndlPWyCT"},"href":"https://api.spotify.com/v1/tracks/7dDLHlyZJBqEWSndlPWyCT","id":"7dDLHlyZJBqEWSndlPWyCT","is_local":false,"is_playable":true,"name":"Ill Mind of Hopsin 5","track_number":1,"type":"track","uri":"spotify:track:7dDLHlyZJBqEWSndlPWyCT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"}],"external_urls":{"spotify":"https://open.spotify.com/album/6seO2kGWhFKbe61aNvdB12"},"href":"https://api.spotify.com/v1/albums/6seO2kGWhFKbe61aNvdB12","id":"6seO2kGWhFKbe61aNvdB12","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfcd61a7e812238851963b32"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfcd61a7e812238851963b32"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfcd61a7e812238851963b32"}],"is_playable":true,"name":"Drug Dealers Anonymous","release_date":"2016-06-23","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6seO2kGWhFKbe61aNvdB12"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3nFkdlSjzX9mRTtwJOzDYB"},"href":"https://api.spotify.com/v1/artists/3nFkdlSjzX9mRTtwJOzDYB","id":"3nFkdlSjzX9mRTtwJOzDYB","name":"JA\u0178-Z","type":"artist","uri":"spotify:artist:3nFkdlSjzX9mRTtwJOzDYB"}],"disc_number":1,"duration_ms":253786,"explicit":true,"external_ids":{"isrc":"USUM71605133"},"external_urls":{"spotify":"https://open.spotify.com/track/1b6rmL3VXBgYTbn61kM8wT"},"href":"https://api.spotify.com/v1/tracks/1b6rmL3VXBgYTbn61kM8wT","id":"1b6rmL3VXBgYTbn61kM8wT","is_local":false,"is_playable":true,"name":"Drug Dealers Anonymous","track_number":1,"type":"track","uri":"spotify:track:1b6rmL3VXBgYTbn61kM8wT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"}],"external_urls":{"spotify":"https://open.spotify.com/album/3N7agGkKrdlEHBrzSDTNmG"},"href":"https://api.spotify.com/v1/albums/3N7agGkKrdlEHBrzSDTNmG","id":"3N7agGkKrdlEHBrzSDTNmG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735c403000feeddc6a725c0bd1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025c403000feeddc6a725c0bd1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515c403000feeddc6a725c0bd1"}],"is_playable":true,"name":"Malice 'N Wonderland","release_date":"2009-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:3N7agGkKrdlEHBrzSDTNmG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1W3FSF1BLpY3hlVIgvenLz"},"href":"https://api.spotify.com/v1/artists/1W3FSF1BLpY3hlVIgvenLz","id":"1W3FSF1BLpY3hlVIgvenLz","name":"THE-DREAM","type":"artist","uri":"spotify:artist:1W3FSF1BLpY3hlVIgvenLz"}],"disc_number":1,"duration_ms":256546,"explicit":true,"external_ids":{"isrc":"USCA20904839"},"external_urls":{"spotify":"https://open.spotify.com/track/1E8wif6bVXurUgxV8Gfwrw"},"href":"https://api.spotify.com/v1/tracks/1E8wif6bVXurUgxV8Gfwrw","id":"1E8wif6bVXurUgxV8Gfwrw","is_local":false,"is_playable":true,"name":"Gangsta Luv","track_number":6,"type":"track","uri":"spotify:track:1E8wif6bVXurUgxV8Gfwrw"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7otNm1oGn1kmJpFIZ3ts21"},"href":"https://api.spotify.com/v1/albums/7otNm1oGn1kmJpFIZ3ts21","id":"7otNm1oGn1kmJpFIZ3ts21","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734a382db9121b0722a768adba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024a382db9121b0722a768adba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514a382db9121b0722a768adba"}],"is_playable":true,"name":"Old School RnB","release_date":"2026-08-08","release_date_precision":"day","total_tracks":64,"type":"album","uri":"spotify:album:7otNm1oGn1kmJpFIZ3ts21"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1W3FSF1BLpY3hlVIgvenLz"},"href":"https://api.spotify.com/v1/artists/1W3FSF1BLpY3hlVIgvenLz","id":"1W3FSF1BLpY3hlVIgvenLz","name":"THE-DREAM","type":"artist","uri":"spotify:artist:1W3FSF1BLpY3hlVIgvenLz"}],"disc_number":1,"duration_ms":257133,"explicit":true,"external_ids":{"isrc":"USCA20904839"},"external_urls":{"spotify":"https://open.spotify.com/track/2ZxhxgA1CjNzG4mlI5M3Lm"},"href":"https://api.spotify.com/v1/tracks/2ZxhxgA1CjNzG4mlI5M3Lm","id":"2ZxhxgA1CjNzG4mlI5M3Lm","is_local":false,"is_playable":true,"name":"Gangsta Luv","track_number":45,"type":"track","uri":"spotify:track:2ZxhxgA1CjNzG4mlI5M3Lm"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3BQZ4iBTEt3weXvWVAihR3"},"href":"https://api.spotify.com/v1/albums/3BQZ4iBTEt3weXvWVAihR3","id":"3BQZ4iBTEt3weXvWVAihR3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738a9d2f67c71c87a5cbdb40b2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028a9d2f67c71c87a5cbdb40b2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518a9d2f67c71c87a5cbdb40b2"}],"is_playable":true,"name":"Hip Hop Club Banger","release_date":"2026-08-01","release_date_precision":"day","total_tracks":70,"type":"album","uri":"spotify:album:3BQZ4iBTEt3weXvWVAihR3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1W3FSF1BLpY3hlVIgvenLz"},"href":"https://api.spotify.com/v1/artists/1W3FSF1BLpY3hlVIgvenLz","id":"1W3FSF1BLpY3hlVIgvenLz","name":"THE-DREAM","type":"artist","uri":"spotify:artist:1W3FSF1BLpY3hlVIgvenLz"}],"disc_number":1,"duration_ms":257133,"explicit":true,"external_ids":{"isrc":"USCA20904839"},"external_urls":{"spotify":"https://open.spotify.com/track/287rQtNbV4NsBvlZmvJCRT"},"href":"https://api.spotify.com/v1/tracks/287rQtNbV4NsBvlZmvJCRT","id":"287rQtNbV4NsBvlZmvJCRT","is_local":false,"is_playable":true,"name":"Gangsta Luv","track_number":34,"type":"track","uri":"spotify:track:287rQtNbV4NsBvlZmvJCRT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7jnEJXIT7Ur1VLF1BC48eD"},"href":"https://api.spotify.com/v1/artists/7jnEJXIT7Ur1VLF1BC48eD","id":"7jnEJXIT7Ur1VLF1BC48eD","name":"My Boy Arlo","type":"artist","uri":"spotify:artist:7jnEJXIT7Ur1VLF1BC48eD"}],"external_urls":{"spotify":"https://open.spotify.com/album/0TMwChd09CEYj3qSyTofL1"},"href":"https://api.spotify.com/v1/albums/0TMwChd09CEYj3qSyTofL1","id":"0TMwChd09CEYj3qSyTofL1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731d0cd3b0e276e850909988ee"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021d0cd3b0e276e850909988ee"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511d0cd3b0e276e850909988ee"}],"is_playable":true,"name":"URL To Her Body","release_date":"2025-12-31","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0TMwChd09CEYj3qSyTofL1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7jnEJXIT7Ur1VLF1BC48eD"},"href":"https://api.spotify.com/v1/artists/7jnEJXIT7Ur1VLF1BC48eD","id":"7jnEJXIT7Ur1VLF1BC48eD","name":"My Boy Arlo","type":"artist","uri":"spotify:artist:7jnEJXIT7Ur1VLF1BC48eD"}],"disc_number":1,"duration_ms":216758,"explicit":false,"external_ids":{"isrc":"QZFYX2611590"},"external_urls":{"spotify":"https://open.spotify.com/track/3be5225YmWfELtUIQ6c6HA"},"href":"https://api.spotify.com/v1/tracks/3be5225YmWfELtUIQ6c6HA","id":"3be5225YmWfELtUIQ6c6HA","is_local":false,"is_playable":true,"name":"URL To Her Body","track_number":1,"type":"track","uri":"spotify:track:3be5225YmWfELtUIQ6c6HA"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Body+Loop+LSB&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "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" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Trouble+Kanine&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Cut%20Some%20Slack%20Bou&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Cut%20Some%20Slack%20Bou&type=track","offset":0,"previous":null,"total":13,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67FB4n52MgexGQIG8s0yUH"},"href":"https://api.spotify.com/v1/artists/67FB4n52MgexGQIG8s0yUH","id":"67FB4n52MgexGQIG8s0yUH","name":"Lola Young","type":"artist","uri":"spotify:artist:67FB4n52MgexGQIG8s0yUH"}],"external_urls":{"spotify":"https://open.spotify.com/album/2QWd1BsO7J0zLwxhsKl3zh"},"href":"https://api.spotify.com/v1/albums/2QWd1BsO7J0zLwxhsKl3zh","id":"2QWd1BsO7J0zLwxhsKl3zh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a0cb974834e04f46b63b99a8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a0cb974834e04f46b63b99a8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a0cb974834e04f46b63b99a8"}],"is_playable":true,"name":"Messy","release_date":"2024-05-30","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:2QWd1BsO7J0zLwxhsKl3zh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67FB4n52MgexGQIG8s0yUH"},"href":"https://api.spotify.com/v1/artists/67FB4n52MgexGQIG8s0yUH","id":"67FB4n52MgexGQIG8s0yUH","name":"Lola Young","type":"artist","uri":"spotify:artist:67FB4n52MgexGQIG8s0yUH"}],"disc_number":1,"duration_ms":284068,"explicit":true,"external_ids":{"isrc":"GBUM72401610"},"external_urls":{"spotify":"https://open.spotify.com/track/3SKH53SPQbEnZR4cJPVaz2"},"href":"https://api.spotify.com/v1/tracks/3SKH53SPQbEnZR4cJPVaz2","id":"3SKH53SPQbEnZR4cJPVaz2","is_local":false,"is_playable":true,"name":"Messy","track_number":1,"type":"track","uri":"spotify:track:3SKH53SPQbEnZR4cJPVaz2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6iWuBN32BqCJAeXW6o3nil"},"href":"https://api.spotify.com/v1/artists/6iWuBN32BqCJAeXW6o3nil","id":"6iWuBN32BqCJAeXW6o3nil","name":"Cautious Clay","type":"artist","uri":"spotify:artist:6iWuBN32BqCJAeXW6o3nil"}],"external_urls":{"spotify":"https://open.spotify.com/album/4UEIfM6VbbjiSVUwPFXWxO"},"href":"https://api.spotify.com/v1/albums/4UEIfM6VbbjiSVUwPFXWxO","id":"4UEIfM6VbbjiSVUwPFXWxO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732ebe302e3bfa10374627fb5d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022ebe302e3bfa10374627fb5d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512ebe302e3bfa10374627fb5d"}],"is_playable":true,"name":"Deadpan Love","release_date":"2021-06-25","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4UEIfM6VbbjiSVUwPFXWxO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6iWuBN32BqCJAeXW6o3nil"},"href":"https://api.spotify.com/v1/artists/6iWuBN32BqCJAeXW6o3nil","id":"6iWuBN32BqCJAeXW6o3nil","name":"Cautious Clay","type":"artist","uri":"spotify:artist:6iWuBN32BqCJAeXW6o3nil"}],"disc_number":1,"duration_ms":139300,"explicit":false,"external_ids":{"isrc":"QMBZ92039009"},"external_urls":{"spotify":"https://open.spotify.com/track/2X9rXokp9vKzPcMBa5BY5Y"},"href":"https://api.spotify.com/v1/tracks/2X9rXokp9vKzPcMBa5BY5Y","id":"2X9rXokp9vKzPcMBa5BY5Y","is_local":false,"is_playable":true,"name":"Dying In The Subtlety","track_number":7,"type":"track","uri":"spotify:track:2X9rXokp9vKzPcMBa5BY5Y"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67FB4n52MgexGQIG8s0yUH"},"href":"https://api.spotify.com/v1/artists/67FB4n52MgexGQIG8s0yUH","id":"67FB4n52MgexGQIG8s0yUH","name":"Lola Young","type":"artist","uri":"spotify:artist:67FB4n52MgexGQIG8s0yUH"}],"external_urls":{"spotify":"https://open.spotify.com/album/3uTpTaMOynCYKV5AtgeO2U"},"href":"https://api.spotify.com/v1/albums/3uTpTaMOynCYKV5AtgeO2U","id":"3uTpTaMOynCYKV5AtgeO2U","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736aa2a180c7b009ca8454ef89"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026aa2a180c7b009ca8454ef89"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516aa2a180c7b009ca8454ef89"}],"is_playable":true,"name":"This Wasn't Meant For You Anyway","release_date":"2024-06-21","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:3uTpTaMOynCYKV5AtgeO2U"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67FB4n52MgexGQIG8s0yUH"},"href":"https://api.spotify.com/v1/artists/67FB4n52MgexGQIG8s0yUH","id":"67FB4n52MgexGQIG8s0yUH","name":"Lola Young","type":"artist","uri":"spotify:artist:67FB4n52MgexGQIG8s0yUH"}],"disc_number":1,"duration_ms":284066,"explicit":true,"external_ids":{"isrc":"GBUM72401610"},"external_urls":{"spotify":"https://open.spotify.com/track/35ISBknsCeZQtq66xABI9g"},"href":"https://api.spotify.com/v1/tracks/35ISBknsCeZQtq66xABI9g","id":"35ISBknsCeZQtq66xABI9g","is_local":false,"is_playable":true,"name":"Messy","track_number":5,"type":"track","uri":"spotify:track:35ISBknsCeZQtq66xABI9g"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67FB4n52MgexGQIG8s0yUH"},"href":"https://api.spotify.com/v1/artists/67FB4n52MgexGQIG8s0yUH","id":"67FB4n52MgexGQIG8s0yUH","name":"Lola Young","type":"artist","uri":"spotify:artist:67FB4n52MgexGQIG8s0yUH"}],"external_urls":{"spotify":"https://open.spotify.com/album/4bCcQKDKI3gHZNqA1ZIBnh"},"href":"https://api.spotify.com/v1/albums/4bCcQKDKI3gHZNqA1ZIBnh","id":"4bCcQKDKI3gHZNqA1ZIBnh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737a017c32f729067bc47b83e4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027a017c32f729067bc47b83e4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517a017c32f729067bc47b83e4"}],"is_playable":true,"name":"Messy","release_date":"2024-05-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4bCcQKDKI3gHZNqA1ZIBnh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67FB4n52MgexGQIG8s0yUH"},"href":"https://api.spotify.com/v1/artists/67FB4n52MgexGQIG8s0yUH","id":"67FB4n52MgexGQIG8s0yUH","name":"Lola Young","type":"artist","uri":"spotify:artist:67FB4n52MgexGQIG8s0yUH"}],"disc_number":1,"duration_ms":284068,"explicit":false,"external_ids":{"isrc":"GBUM72402815"},"external_urls":{"spotify":"https://open.spotify.com/track/2YuUy4hBCVm4L5IRHu0iVl"},"href":"https://api.spotify.com/v1/tracks/2YuUy4hBCVm4L5IRHu0iVl","id":"2YuUy4hBCVm4L5IRHu0iVl","is_local":false,"is_playable":true,"name":"Messy","track_number":1,"type":"track","uri":"spotify:track:2YuUy4hBCVm4L5IRHu0iVl"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CmaKO2zEGJ1NWpS1yfVGz"},"href":"https://api.spotify.com/v1/artists/2CmaKO2zEGJ1NWpS1yfVGz","id":"2CmaKO2zEGJ1NWpS1yfVGz","name":"Falling In Reverse","type":"artist","uri":"spotify:artist:2CmaKO2zEGJ1NWpS1yfVGz"}],"external_urls":{"spotify":"https://open.spotify.com/album/2knEuvsxqHMAoxlQpIdpQD"},"href":"https://api.spotify.com/v1/albums/2knEuvsxqHMAoxlQpIdpQD","id":"2knEuvsxqHMAoxlQpIdpQD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cd850819595472eae0c06f66"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cd850819595472eae0c06f66"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cd850819595472eae0c06f66"}],"is_playable":true,"name":"Popular Monster","release_date":"2024-08-16","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:2knEuvsxqHMAoxlQpIdpQD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CmaKO2zEGJ1NWpS1yfVGz"},"href":"https://api.spotify.com/v1/artists/2CmaKO2zEGJ1NWpS1yfVGz","id":"2CmaKO2zEGJ1NWpS1yfVGz","name":"Falling In Reverse","type":"artist","uri":"spotify:artist:2CmaKO2zEGJ1NWpS1yfVGz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/19k8AgwwTSxeaxkOuCQEJs"},"href":"https://api.spotify.com/v1/artists/19k8AgwwTSxeaxkOuCQEJs","id":"19k8AgwwTSxeaxkOuCQEJs","name":"Jelly Roll","type":"artist","uri":"spotify:artist:19k8AgwwTSxeaxkOuCQEJs"}],"disc_number":1,"duration_ms":190230,"explicit":true,"external_ids":{"isrc":"USEP42414005"},"external_urls":{"spotify":"https://open.spotify.com/track/19CCQeIOxxUDcpFw539zd7"},"href":"https://api.spotify.com/v1/tracks/19CCQeIOxxUDcpFw539zd7","id":"19CCQeIOxxUDcpFw539zd7","is_local":false,"is_playable":true,"name":"All My Life","track_number":3,"type":"track","uri":"spotify:track:19CCQeIOxxUDcpFw539zd7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7pBMkMtBoc5eFPNNRYkPUm"},"href":"https://api.spotify.com/v1/artists/7pBMkMtBoc5eFPNNRYkPUm","id":"7pBMkMtBoc5eFPNNRYkPUm","name":"Salem Slut","type":"artist","uri":"spotify:artist:7pBMkMtBoc5eFPNNRYkPUm"}],"external_urls":{"spotify":"https://open.spotify.com/album/0kM6ZiN4DkQDdJ1EYVVzmB"},"href":"https://api.spotify.com/v1/albums/0kM6ZiN4DkQDdJ1EYVVzmB","id":"0kM6ZiN4DkQDdJ1EYVVzmB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27372cf97042345effb488ca8e0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0272cf97042345effb488ca8e0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485172cf97042345effb488ca8e0"}],"is_playable":true,"name":"Effed Up Jeans","release_date":"2026-04-13","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0kM6ZiN4DkQDdJ1EYVVzmB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7pBMkMtBoc5eFPNNRYkPUm"},"href":"https://api.spotify.com/v1/artists/7pBMkMtBoc5eFPNNRYkPUm","id":"7pBMkMtBoc5eFPNNRYkPUm","name":"Salem Slut","type":"artist","uri":"spotify:artist:7pBMkMtBoc5eFPNNRYkPUm"}],"disc_number":1,"duration_ms":149885,"explicit":false,"external_ids":{"isrc":"UKACT2692787"},"external_urls":{"spotify":"https://open.spotify.com/track/2fy4lMuI4lYMH4yLMgvzrR"},"href":"https://api.spotify.com/v1/tracks/2fy4lMuI4lYMH4yLMgvzrR","id":"2fy4lMuI4lYMH4yLMgvzrR","is_local":false,"is_playable":true,"name":"Effed Up Jeans","track_number":1,"type":"track","uri":"spotify:track:2fy4lMuI4lYMH4yLMgvzrR"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6iWuBN32BqCJAeXW6o3nil"},"href":"https://api.spotify.com/v1/artists/6iWuBN32BqCJAeXW6o3nil","id":"6iWuBN32BqCJAeXW6o3nil","name":"Cautious Clay","type":"artist","uri":"spotify:artist:6iWuBN32BqCJAeXW6o3nil"}],"external_urls":{"spotify":"https://open.spotify.com/album/6VYcP2lHJRnhIH1BLbNRG6"},"href":"https://api.spotify.com/v1/albums/6VYcP2lHJRnhIH1BLbNRG6","id":"6VYcP2lHJRnhIH1BLbNRG6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27308c040d0de86b29c4b3829ce"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0208c040d0de86b29c4b3829ce"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485108c040d0de86b29c4b3829ce"}],"is_playable":true,"name":"Deadpan Love (Deluxe)","release_date":"2021-06-25","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:6VYcP2lHJRnhIH1BLbNRG6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6iWuBN32BqCJAeXW6o3nil"},"href":"https://api.spotify.com/v1/artists/6iWuBN32BqCJAeXW6o3nil","id":"6iWuBN32BqCJAeXW6o3nil","name":"Cautious Clay","type":"artist","uri":"spotify:artist:6iWuBN32BqCJAeXW6o3nil"}],"disc_number":1,"duration_ms":139300,"explicit":false,"external_ids":{"isrc":"QMBZ92039009"},"external_urls":{"spotify":"https://open.spotify.com/track/7vKpXZaso9LvRVs5IRvnh6"},"href":"https://api.spotify.com/v1/tracks/7vKpXZaso9LvRVs5IRvnh6","id":"7vKpXZaso9LvRVs5IRvnh6","is_local":false,"is_playable":true,"name":"Dying In The Subtlety","track_number":7,"type":"track","uri":"spotify:track:7vKpXZaso9LvRVs5IRvnh6"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4gdZrXpeqBio4Ri2ABrM7X"},"href":"https://api.spotify.com/v1/albums/4gdZrXpeqBio4Ri2ABrM7X","id":"4gdZrXpeqBio4Ri2ABrM7X","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734a55eddde8784ca014a73bfd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024a55eddde8784ca014a73bfd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514a55eddde8784ca014a73bfd"}],"is_playable":true,"name":"Cero Skips","release_date":"2026-08-07","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:4gdZrXpeqBio4Ri2ABrM7X"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67FB4n52MgexGQIG8s0yUH"},"href":"https://api.spotify.com/v1/artists/67FB4n52MgexGQIG8s0yUH","id":"67FB4n52MgexGQIG8s0yUH","name":"Lola Young","type":"artist","uri":"spotify:artist:67FB4n52MgexGQIG8s0yUH"}],"disc_number":1,"duration_ms":284068,"explicit":true,"external_ids":{"isrc":"GBUM72401610"},"external_urls":{"spotify":"https://open.spotify.com/track/03FE0CV8hZW21Fv2Wh50hN"},"href":"https://api.spotify.com/v1/tracks/03FE0CV8hZW21Fv2Wh50hN","id":"03FE0CV8hZW21Fv2Wh50hN","is_local":false,"is_playable":true,"name":"Messy","track_number":2,"type":"track","uri":"spotify:track:03FE0CV8hZW21Fv2Wh50hN"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0WHZne2taTnKv2WuS88pTi"},"href":"https://api.spotify.com/v1/albums/0WHZne2taTnKv2WuS88pTi","id":"0WHZne2taTnKv2WuS88pTi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273843b2a3506d299e3a28de16e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02843b2a3506d299e3a28de16e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851843b2a3506d299e3a28de16e"}],"is_playable":true,"name":"Die besten Songs 2026","release_date":"2026-08-07","release_date_precision":"day","total_tracks":66,"type":"album","uri":"spotify:album:0WHZne2taTnKv2WuS88pTi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67FB4n52MgexGQIG8s0yUH"},"href":"https://api.spotify.com/v1/artists/67FB4n52MgexGQIG8s0yUH","id":"67FB4n52MgexGQIG8s0yUH","name":"Lola Young","type":"artist","uri":"spotify:artist:67FB4n52MgexGQIG8s0yUH"}],"disc_number":1,"duration_ms":284068,"explicit":true,"external_ids":{"isrc":"GBUM72401610"},"external_urls":{"spotify":"https://open.spotify.com/track/1zKebHBrBj0IOzRiYSQ6jR"},"href":"https://api.spotify.com/v1/tracks/1zKebHBrBj0IOzRiYSQ6jR","id":"1zKebHBrBj0IOzRiYSQ6jR","is_local":false,"is_playable":true,"name":"Messy","track_number":28,"type":"track","uri":"spotify:track:1zKebHBrBj0IOzRiYSQ6jR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7HyV0VUAtVPDvZ9th9uCkO"},"href":"https://api.spotify.com/v1/albums/7HyV0VUAtVPDvZ9th9uCkO","id":"7HyV0VUAtVPDvZ9th9uCkO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27300e4331a5b0ec9699d86b8f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0200e4331a5b0ec9699d86b8f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485100e4331a5b0ec9699d86b8f5"}],"is_playable":true,"name":"London Vibes","release_date":"2026-07-31","release_date_precision":"day","total_tracks":57,"type":"album","uri":"spotify:album:7HyV0VUAtVPDvZ9th9uCkO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67FB4n52MgexGQIG8s0yUH"},"href":"https://api.spotify.com/v1/artists/67FB4n52MgexGQIG8s0yUH","id":"67FB4n52MgexGQIG8s0yUH","name":"Lola Young","type":"artist","uri":"spotify:artist:67FB4n52MgexGQIG8s0yUH"}],"disc_number":1,"duration_ms":284068,"explicit":true,"external_ids":{"isrc":"GBUM72401610"},"external_urls":{"spotify":"https://open.spotify.com/track/6iowIcuwFvdMwpnjHGCgn9"},"href":"https://api.spotify.com/v1/tracks/6iowIcuwFvdMwpnjHGCgn9","id":"6iowIcuwFvdMwpnjHGCgn9","is_local":false,"is_playable":true,"name":"Messy","track_number":6,"type":"track","uri":"spotify:track:6iowIcuwFvdMwpnjHGCgn9"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1DdXQlMjBTb21lJTIwU2xhY2slMjBCb3UmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MTAmbGltaXQ9MTAmcXVlcnk9Q3V0JTIwU29tZSUyMFNsYWNrJTIwQm91JnR5cGU9dHJhY2siLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MTMsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82N0ZCNG41Mk1nZXhHUUlHOHMweVVIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY3RkI0bjUyTWdleEdRSUc4czB5VUgiLCJpZCI6IjY3RkI0bjUyTWdleEdRSUc4czB5VUgiLCJuYW1lIjoiTG9sYSBZb3VuZyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2N0ZCNG41Mk1nZXhHUUlHOHMweVVIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlFXZDFCc083SjB6THd4aHNLbDN6aCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJRV2QxQnNPN0owekx3eGhzS2wzemgiLCJpZCI6IjJRV2QxQnNPN0owekx3eGhzS2wzemgi", + "LCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTBjYjk3NDgzNGUwNGY0NmI2M2I5OWE4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEwY2I5NzQ4MzRlMDRmNDZiNjNiOTlhOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTBjYjk3NDgzNGUwNGY0NmI2M2I5OWE4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1lc3N5IiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wNS0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MlFXZDFCc083SjB6THd4aHNLbDN6aCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY3RkI0bjUyTWdleEdRSUc4czB5VUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCIsImlkIjoiNjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCIsIm5hbWUiOiJMb2xhIFlvdW5nIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjY3RkI0bjUyTWdleEdRSUc4czB5VUgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjg0MDY4LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlVNNzI0MDE2MTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNTS0g1M1NQUWJFblpSNGNKUFZhejIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zU0tINTNTUFFiRW5aUjRjSlBWYXoyIiwiaWQiOiIzU0tINTNTUFFiRW5aUjRjSlBWYXoyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1lc3N5IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNTS0g1M1NQUWJFblpSNGNKUFZhejIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmlXdUJOMzJCcUNKQWVYVzZvM25pbCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82aVd1Qk4zMkJxQ0pBZVhXNm8zbmlsIiwiaWQiOiI2aVd1Qk4zMkJxQ0pBZVhXNg==", + "bzNuaWwiLCJuYW1lIjoiQ2F1dGlvdXMgQ2xheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2aVd1Qk4zMkJxQ0pBZVhXNm8zbmlsIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFVFSWZNNlZiYmppU1ZVd1BGWFd4TyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRVRUlmTTZWYmJqaVNWVXdQRlhXeE8iLCJpZCI6IjRVRUlmTTZWYmJqaVNWVXdQRlhXeE8iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMmViZTMwMmUzYmZhMTAzNzQ2MjdmYjVkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjJlYmUzMDJlM2JmYTEwMzc0NjI3ZmI1ZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMmViZTMwMmUzYmZhMTAzNzQ2MjdmYjVkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlYWRwYW4gTG92ZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDYtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0VUVJZk02VmJiamlTVlV3UEZYV3hPIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmlXdUJOMzJCcUNKQWVYVzZvM25pbCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82aVd1Qk4zMkJxQ0pBZVhXNm8zbmlsIiwiaWQiOiI2aVd1Qk4zMkJxQ0pBZVhXNm8zbmlsIiwibmFtZSI6IkNhdXRpb3VzIENsYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NmlXdUJOMzJCcUNKQWVYVzZvM25pbCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxMzkzMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRTUJaOTIwMzkwMDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJYOXJYb2twOXZLelBjTUJhNUJZNVkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yWDlyWG9rcDl2S3pQY01CYTVCWTVZIiwiaWQiOiIyWDlyWG9rcDl2S3pQY01CYTVCWTVZIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkR5aW5nIEluIFRoZSBTdWJ0bA==", + "ZXR5IiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJYOXJYb2twOXZLelBjTUJhNUJZNVkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82N0ZCNG41Mk1nZXhHUUlHOHMweVVIIiwiaWQiOiI2N0ZCNG41Mk1nZXhHUUlHOHMweVVIIiwibmFtZSI6IkxvbGEgWW91bmciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzN1VHBUYU1PeW5DWUtWNUF0Z2VPMlUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zdVRwVGFNT3luQ1lLVjVBdGdlTzJVIiwiaWQiOiIzdVRwVGFNT3luQ1lLVjVBdGdlTzJVIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZhYTJhMTgwYzdiMDA5Y2E4NDU0ZWY4OSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2YWEyYTE4MGM3YjAwOWNhODQ1NGVmODkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZhYTJhMTgwYzdiMDA5Y2E4NDU0ZWY4OSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGlzIFdhc24ndCBNZWFudCBGb3IgWW91IEFueXdheSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDYtMjEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozdVRwVGFNT3luQ1lLVjVBdGdlTzJVIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82N0ZCNG41Mk1nZXhHUUlHOHMweVVIIiwiaWQiOiI2N0ZCNG41Mk1nZXhHUUlHOHMweVVIIiwibmFtZSI6IkxvbGEgWW91bmciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cg==", + "YXRpb25fbXMiOjI4NDA2NiwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JVTTcyNDAxNjEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zNUlTQmtuc0NlWlF0cTY2eEFCSTlnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzVJU0JrbnNDZVpRdHE2NnhBQkk5ZyIsImlkIjoiMzVJU0JrbnNDZVpRdHE2NnhBQkk5ZyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNZXNzeSIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozNUlTQmtuc0NlWlF0cTY2eEFCSTlnIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82N0ZCNG41Mk1nZXhHUUlHOHMweVVIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY3RkI0bjUyTWdleEdRSUc4czB5VUgiLCJpZCI6IjY3RkI0bjUyTWdleEdRSUc4czB5VUgiLCJuYW1lIjoiTG9sYSBZb3VuZyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2N0ZCNG41Mk1nZXhHUUlHOHMweVVIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNGJDY1FLREtJM2dIWk5xQTFaSUJuaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRiQ2NRS0RLSTNnSFpOcUExWklCbmgiLCJpZCI6IjRiQ2NRS0RLSTNnSFpOcUExWklCbmgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2EwMTdjMzJmNzI5MDY3YmM0N2I4M2U0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdhMDE3YzMyZjcyOTA2N2JjNDdiODNlNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2EwMTdjMzJmNzI5MDY3YmM0N2I4M2U0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1lc3N5IiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wNS0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NGJDY1FLREtJM2dIWk5xQTFaSUJuaCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIg==", + "Onsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82N0ZCNG41Mk1nZXhHUUlHOHMweVVIIiwiaWQiOiI2N0ZCNG41Mk1nZXhHUUlHOHMweVVIIiwibmFtZSI6IkxvbGEgWW91bmciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyODQwNjgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlVNNzI0MDI4MTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJZdVV5NGhCQ1ZtNEw1SVJIdTBpVmwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yWXVVeTRoQkNWbTRMNUlSSHUwaVZsIiwiaWQiOiIyWXVVeTRoQkNWbTRMNUlSSHUwaVZsIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1lc3N5IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJZdVV5NGhCQ1ZtNEw1SVJIdTBpVmwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkNtYUtPMnpFR0oxTldwUzF5ZlZHeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQ21hS08yekVHSjFOV3BTMXlmVkd6IiwiaWQiOiIyQ21hS08yekVHSjFOV3BTMXlmVkd6IiwibmFtZSI6IkZhbGxpbmcgSW4gUmV2ZXJzZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQ21hS08yekVHSjFOV3BTMXlmVkd6In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMmtuRXV2c3hxSE1Bb3hsUXBJZHBRRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJrbkV1dnN4cUhNQW94bFFwSWRwUUQiLCJpZCI6IjJrbkV1dnN4cUhNQW94bFFwSWRwUUQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczY2Q4NTA4MTk1OTU0NzJlYWUwYzA2ZjY2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmNkODUwODE5NTk1NDcyZWFlMGMwNmY2NiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdA==", + "aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjZDg1MDgxOTU5NTQ3MmVhZTBjMDZmNjYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUG9wdWxhciBNb25zdGVyIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wOC0xNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJrbkV1dnN4cUhNQW94bFFwSWRwUUQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQ21hS08yekVHSjFOV3BTMXlmVkd6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJDbWFLTzJ6RUdKMU5XcFMxeWZWR3oiLCJpZCI6IjJDbWFLTzJ6RUdKMU5XcFMxeWZWR3oiLCJuYW1lIjoiRmFsbGluZyBJbiBSZXZlcnNlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJDbWFLTzJ6RUdKMU5XcFMxeWZWR3oifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTlrOEFnd3dUU3hlYXhrT3VDUUVKcyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xOWs4QWd3d1RTeGVheGtPdUNRRUpzIiwiaWQiOiIxOWs4QWd3d1RTeGVheGtPdUNRRUpzIiwibmFtZSI6IkplbGx5IFJvbGwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTlrOEFnd3dUU3hlYXhrT3VDUUVKcyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTAyMzAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRVA0MjQxNDAwNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMTlDQ1FlSU94eFVEY3BGdzUzOXpkNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzE5Q0NRZUlPeHhVRGNwRnc1Mzl6ZDciLCJpZCI6IjE5Q0NRZUlPeHhVRGNwRnc1Mzl6ZDciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWxsIE15IExpZmUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MTlDQ1FlSU94eFVEY3BGdzUzOXpkNyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3BCTWtNdEJvYzVlRlBOTlJZa1BVbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeQ==", + "LmNvbS92MS9hcnRpc3RzLzdwQk1rTXRCb2M1ZUZQTk5SWWtQVW0iLCJpZCI6IjdwQk1rTXRCb2M1ZUZQTk5SWWtQVW0iLCJuYW1lIjoiU2FsZW0gU2x1dCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3cEJNa010Qm9jNWVGUE5OUllrUFVtIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMGtNNlppTjREa1FEZEoxRVlWVnptQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBrTTZaaU40RGtRRGRKMUVZVlZ6bUIiLCJpZCI6IjBrTTZaaU40RGtRRGRKMUVZVlZ6bUIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzJjZjk3MDQyMzQ1ZWZmYjQ4OGNhOGUwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjcyY2Y5NzA0MjM0NWVmZmI0ODhjYThlMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzJjZjk3MDQyMzQ1ZWZmYjQ4OGNhOGUwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVmZmVkIFVwIEplYW5zIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNC0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MGtNNlppTjREa1FEZEoxRVlWVnptQiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdwQk1rTXRCb2M1ZUZQTk5SWWtQVW0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3BCTWtNdEJvYzVlRlBOTlJZa1BVbSIsImlkIjoiN3BCTWtNdEJvYzVlRlBOTlJZa1BVbSIsIm5hbWUiOiJTYWxlbSBTbHV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdwQk1rTXRCb2M1ZUZQTk5SWWtQVW0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQ5ODg1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVUtBQ1QyNjkyNzg3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yZnk0bE11STRsWU1INHlMTWd2enJSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMmZ5NGxNdUk0bFlNSDR5TE1ndnpyUiIsImlkIjoiMmZ5NGxNdUk0bFlNSDR5TE1ndnpyUiIsImlzXw==", + "bG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVmZmVkIFVwIEplYW5zIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJmeTRsTXVJNGxZTUg0eUxNZ3Z6clIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmlXdUJOMzJCcUNKQWVYVzZvM25pbCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82aVd1Qk4zMkJxQ0pBZVhXNm8zbmlsIiwiaWQiOiI2aVd1Qk4zMkJxQ0pBZVhXNm8zbmlsIiwibmFtZSI6IkNhdXRpb3VzIENsYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NmlXdUJOMzJCcUNKQWVYVzZvM25pbCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZWWWNQMmxISlJuaElIMUJMYk5SRzYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82VlljUDJsSEpSbmhJSDFCTGJOUkc2IiwiaWQiOiI2VlljUDJsSEpSbmhJSDFCTGJOUkc2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzA4YzA0MGQwZGU4NmIyOWM0YjM4MjljZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwOGMwNDBkMGRlODZiMjljNGIzODI5Y2UifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTA4YzA0MGQwZGU4NmIyOWM0YjM4MjljZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZWFkcGFuIExvdmUgKERlbHV4ZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTA2LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlZZY1AybEhKUm5oSUgxQkxiTlJHNiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZpV3VCTjMyQnFDSkFlWFc2bzNuaWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmlXdUJOMzJCcUNKQWVYVzZvM25pbCIsImlkIjoiNmlXdUJOMzJCcUNKQWVYVzZvM25pbCIsIm5hbWUiOiJDYXV0aW91cyBDbGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Og==", + "NmlXdUJOMzJCcUNKQWVYVzZvM25pbCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxMzkzMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRTUJaOTIwMzkwMDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzd2S3BYWmFzbzlMdlJWczVJUnZuaDYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83dktwWFphc285THZSVnM1SVJ2bmg2IiwiaWQiOiI3dktwWFphc285THZSVnM1SVJ2bmg2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkR5aW5nIEluIFRoZSBTdWJ0bGV0eSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3dktwWFphc285THZSVnM1SVJ2bmg2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRnZFpyWHBlcUJpbzRSaTJBQnJNN1gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80Z2RaclhwZXFCaW80UmkyQUJyTTdYIiwiaWQiOiI0Z2RaclhwZXFCaW80UmkyQUJyTTdYIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRhNTVlZGRkZTg3ODRjYTAxNGE3M2JmZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0YTU1ZWRkZGU4Nzg0Y2EwMTRhNzNiZmQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRhNTVlZGRkZTg3ODRjYTAxNGE3M2JmZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDZXJvIFNraXBzIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wOC0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMzLCJ0eXBlIjoiYQ==", + "bGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NGdkWnJYcGVxQmlvNFJpMkFCck03WCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY3RkI0bjUyTWdleEdRSUc4czB5VUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCIsImlkIjoiNjdGQjRuNTJNZ2V4R1FJRzhzMHlVSCIsIm5hbWUiOiJMb2xhIFlvdW5nIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjY3RkI0bjUyTWdleEdRSUc4czB5VUgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjg0MDY4LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlVNNzI0MDE2MTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzAzRkUwQ1Y4aFpXMjFGdjJXaDUwaE4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wM0ZFMENWOGhaVzIxRnYyV2g1MGhOIiwiaWQiOiIwM0ZFMENWOGhaVzIxRnYyV2g1MGhOIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1lc3N5IiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjAzRkUwQ1Y4aFpXMjFGdjJXaDUwaE4ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMFdIWm5lMnRhVG5LdjJXdVM4OHBUaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBXSFpuZTJ0YVRuS3YyV3VTODhwVGkiLCJpZCI6IjBXSFpuZTJ0YVRuS3YyV3VTODhwVGkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODQzYjJhMzUwNmQyOTllM2EyOGRlMTZlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cA==", + "czovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODQzYjJhMzUwNmQyOTllM2EyOGRlMTZlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4NDNiMmEzNTA2ZDI5OWUzYTI4ZGUxNmUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGllIGJlc3RlbiBTb25ncyAyMDI2IiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wOC0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjY2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBXSFpuZTJ0YVRuS3YyV3VTODhwVGkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82N0ZCNG41Mk1nZXhHUUlHOHMweVVIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY3RkI0bjUyTWdleEdRSUc4czB5VUgiLCJpZCI6IjY3RkI0bjUyTWdleEdRSUc4czB5VUgiLCJuYW1lIjoiTG9sYSBZb3VuZyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2N0ZCNG41Mk1nZXhHUUlHOHMweVVIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI4NDA2OCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JVTTcyNDAxNjEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xektlYkhCckJqMElPelJpWVNRNmpSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMXpLZWJIQnJCajBJT3pSaVlTUTZqUiIsImlkIjoiMXpLZWJIQnJCajBJT3pSaVlTUTZqUiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNZXNzeSIsInRyYWNrX251bWJlciI6MjgsInR5cGUi", + "OiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXpLZWJIQnJCajBJT3pSaVlTUTZqUiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83SHlWMFZVQXRWUER2Wjl0aDl1Q2tPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0h5VjBWVUF0VlBEdlo5dGg5dUNrTyIsImlkIjoiN0h5VjBWVUF0VlBEdlo5dGg5dUNrTyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwMGU0MzMxYTViMGVjOTY5OWQ4NmI4ZjUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDBlNDMzMWE1YjBlYzk2OTlkODZiOGY1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwMGU0MzMxYTViMGVjOTY5OWQ4NmI4ZjUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTG9uZG9uIFZpYmVzIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNy0zMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjU3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdIeVYwVlVBdFZQRHZaOXRoOXVDa08ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82N0ZCNG41Mk1nZXhHUUlHOHMweVVIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY3RkI0bjUyTWdleEdRSUc4czB5VUgiLCJpZCI6IjY3RkI0bjUyTWdleEdRSUc4czB5VUgiLCJuYW1lIjoiTG9sYSBZb3VuZyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2N0ZCNG41Mk1nZXhHUUlHOHMweVVIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI4NDA2OCwiZXhwbGljaXQiOnRydWUsImV4dA==", + "ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlVNNzI0MDE2MTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZpb3dJY3V3RnZkTXdwbmpIR0NnbjkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82aW93SWN1d0Z2ZE13cG5qSEdDZ245IiwiaWQiOiI2aW93SWN1d0Z2ZE13cG5qSEdDZ245IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1lc3N5IiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZpb3dJY3V3RnZkTXdwbmpIR0NnbjkifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Cut+Some+Slack+Bou&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Warehouse%20Project%20Etherwood&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Warehouse%20Project%20Etherwood&type=track","offset":0,"previous":null,"total":13,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QiGMkoYvzzIiDuDCIt2Ci"},"href":"https://api.spotify.com/v1/artists/0QiGMkoYvzzIiDuDCIt2Ci","id":"0QiGMkoYvzzIiDuDCIt2Ci","name":"Douglas Gregory","type":"artist","uri":"spotify:artist:0QiGMkoYvzzIiDuDCIt2Ci"}],"external_urls":{"spotify":"https://open.spotify.com/album/2JPweucsoxRMZwoh7EdClx"},"href":"https://api.spotify.com/v1/albums/2JPweucsoxRMZwoh7EdClx","id":"2JPweucsoxRMZwoh7EdClx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e9a713bf71711b2b9935f076"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e9a713bf71711b2b9935f076"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e9a713bf71711b2b9935f076"}],"is_playable":true,"name":"Candle Girl","release_date":"2024-03-02","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2JPweucsoxRMZwoh7EdClx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QiGMkoYvzzIiDuDCIt2Ci"},"href":"https://api.spotify.com/v1/artists/0QiGMkoYvzzIiDuDCIt2Ci","id":"0QiGMkoYvzzIiDuDCIt2Ci","name":"Douglas Gregory","type":"artist","uri":"spotify:artist:0QiGMkoYvzzIiDuDCIt2Ci"}],"disc_number":1,"duration_ms":173549,"explicit":false,"external_ids":{"isrc":"QZZ972413815"},"external_urls":{"spotify":"https://open.spotify.com/track/4P6I7s0fIV5juIt1IfI5kN"},"href":"https://api.spotify.com/v1/tracks/4P6I7s0fIV5juIt1IfI5kN","id":"4P6I7s0fIV5juIt1IfI5kN","is_local":false,"is_playable":true,"name":"Candle Girl","track_number":1,"type":"track","uri":"spotify:track:4P6I7s0fIV5juIt1IfI5kN"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2f8YeRDSJhmeSIPEbMQ28L"},"href":"https://api.spotify.com/v1/artists/2f8YeRDSJhmeSIPEbMQ28L","id":"2f8YeRDSJhmeSIPEbMQ28L","name":"SNOWMEN","type":"artist","uri":"spotify:artist:2f8YeRDSJhmeSIPEbMQ28L"}],"external_urls":{"spotify":"https://open.spotify.com/album/1Q6P3zms3Ajm76B5qf8IMd"},"href":"https://api.spotify.com/v1/albums/1Q6P3zms3Ajm76B5qf8IMd","id":"1Q6P3zms3Ajm76B5qf8IMd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f7c1598012b2987734c2b212"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f7c1598012b2987734c2b212"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f7c1598012b2987734c2b212"}],"is_playable":true,"name":"Make Time/Waste Time","release_date":"2025-09-12","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:1Q6P3zms3Ajm76B5qf8IMd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2f8YeRDSJhmeSIPEbMQ28L"},"href":"https://api.spotify.com/v1/artists/2f8YeRDSJhmeSIPEbMQ28L","id":"2f8YeRDSJhmeSIPEbMQ28L","name":"SNOWMEN","type":"artist","uri":"spotify:artist:2f8YeRDSJhmeSIPEbMQ28L"}],"disc_number":1,"duration_ms":208520,"explicit":false,"external_ids":{"isrc":"QMDA72520945"},"external_urls":{"spotify":"https://open.spotify.com/track/3xi3Zcjwl4LOpOD4Spgms4"},"href":"https://api.spotify.com/v1/tracks/3xi3Zcjwl4LOpOD4Spgms4","id":"3xi3Zcjwl4LOpOD4Spgms4","is_local":false,"is_playable":true,"name":"Make Time/Waste Time","track_number":1,"type":"track","uri":"spotify:track:3xi3Zcjwl4LOpOD4Spgms4"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7ccAcGF30fCIXm9pahSUum"},"href":"https://api.spotify.com/v1/artists/7ccAcGF30fCIXm9pahSUum","id":"7ccAcGF30fCIXm9pahSUum","name":"Rubbeni","type":"artist","uri":"spotify:artist:7ccAcGF30fCIXm9pahSUum"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tV6sV7u8RAKXMy2nk3BeG"},"href":"https://api.spotify.com/v1/albums/5tV6sV7u8RAKXMy2nk3BeG","id":"5tV6sV7u8RAKXMy2nk3BeG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737622b0a1f53a8709e6580cad"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027622b0a1f53a8709e6580cad"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517622b0a1f53a8709e6580cad"}],"is_playable":true,"name":"Withering","release_date":"2024-10-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5tV6sV7u8RAKXMy2nk3BeG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7ccAcGF30fCIXm9pahSUum"},"href":"https://api.spotify.com/v1/artists/7ccAcGF30fCIXm9pahSUum","id":"7ccAcGF30fCIXm9pahSUum","name":"Rubbeni","type":"artist","uri":"spotify:artist:7ccAcGF30fCIXm9pahSUum"}],"disc_number":1,"duration_ms":137522,"explicit":false,"external_ids":{"isrc":"USANG2479109"},"external_urls":{"spotify":"https://open.spotify.com/track/481V5JxSgJbu2tHOYD8z55"},"href":"https://api.spotify.com/v1/tracks/481V5JxSgJbu2tHOYD8z55","id":"481V5JxSgJbu2tHOYD8z55","is_local":false,"is_playable":true,"name":"Withering","track_number":1,"type":"track","uri":"spotify:track:481V5JxSgJbu2tHOYD8z55"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2f8YeRDSJhmeSIPEbMQ28L"},"href":"https://api.spotify.com/v1/artists/2f8YeRDSJhmeSIPEbMQ28L","id":"2f8YeRDSJhmeSIPEbMQ28L","name":"SNOWMEN","type":"artist","uri":"spotify:artist:2f8YeRDSJhmeSIPEbMQ28L"}],"external_urls":{"spotify":"https://open.spotify.com/album/23Rfn0oiO3Mkz4Ld56HVIo"},"href":"https://api.spotify.com/v1/albums/23Rfn0oiO3Mkz4Ld56HVIo","id":"23Rfn0oiO3Mkz4Ld56HVIo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a4bd07ed76b8d4857e9af4d6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a4bd07ed76b8d4857e9af4d6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a4bd07ed76b8d4857e9af4d6"}],"is_playable":true,"name":"Primordial Soup","release_date":"2025-10-10","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:23Rfn0oiO3Mkz4Ld56HVIo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2f8YeRDSJhmeSIPEbMQ28L"},"href":"https://api.spotify.com/v1/artists/2f8YeRDSJhmeSIPEbMQ28L","id":"2f8YeRDSJhmeSIPEbMQ28L","name":"SNOWMEN","type":"artist","uri":"spotify:artist:2f8YeRDSJhmeSIPEbMQ28L"}],"disc_number":1,"duration_ms":208520,"explicit":false,"external_ids":{"isrc":"QMDA72520945"},"external_urls":{"spotify":"https://open.spotify.com/track/0D2L5vDYUeG5gNMSGcFpUM"},"href":"https://api.spotify.com/v1/tracks/0D2L5vDYUeG5gNMSGcFpUM","id":"0D2L5vDYUeG5gNMSGcFpUM","is_local":false,"is_playable":true,"name":"Make Time/Waste Time","track_number":3,"type":"track","uri":"spotify:track:0D2L5vDYUeG5gNMSGcFpUM"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2f8YeRDSJhmeSIPEbMQ28L"},"href":"https://api.spotify.com/v1/artists/2f8YeRDSJhmeSIPEbMQ28L","id":"2f8YeRDSJhmeSIPEbMQ28L","name":"SNOWMEN","type":"artist","uri":"spotify:artist:2f8YeRDSJhmeSIPEbMQ28L"}],"external_urls":{"spotify":"https://open.spotify.com/album/5FpcQhnZ2kIEOvHPa0fO1c"},"href":"https://api.spotify.com/v1/albums/5FpcQhnZ2kIEOvHPa0fO1c","id":"5FpcQhnZ2kIEOvHPa0fO1c","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273992c6706ce7eb69812929387"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02992c6706ce7eb69812929387"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851992c6706ce7eb69812929387"}],"is_playable":true,"name":"A Kick To The Face","release_date":"2025-11-07","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:5FpcQhnZ2kIEOvHPa0fO1c"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2f8YeRDSJhmeSIPEbMQ28L"},"href":"https://api.spotify.com/v1/artists/2f8YeRDSJhmeSIPEbMQ28L","id":"2f8YeRDSJhmeSIPEbMQ28L","name":"SNOWMEN","type":"artist","uri":"spotify:artist:2f8YeRDSJhmeSIPEbMQ28L"}],"disc_number":1,"duration_ms":208520,"explicit":false,"external_ids":{"isrc":"QMDA72520945"},"external_urls":{"spotify":"https://open.spotify.com/track/1n0IxgDV9mjNCLPsN3fR8F"},"href":"https://api.spotify.com/v1/tracks/1n0IxgDV9mjNCLPsN3fR8F","id":"1n0IxgDV9mjNCLPsN3fR8F","is_local":false,"is_playable":true,"name":"Make Time/Waste Time","track_number":2,"type":"track","uri":"spotify:track:1n0IxgDV9mjNCLPsN3fR8F"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FD0unjzGQhX3b6eMccMJe"},"href":"https://api.spotify.com/v1/artists/6FD0unjzGQhX3b6eMccMJe","id":"6FD0unjzGQhX3b6eMccMJe","name":"Ghostface Killah","type":"artist","uri":"spotify:artist:6FD0unjzGQhX3b6eMccMJe"}],"external_urls":{"spotify":"https://open.spotify.com/album/0L1Qq8en6hODRCgaAfTBAq"},"href":"https://api.spotify.com/v1/albums/0L1Qq8en6hODRCgaAfTBAq","id":"0L1Qq8en6hODRCgaAfTBAq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c1aa11212e70ed17d64c5cff"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c1aa11212e70ed17d64c5cff"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c1aa11212e70ed17d64c5cff"}],"is_playable":true,"name":"GhostDeini The Great (Bonus Tracks)","release_date":"2008-01-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:0L1Qq8en6hODRCgaAfTBAq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FD0unjzGQhX3b6eMccMJe"},"href":"https://api.spotify.com/v1/artists/6FD0unjzGQhX3b6eMccMJe","id":"6FD0unjzGQhX3b6eMccMJe","name":"Ghostface Killah","type":"artist","uri":"spotify:artist:6FD0unjzGQhX3b6eMccMJe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5tN6fQFvbiTYubJ9okxkft"},"href":"https://api.spotify.com/v1/artists/5tN6fQFvbiTYubJ9okxkft","id":"5tN6fQFvbiTYubJ9okxkft","name":"Malice","type":"artist","uri":"spotify:artist:5tN6fQFvbiTYubJ9okxkft"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2yQf6b8hxahZaT5dHlWaB1"},"href":"https://api.spotify.com/v1/artists/2yQf6b8hxahZaT5dHlWaB1","id":"2yQf6b8hxahZaT5dHlWaB1","name":"Raekwon","type":"artist","uri":"spotify:artist:2yQf6b8hxahZaT5dHlWaB1"}],"disc_number":1,"duration_ms":363920,"explicit":true,"external_ids":{"isrc":"USUM70849219"},"external_urls":{"spotify":"https://open.spotify.com/track/5E2NY2XBEMh9BrXrBqUBOK"},"href":"https://api.spotify.com/v1/tracks/5E2NY2XBEMh9BrXrBqUBOK","id":"5E2NY2XBEMh9BrXrBqUBOK","is_local":false,"is_playable":true,"name":"Kilo - Remix Album Version (Explicit)","track_number":1,"type":"track","uri":"spotify:track:5E2NY2XBEMh9BrXrBqUBOK"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1eHRZoKPCa0T8Cvk0ntr2o"},"href":"https://api.spotify.com/v1/artists/1eHRZoKPCa0T8Cvk0ntr2o","id":"1eHRZoKPCa0T8Cvk0ntr2o","name":"SAO","type":"artist","uri":"spotify:artist:1eHRZoKPCa0T8Cvk0ntr2o"}],"external_urls":{"spotify":"https://open.spotify.com/album/1CwJcqwt9T4JA8nmn0nrxj"},"href":"https://api.spotify.com/v1/albums/1CwJcqwt9T4JA8nmn0nrxj","id":"1CwJcqwt9T4JA8nmn0nrxj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dfb8a047adb53e13504df066"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dfb8a047adb53e13504df066"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dfb8a047adb53e13504df066"}],"is_playable":true,"name":"FRENCH TOUCH","release_date":"2026-07-24","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1CwJcqwt9T4JA8nmn0nrxj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1eHRZoKPCa0T8Cvk0ntr2o"},"href":"https://api.spotify.com/v1/artists/1eHRZoKPCa0T8Cvk0ntr2o","id":"1eHRZoKPCa0T8Cvk0ntr2o","name":"SAO","type":"artist","uri":"spotify:artist:1eHRZoKPCa0T8Cvk0ntr2o"}],"disc_number":1,"duration_ms":201141,"explicit":false,"external_ids":{"isrc":"ITJAH2600143"},"external_urls":{"spotify":"https://open.spotify.com/track/0p176lJeLpzNAl5UySxRjP"},"href":"https://api.spotify.com/v1/tracks/0p176lJeLpzNAl5UySxRjP","id":"0p176lJeLpzNAl5UySxRjP","is_local":false,"is_playable":true,"name":"FRENCH TOUCH","track_number":1,"type":"track","uri":"spotify:track:0p176lJeLpzNAl5UySxRjP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fhngmJMaaKcdhXHCa4cPK"},"href":"https://api.spotify.com/v1/artists/2fhngmJMaaKcdhXHCa4cPK","id":"2fhngmJMaaKcdhXHCa4cPK","name":"The Dead Milkmen","type":"artist","uri":"spotify:artist:2fhngmJMaaKcdhXHCa4cPK"}],"external_urls":{"spotify":"https://open.spotify.com/album/2ZNb1MUe50ckOcSe9TQOQz"},"href":"https://api.spotify.com/v1/albums/2ZNb1MUe50ckOcSe9TQOQz","id":"2ZNb1MUe50ckOcSe9TQOQz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c6c5c1e4b56e7a439a0ed8f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c6c5c1e4b56e7a439a0ed8f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c6c5c1e4b56e7a439a0ed8f7"}],"is_playable":true,"name":"Death Rides A Pale Cow: The Ultimate Collection","release_date":"1997-01-01","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:2ZNb1MUe50ckOcSe9TQOQz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fhngmJMaaKcdhXHCa4cPK"},"href":"https://api.spotify.com/v1/artists/2fhngmJMaaKcdhXHCa4cPK","id":"2fhngmJMaaKcdhXHCa4cPK","name":"The Dead Milkmen","type":"artist","uri":"spotify:artist:2fhngmJMaaKcdhXHCa4cPK"}],"disc_number":1,"duration_ms":187200,"explicit":false,"external_ids":{"isrc":"USRS72945020"},"external_urls":{"spotify":"https://open.spotify.com/track/0rOgJL9LILiDXotikgwLiO"},"href":"https://api.spotify.com/v1/tracks/0rOgJL9LILiDXotikgwLiO","id":"0rOgJL9LILiDXotikgwLiO","is_local":false,"is_playable":true,"name":"Peter Bazooka","track_number":19,"type":"track","uri":"spotify:track:0rOgJL9LILiDXotikgwLiO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3zZqPqqOoLRafmxkg2ooV0"},"href":"https://api.spotify.com/v1/artists/3zZqPqqOoLRafmxkg2ooV0","id":"3zZqPqqOoLRafmxkg2ooV0","name":"Amina Shareef Ali","type":"artist","uri":"spotify:artist:3zZqPqqOoLRafmxkg2ooV0"}],"external_urls":{"spotify":"https://open.spotify.com/album/63sZu0nJxRPTDLgYG3fOAh"},"href":"https://api.spotify.com/v1/albums/63sZu0nJxRPTDLgYG3fOAh","id":"63sZu0nJxRPTDLgYG3fOAh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aeea7ca695913b798474772b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aeea7ca695913b798474772b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aeea7ca695913b798474772b"}],"is_playable":true,"name":"Holy Rock & Roll","release_date":"2011-04-09","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:63sZu0nJxRPTDLgYG3fOAh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3zZqPqqOoLRafmxkg2ooV0"},"href":"https://api.spotify.com/v1/artists/3zZqPqqOoLRafmxkg2ooV0","id":"3zZqPqqOoLRafmxkg2ooV0","name":"Amina Shareef Ali","type":"artist","uri":"spotify:artist:3zZqPqqOoLRafmxkg2ooV0"}],"disc_number":1,"duration_ms":273506,"explicit":true,"external_ids":{"isrc":"QZNWW2056699"},"external_urls":{"spotify":"https://open.spotify.com/track/379t7U6k21Ii67nUTMHHTd"},"href":"https://api.spotify.com/v1/tracks/379t7U6k21Ii67nUTMHHTd","id":"379t7U6k21Ii67nUTMHHTd","is_local":false,"is_playable":true,"name":"This Heart Is Not A Home","track_number":7,"type":"track","uri":"spotify:track:379t7U6k21Ii67nUTMHHTd"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1GjXiBhwYgQnMfBCSJfwix"},"href":"https://api.spotify.com/v1/artists/1GjXiBhwYgQnMfBCSJfwix","id":"1GjXiBhwYgQnMfBCSJfwix","name":"YK Frizz","type":"artist","uri":"spotify:artist:1GjXiBhwYgQnMfBCSJfwix"}],"external_urls":{"spotify":"https://open.spotify.com/album/6M5WeZjsKft3VgKbJMSjEz"},"href":"https://api.spotify.com/v1/albums/6M5WeZjsKft3VgKbJMSjEz","id":"6M5WeZjsKft3VgKbJMSjEz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273364200f43e3cf36f43d2f0cc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02364200f43e3cf36f43d2f0cc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851364200f43e3cf36f43d2f0cc"}],"is_playable":true,"name":"Only If They Knew","release_date":"2019-05-04","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6M5WeZjsKft3VgKbJMSjEz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1GjXiBhwYgQnMfBCSJfwix"},"href":"https://api.spotify.com/v1/artists/1GjXiBhwYgQnMfBCSJfwix","id":"1GjXiBhwYgQnMfBCSJfwix","name":"YK Frizz","type":"artist","uri":"spotify:artist:1GjXiBhwYgQnMfBCSJfwix"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6phaf9WllB1XA7G1IvapJ8"},"href":"https://api.spotify.com/v1/artists/6phaf9WllB1XA7G1IvapJ8","id":"6phaf9WllB1XA7G1IvapJ8","name":"Ki","type":"artist","uri":"spotify:artist:6phaf9WllB1XA7G1IvapJ8"}],"disc_number":1,"duration_ms":192552,"explicit":true,"external_ids":{"isrc":"QZES61957276"},"external_urls":{"spotify":"https://open.spotify.com/track/7qSN31xgKyd6oc2VpJtVbs"},"href":"https://api.spotify.com/v1/tracks/7qSN31xgKyd6oc2VpJtVbs","id":"7qSN31xgKyd6oc2VpJtVbs","is_local":false,"is_playable":true,"name":"Astonished","track_number":3,"type":"track","uri":"spotify:track:7qSN31xgKyd6oc2VpJtVbs"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1XYXJlaG91c2UlMjBQcm9qZWN0JTIwRXRoZXJ3b29kJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9zZWFyY2g/b2Zmc2V0PTEwJmxpbWl0PTEwJnF1ZXJ5PVdhcmVob3VzZSUyMFByb2plY3QlMjBFdGhlcndvb2QmdHlwZT10cmFjayIsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoxMywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBRaUdNa29Zdnp6SWlEdURDSXQyQ2kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFFpR01rb1l2enpJaUR1RENJdDJDaSIsImlkIjoiMFFpR01rb1l2enpJaUR1RENJdDJDaSIsIm5hbWUiOiJEb3VnbGFzIEdyZWdvcnkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFFpR01rb1l2enpJaUR1RENJdDJDaSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJKUHdldWNzb3hSTVp3b2g3RWRDbHgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8ySlB3ZXVjc294Uk1ad29oN0VkQ2x4IiwiaWQiOiIySlB3ZXVjc294Uk1ad29oN0VkQ2x4IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2U5YTcxM2JmNzE3MTFiMmI5OTM1ZjA3NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlOWE3MTNiZjcxNzExYjJiOTkzNWYwNzYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWU5YTcxM2JmNzE3MTFiMmI5OTM1ZjA3NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYW5kbGUgR2lybCIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDMtMDIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJKUHdldWNzb3hSTVp3b2g3RWRDbHgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wUWlHTWtvWXZ6eklpRHVEQ0l0MkNpIn0sImhyZWYiOiJodA==", + "dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFFpR01rb1l2enpJaUR1RENJdDJDaSIsImlkIjoiMFFpR01rb1l2enpJaUR1RENJdDJDaSIsIm5hbWUiOiJEb3VnbGFzIEdyZWdvcnkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFFpR01rb1l2enpJaUR1RENJdDJDaSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzM1NDksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWlo5NzI0MTM4MTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRQNkk3czBmSVY1anVJdDFJZkk1a04ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80UDZJN3MwZklWNWp1SXQxSWZJNWtOIiwiaWQiOiI0UDZJN3MwZklWNWp1SXQxSWZJNWtOIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNhbmRsZSBHaXJsIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRQNkk3czBmSVY1anVJdDFJZkk1a04ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJmOFllUkRTSmhtZVNJUEViTVEyOEwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmY4WWVSRFNKaG1lU0lQRWJNUTI4TCIsImlkIjoiMmY4WWVSRFNKaG1lU0lQRWJNUTI4TCIsIm5hbWUiOiJTTk9XTUVOIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJmOFllUkRTSmhtZVNJUEViTVEyOEwifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xUTZQM3ptczNBam03NkI1cWY4SU1kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVE2UDN6bXMzQWptNzZCNXFmOElNZCIsImlkIjoiMVE2UDN6bXMzQWptNzZCNXFmOElNZCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmN2MxNTk4MDEyYjI5ODc3MzRjMmIyMTIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjdjMTU5ODAxMmIyOTg3NzM0YzJiMjEyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmN2MxNTk4MDEyYjI5ODc3MzRjMmIyMTIifQ==", + "XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNYWtlIFRpbWUvV2FzdGUgVGltZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDktMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFRNlAzem1zM0FqbTc2QjVxZjhJTWQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yZjhZZVJEU0pobWVTSVBFYk1RMjhMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJmOFllUkRTSmhtZVNJUEViTVEyOEwiLCJpZCI6IjJmOFllUkRTSmhtZVNJUEViTVEyOEwiLCJuYW1lIjoiU05PV01FTiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyZjhZZVJEU0pobWVTSVBFYk1RMjhMIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwODUyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFNREE3MjUyMDk0NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM3hpM1pjandsNExPcE9ENFNwZ21zNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzN4aTNaY2p3bDRMT3BPRDRTcGdtczQiLCJpZCI6IjN4aTNaY2p3bDRMT3BPRDRTcGdtczQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWFrZSBUaW1lL1dhc3RlIFRpbWUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M3hpM1pjandsNExPcE9ENFNwZ21zNCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN2NjQWNHRjMwZkNJWG05cGFoU1V1bSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83Y2NBY0dGMzBmQ0lYbTlwYWhTVXVtIiwiaWQiOiI3Y2NBY0dGMzBmQ0lYbTlwYWhTVXVtIiwibmFtZSI6IlJ1YmJlbmkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N2NjQWNHRjMwZkNJWG05cGFoU1V1bSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzV0VjZzVjd1OFJBS1hNeTJuazNCZUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81dFY2c1Y3dThSQUtYTXkybmszQmVHIiwiaWQiOiI1dFY2c1Y3dThSQUtYTXkybmszQmVHIiwiaW1hZ2VzIjpbew==", + "ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzYyMmIwYTFmNTNhODcwOWU2NTgwY2FkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjc2MjJiMGExZjUzYTg3MDllNjU4MGNhZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzYyMmIwYTFmNTNhODcwOWU2NTgwY2FkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldpdGhlcmluZyIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMTAtMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjV0VjZzVjd1OFJBS1hNeTJuazNCZUcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83Y2NBY0dGMzBmQ0lYbTlwYWhTVXVtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdjY0FjR0YzMGZDSVhtOXBhaFNVdW0iLCJpZCI6IjdjY0FjR0YzMGZDSVhtOXBhaFNVdW0iLCJuYW1lIjoiUnViYmVuaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3Y2NBY0dGMzBmQ0lYbTlwYWhTVXVtIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEzNzUyMiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQU5HMjQ3OTEwOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDgxVjVKeFNnSmJ1MnRIT1lEOHo1NSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQ4MVY1SnhTZ0pidTJ0SE9ZRDh6NTUiLCJpZCI6IjQ4MVY1SnhTZ0pidTJ0SE9ZRDh6NTUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2l0aGVyaW5nIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjQ4MVY1SnhTZ0pidTJ0SE9ZRDh6NTUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJmOFllUkRTSmhtZVNJUEViTVEyOEwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmY4WWVSRFNKaG1lU0lQRWJNUTI4TCIsImlkIjoiMmY4WWVSRFNKaG1lU0lQRWJNUTI4TA==", + "IiwibmFtZSI6IlNOT1dNRU4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmY4WWVSRFNKaG1lU0lQRWJNUTI4TCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzIzUmZuMG9pTzNNa3o0TGQ1NkhWSW8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yM1JmbjBvaU8zTWt6NExkNTZIVklvIiwiaWQiOiIyM1JmbjBvaU8zTWt6NExkNTZIVklvIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2E0YmQwN2VkNzZiOGQ0ODU3ZTlhZjRkNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhNGJkMDdlZDc2YjhkNDg1N2U5YWY0ZDYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWE0YmQwN2VkNzZiOGQ0ODU3ZTlhZjRkNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQcmltb3JkaWFsIFNvdXAiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTEwLTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyM1JmbjBvaU8zTWt6NExkNTZIVklvIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmY4WWVSRFNKaG1lU0lQRWJNUTI4TCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yZjhZZVJEU0pobWVTSVBFYk1RMjhMIiwiaWQiOiIyZjhZZVJEU0pobWVTSVBFYk1RMjhMIiwibmFtZSI6IlNOT1dNRU4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmY4WWVSRFNKaG1lU0lQRWJNUTI4TCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDg1MjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRTURBNzI1MjA5NDUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBEMkw1dkRZVWVHNWdOTVNHY0ZwVU0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wRDJMNXZEWVVlRzVnTk1TR2NGcFVNIiwiaWQiOiIwRDJMNXZEWVVlRzVnTk1TR2NGcFVNIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1ha2UgVGltZS9XYXN0ZSBUaW1lIiwidHJhY2tfbnVtYg==", + "ZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MEQyTDV2RFlVZUc1Z05NU0djRnBVTSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yZjhZZVJEU0pobWVTSVBFYk1RMjhMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJmOFllUkRTSmhtZVNJUEViTVEyOEwiLCJpZCI6IjJmOFllUkRTSmhtZVNJUEViTVEyOEwiLCJuYW1lIjoiU05PV01FTiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyZjhZZVJEU0pobWVTSVBFYk1RMjhMIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUZwY1Fobloya0lFT3ZIUGEwZk8xYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVGcGNRaG5aMmtJRU92SFBhMGZPMWMiLCJpZCI6IjVGcGNRaG5aMmtJRU92SFBhMGZPMWMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTkyYzY3MDZjZTdlYjY5ODEyOTI5Mzg3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjk5MmM2NzA2Y2U3ZWI2OTgxMjkyOTM4NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOTkyYzY3MDZjZTdlYjY5ODEyOTI5Mzg3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkEgS2ljayBUbyBUaGUgRmFjZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMTEtMDciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1RnBjUWhuWjJrSUVPdkhQYTBmTzFjIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmY4WWVSRFNKaG1lU0lQRWJNUTI4TCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yZjhZZVJEU0pobWVTSVBFYk1RMjhMIiwiaWQiOiIyZjhZZVJEU0pobWVTSVBFYk1RMjhMIiwibmFtZSI6IlNOT1dNRU4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmY4WWVSRFNKaG1lU0lQRWJNUTI4TCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDg1MjAsImV4cGxpY2l0IjpmYWxzZSwiZQ==", + "eHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFNREE3MjUyMDk0NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMW4wSXhnRFY5bWpOQ0xQc04zZlI4RiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFuMEl4Z0RWOW1qTkNMUHNOM2ZSOEYiLCJpZCI6IjFuMEl4Z0RWOW1qTkNMUHNOM2ZSOEYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWFrZSBUaW1lL1dhc3RlIFRpbWUiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MW4wSXhnRFY5bWpOQ0xQc04zZlI4RiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RkQwdW5qekdRaFgzYjZlTWNjTUplIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZGRDB1bmp6R1FoWDNiNmVNY2NNSmUiLCJpZCI6IjZGRDB1bmp6R1FoWDNiNmVNY2NNSmUiLCJuYW1lIjoiR2hvc3RmYWNlIEtpbGxhaCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2RkQwdW5qekdRaFgzYjZlTWNjTUplIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMEwxUXE4ZW42aE9EUkNnYUFmVEJBcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBMMVFxOGVuNmhPRFJDZ2FBZlRCQXEiLCJpZCI6IjBMMVFxOGVuNmhPRFJDZ2FBZlRCQXEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzFhYTExMjEyZTcwZWQxN2Q2NGM1Y2ZmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmMxYWExMTIxMmU3MGVkMTdkNjRjNWNmZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzFhYTExMjEyZTcwZWQxN2Q2NGM1Y2ZmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikdob3N0RGVpbmkgVGhlIEdyZWF0IChCb251cyBUcmFja3MpIiwicmVsZWFzZV9kYXRlIjoiMjAwOC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBMMVFxOGVuNmhPRFJDZ2FBZlRCQXEifSwiYXJ0aXN0cyI6Ww==", + "eyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZGRDB1bmp6R1FoWDNiNmVNY2NNSmUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkZEMHVuanpHUWhYM2I2ZU1jY01KZSIsImlkIjoiNkZEMHVuanpHUWhYM2I2ZU1jY01KZSIsIm5hbWUiOiJHaG9zdGZhY2UgS2lsbGFoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGRDB1bmp6R1FoWDNiNmVNY2NNSmUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXRONmZRRnZiaVRZdWJKOW9reGtmdCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81dE42ZlFGdmJpVFl1Yko5b2t4a2Z0IiwiaWQiOiI1dE42ZlFGdmJpVFl1Yko5b2t4a2Z0IiwibmFtZSI6Ik1hbGljZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1dE42ZlFGdmJpVFl1Yko5b2t4a2Z0In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJ5UWY2YjhoeGFoWmFUNWRIbFdhQjEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMnlRZjZiOGh4YWhaYVQ1ZEhsV2FCMSIsImlkIjoiMnlRZjZiOGh4YWhaYVQ1ZEhsV2FCMSIsIm5hbWUiOiJSYWVrd29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJ5UWY2YjhoeGFoWmFUNWRIbFdhQjEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzYzOTIwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzA4NDkyMTkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVFMk5ZMlhCRU1oOUJyWHJCcVVCT0sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81RTJOWTJYQkVNaDlCclhyQnFVQk9LIiwiaWQiOiI1RTJOWTJYQkVNaDlCclhyQnFVQk9LIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IktpbG8gLSBSZW1peCBBbGJ1bSBWZXJzaW9uIChFeHBsaWNpdCkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUUyTlkyWEJFTWg5QnJYckJxVUJPSyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMWVIUlpvS1BDYTBUOEN2azBudHIybyJ9LCJocmVmIjoiaHR0cHM6Ly9hcA==", + "aS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFlSFJab0tQQ2EwVDhDdmswbnRyMm8iLCJpZCI6IjFlSFJab0tQQ2EwVDhDdmswbnRyMm8iLCJuYW1lIjoiU0FPIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFlSFJab0tQQ2EwVDhDdmswbnRyMm8ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xQ3dKY3F3dDlUNEpBOG5tbjBucnhqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUN3SmNxd3Q5VDRKQThubW4wbnJ4aiIsImlkIjoiMUN3SmNxd3Q5VDRKQThubW4wbnJ4aiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkZmI4YTA0N2FkYjUzZTEzNTA0ZGYwNjYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZGZiOGEwNDdhZGI1M2UxMzUwNGRmMDY2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkZmI4YTA0N2FkYjUzZTEzNTA0ZGYwNjYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRlJFTkNIIFRPVUNIIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNy0yNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MUN3SmNxd3Q5VDRKQThubW4wbnJ4aiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFlSFJab0tQQ2EwVDhDdmswbnRyMm8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMWVIUlpvS1BDYTBUOEN2azBudHIybyIsImlkIjoiMWVIUlpvS1BDYTBUOEN2azBudHIybyIsIm5hbWUiOiJTQU8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MWVIUlpvS1BDYTBUOEN2azBudHIybyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDExNDEsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJJVEpBSDI2MDAxNDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBwMTc2bEplTHB6TkFsNVV5U3hSalAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wcDE3NmxKZUxwek5BbDVVeVN4UmpQIiwiaWQiOiIwcDE3NmxKZUxwek5BbDVVeVN4UmpQIiwiaXNfbG9jYWwiOg==", + "ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRlJFTkNIIFRPVUNIIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBwMTc2bEplTHB6TkFsNVV5U3hSalAifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmZobmdtSk1hYUtjZGhYSENhNGNQSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yZmhuZ21KTWFhS2NkaFhIQ2E0Y1BLIiwiaWQiOiIyZmhuZ21KTWFhS2NkaFhIQ2E0Y1BLIiwibmFtZSI6IlRoZSBEZWFkIE1pbGttZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmZobmdtSk1hYUtjZGhYSENhNGNQSyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJaTmIxTVVlNTBja09jU2U5VFFPUXoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yWk5iMU1VZTUwY2tPY1NlOVRRT1F6IiwiaWQiOiIyWk5iMU1VZTUwY2tPY1NlOVRRT1F6IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2M2YzVjMWU0YjU2ZTdhNDM5YTBlZDhmNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjNmM1YzFlNGI1NmU3YTQzOWEwZWQ4ZjcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM2YzVjMWU0YjU2ZTdhNDM5YTBlZDhmNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZWF0aCBSaWRlcyBBIFBhbGUgQ293OiBUaGUgVWx0aW1hdGUgQ29sbGVjdGlvbiIsInJlbGVhc2VfZGF0ZSI6IjE5OTctMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyWk5iMU1VZTUwY2tPY1NlOVRRT1F6In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmZobmdtSk1hYUtjZGhYSENhNGNQSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yZmhuZ21KTWFhS2NkaFhIQ2E0Y1BLIiwiaWQiOiIyZmhuZ21KTWFhS2NkaFhIQ2E0Y1BLIiwibmFtZSI6IlRoZSBEZWFkIE1pbGttZW4iLCJ0eXBlIjoiYQ==", + "cnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyZmhuZ21KTWFhS2NkaFhIQ2E0Y1BLIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4NzIwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUlM3Mjk0NTAyMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHJPZ0pMOUxJTGlEWG90aWtnd0xpTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzByT2dKTDlMSUxpRFhvdGlrZ3dMaU8iLCJpZCI6IjByT2dKTDlMSUxpRFhvdGlrZ3dMaU8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUGV0ZXIgQmF6b29rYSIsInRyYWNrX251bWJlciI6MTksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHJPZ0pMOUxJTGlEWG90aWtnd0xpTyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zelpxUHFxT29MUmFmbXhrZzJvb1YwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN6WnFQcXFPb0xSYWZteGtnMm9vVjAiLCJpZCI6IjN6WnFQcXFPb0xSYWZteGtnMm9vVjAiLCJuYW1lIjoiQW1pbmEgU2hhcmVlZiBBbGkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3pacVBxcU9vTFJhZm14a2cyb29WMCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzYzc1p1MG5KeFJQVERMZ1lHM2ZPQWgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82M3NadTBuSnhSUFRETGdZRzNmT0FoIiwiaWQiOiI2M3NadTBuSnhSUFRETGdZRzNmT0FoIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FlZWE3Y2E2OTU5MTNiNzk4NDc0NzcyYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhZWVhN2NhNjk1OTEzYjc5ODQ3NDc3MmIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFlZWE3Y2E2OTU5MTNiNzk4NDc0NzcyYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb2x5IFJvY2sgJiBSb2xsIiwicmVsZWFzZV9kYXRlIjoiMjAxMS0wNC0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0bw==", + "dGFsX3RyYWNrcyI6OCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2M3NadTBuSnhSUFRETGdZRzNmT0FoIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3pacVBxcU9vTFJhZm14a2cyb29WMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zelpxUHFxT29MUmFmbXhrZzJvb1YwIiwiaWQiOiIzelpxUHFxT29MUmFmbXhrZzJvb1YwIiwibmFtZSI6IkFtaW5hIFNoYXJlZWYgQWxpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN6WnFQcXFPb0xSYWZteGtnMm9vVjAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjczNTA2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWk5XVzIwNTY2OTkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzM3OXQ3VTZrMjFJaTY3blVUTUhIVGQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zNzl0N1U2azIxSWk2N25VVE1ISFRkIiwiaWQiOiIzNzl0N1U2azIxSWk2N25VVE1ISFRkIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoaXMgSGVhcnQgSXMgTm90IEEgSG9tZSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozNzl0N1U2azIxSWk2N25VVE1ISFRkIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFHalhpQmh3WWdRbk1mQkNTSmZ3aXgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUdqWGlCaHdZZ1FuTWZCQ1NKZndpeCIsImlkIjoiMUdqWGlCaHdZZ1FuTWZCQ1NKZndpeCIsIm5hbWUiOiJZSyBGcml6eiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxR2pYaUJod1lnUW5NZkJDU0pmd2l4In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNk01V2VaanNLZnQzVmdLYkpNU2pFeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlm", + "eS5jb20vdjEvYWxidW1zLzZNNVdlWmpzS2Z0M1ZnS2JKTVNqRXoiLCJpZCI6IjZNNVdlWmpzS2Z0M1ZnS2JKTVNqRXoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzY0MjAwZjQzZTNjZjM2ZjQzZDJmMGNjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjM2NDIwMGY0M2UzY2YzNmY0M2QyZjBjYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzY0MjAwZjQzZTNjZjM2ZjQzZDJmMGNjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik9ubHkgSWYgVGhleSBLbmV3IiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wNS0wNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZNNVdlWmpzS2Z0M1ZnS2JKTVNqRXoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xR2pYaUJod1lnUW5NZkJDU0pmd2l4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFHalhpQmh3WWdRbk1mQkNTSmZ3aXgiLCJpZCI6IjFHalhpQmh3WWdRbk1mQkNTSmZ3aXgiLCJuYW1lIjoiWUsgRnJpenoiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUdqWGlCaHdZZ1FuTWZCQ1NKZndpeCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82cGhhZjlXbGxCMVhBN0cxSXZhcEo4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZwaGFmOVdsbEIxWEE3RzFJdmFwSjgiLCJpZCI6IjZwaGFmOVdsbEIxWEE3RzFJdmFwSjgiLCJuYW1lIjoiS2kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnBoYWY5V2xsQjFYQTdHMUl2YXBKOCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTI1NTIsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaRVM2MTk1NzI3NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN3FTTjMxeGdLeWQ2b2MyVnBKdFZicyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdxU04zMXhnS3lkNm9jMlZwSnRWYnMiLCJpZCI6IjdxU04zMXhnS3lkNm9jMlZwSnRWYnMiLCJpc19sb2NhbA==", + "IjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBc3RvbmlzaGVkIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdxU04zMXhnS3lkNm9jMlZwSnRWYnMifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Warehouse+Project+Etherwood&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhdGNoaW5nJTIwV2luZG93cyUyMiUyMGFydGlzdCUzQSUyMkolMjBEaWxsYSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhdGNoaW5nJTIwV2luZG93cyUyMiUyMGFydGlzdCUzQSUyMkolMjBEaWxsYSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Watching+Windows%22+artist%3A%22J+Dilla%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Inner%20City%20Life%22%20artist%3A%22Goldie%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"external_urls":{"spotify":"https://open.spotify.com/album/3nlPv0dIcF8CNaiVzsHBsY"},"href":"https://api.spotify.com/v1/albums/3nlPv0dIcF8CNaiVzsHBsY","id":"3nlPv0dIcF8CNaiVzsHBsY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27375994b8451a838f7a5db54d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0275994b8451a838f7a5db54d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485175994b8451a838f7a5db54d7"}],"is_playable":true,"name":"Inner City Life","release_date":"1994-01-01","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:3nlPv0dIcF8CNaiVzsHBsY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"disc_number":1,"duration_ms":420266,"explicit":false,"external_ids":{"isrc":"GBAAP9500462"},"external_urls":{"spotify":"https://open.spotify.com/track/0O7xFEqePrcTUgOi4qe0uB"},"href":"https://api.spotify.com/v1/tracks/0O7xFEqePrcTUgOi4qe0uB","id":"0O7xFEqePrcTUgOi4qe0uB","is_local":false,"is_playable":true,"name":"Inner City Life","track_number":2,"type":"track","uri":"spotify:track:0O7xFEqePrcTUgOi4qe0uB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"external_urls":{"spotify":"https://open.spotify.com/album/3nlPv0dIcF8CNaiVzsHBsY"},"href":"https://api.spotify.com/v1/albums/3nlPv0dIcF8CNaiVzsHBsY","id":"3nlPv0dIcF8CNaiVzsHBsY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27375994b8451a838f7a5db54d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0275994b8451a838f7a5db54d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485175994b8451a838f7a5db54d7"}],"is_playable":true,"name":"Inner City Life","release_date":"1994-01-01","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:3nlPv0dIcF8CNaiVzsHBsY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"disc_number":1,"duration_ms":231973,"explicit":false,"external_ids":{"isrc":"GBANR9400068"},"external_urls":{"spotify":"https://open.spotify.com/track/4TOIdyhxz1xgAlrrz2HHhT"},"href":"https://api.spotify.com/v1/tracks/4TOIdyhxz1xgAlrrz2HHhT","id":"4TOIdyhxz1xgAlrrz2HHhT","is_local":false,"is_playable":true,"name":"Inner City Life - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:4TOIdyhxz1xgAlrrz2HHhT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7FtCGMC0pcHPlrZWmYe9XM"},"href":"https://api.spotify.com/v1/artists/7FtCGMC0pcHPlrZWmYe9XM","id":"7FtCGMC0pcHPlrZWmYe9XM","name":"Break","type":"artist","uri":"spotify:artist:7FtCGMC0pcHPlrZWmYe9XM"}],"external_urls":{"spotify":"https://open.spotify.com/album/798vtFYxe2qAmB6XR5BCwh"},"href":"https://api.spotify.com/v1/albums/798vtFYxe2qAmB6XR5BCwh","id":"798vtFYxe2qAmB6XR5BCwh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273811ddcc2fae29694d2b6077d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02811ddcc2fae29694d2b6077d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851811ddcc2fae29694d2b6077d"}],"is_playable":true,"name":"Inner City Life (Break Remix)","release_date":"2023-05-23","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:798vtFYxe2qAmB6XR5BCwh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7FtCGMC0pcHPlrZWmYe9XM"},"href":"https://api.spotify.com/v1/artists/7FtCGMC0pcHPlrZWmYe9XM","id":"7FtCGMC0pcHPlrZWmYe9XM","name":"Break","type":"artist","uri":"spotify:artist:7FtCGMC0pcHPlrZWmYe9XM"}],"disc_number":1,"duration_ms":370557,"explicit":false,"external_ids":{"isrc":"GBAAP2200045"},"external_urls":{"spotify":"https://open.spotify.com/track/0O0WWQ7iwIVE8zMFtXlT79"},"href":"https://api.spotify.com/v1/tracks/0O0WWQ7iwIVE8zMFtXlT79","id":"0O0WWQ7iwIVE8zMFtXlT79","is_local":false,"is_playable":true,"name":"Inner City Life - Break Remix","track_number":1,"type":"track","uri":"spotify:track:0O0WWQ7iwIVE8zMFtXlT79"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"external_urls":{"spotify":"https://open.spotify.com/album/3nlPv0dIcF8CNaiVzsHBsY"},"href":"https://api.spotify.com/v1/albums/3nlPv0dIcF8CNaiVzsHBsY","id":"3nlPv0dIcF8CNaiVzsHBsY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27375994b8451a838f7a5db54d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0275994b8451a838f7a5db54d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485175994b8451a838f7a5db54d7"}],"is_playable":true,"name":"Inner City Life","release_date":"1994-01-01","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:3nlPv0dIcF8CNaiVzsHBsY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/491cHKkjRVcGaChy40l4Bh"},"href":"https://api.spotify.com/v1/artists/491cHKkjRVcGaChy40l4Bh","id":"491cHKkjRVcGaChy40l4Bh","name":"Nookie","type":"artist","uri":"spotify:artist:491cHKkjRVcGaChy40l4Bh"}],"disc_number":1,"duration_ms":346226,"explicit":false,"external_ids":{"isrc":"GBAAP1812315"},"external_urls":{"spotify":"https://open.spotify.com/track/3bE6j67UQnpHozY7j8QY4w"},"href":"https://api.spotify.com/v1/tracks/3bE6j67UQnpHozY7j8QY4w","id":"3bE6j67UQnpHozY7j8QY4w","is_local":false,"is_playable":true,"name":"Inner City Life - Nookie Remix","track_number":6,"type":"track","uri":"spotify:track:3bE6j67UQnpHozY7j8QY4w"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ECHgK6XAezjHX81zV36f9"},"href":"https://api.spotify.com/v1/albums/4ECHgK6XAezjHX81zV36f9","id":"4ECHgK6XAezjHX81zV36f9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273553e4a678b2295123da08196"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02553e4a678b2295123da08196"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851553e4a678b2295123da08196"}],"is_playable":true,"name":"Inner City Life (The Remixes)","release_date":"1994-11-21","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4ECHgK6XAezjHX81zV36f9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FLqffkqWuOC6VoQzMQdtF"},"href":"https://api.spotify.com/v1/artists/0FLqffkqWuOC6VoQzMQdtF","id":"0FLqffkqWuOC6VoQzMQdtF","name":"Metalheadz","type":"artist","uri":"spotify:artist:0FLqffkqWuOC6VoQzMQdtF"}],"disc_number":1,"duration_ms":195693,"explicit":false,"external_ids":{"isrc":"GBANR9500015"},"external_urls":{"spotify":"https://open.spotify.com/track/6y6sPyDLcyW0wWyLISnWVO"},"href":"https://api.spotify.com/v1/tracks/6y6sPyDLcyW0wWyLISnWVO","id":"6y6sPyDLcyW0wWyLISnWVO","is_local":false,"is_playable":true,"name":"Inner City Life","track_number":1,"type":"track","uri":"spotify:track:6y6sPyDLcyW0wWyLISnWVO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"external_urls":{"spotify":"https://open.spotify.com/album/67HPieOqDZ6G7WOM09Egbk"},"href":"https://api.spotify.com/v1/albums/67HPieOqDZ6G7WOM09Egbk","id":"67HPieOqDZ6G7WOM09Egbk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f01599fdaf6fbc0a3d1e11c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f01599fdaf6fbc0a3d1e11c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f01599fdaf6fbc0a3d1e11c"}],"is_playable":true,"name":"Timeless","release_date":"1995-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:67HPieOqDZ6G7WOM09Egbk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5WydJz9dDGfapnuC8HdGzF"},"href":"https://api.spotify.com/v1/artists/5WydJz9dDGfapnuC8HdGzF","id":"5WydJz9dDGfapnuC8HdGzF","name":"Baby Boys","type":"artist","uri":"spotify:artist:5WydJz9dDGfapnuC8HdGzF"}],"disc_number":1,"duration_ms":217360,"explicit":false,"external_ids":{"isrc":"GBAAP0100795"},"external_urls":{"spotify":"https://open.spotify.com/track/6pJMMs5I2u2pjtODKOlpvn"},"href":"https://api.spotify.com/v1/tracks/6pJMMs5I2u2pjtODKOlpvn","id":"6pJMMs5I2u2pjtODKOlpvn","is_local":false,"is_playable":true,"name":"Inner City Life - Baby Boy's Edit","track_number":13,"type":"track","uri":"spotify:track:6pJMMs5I2u2pjtODKOlpvn"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"external_urls":{"spotify":"https://open.spotify.com/album/1yzvkE7KPp9AGrEPfiIHzn"},"href":"https://api.spotify.com/v1/albums/1yzvkE7KPp9AGrEPfiIHzn","id":"1yzvkE7KPp9AGrEPfiIHzn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ec1457d7afbe36a23fa78092"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ec1457d7afbe36a23fa78092"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ec1457d7afbe36a23fa78092"}],"is_playable":true,"name":"Inner City Life (Timeless 25 Remaster)","release_date":"2020-11-18","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:1yzvkE7KPp9AGrEPfiIHzn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"disc_number":1,"duration_ms":230274,"explicit":false,"external_ids":{"isrc":"GBAAP2000241"},"external_urls":{"spotify":"https://open.spotify.com/track/7czQVaYoO03FCbx7NREqbc"},"href":"https://api.spotify.com/v1/tracks/7czQVaYoO03FCbx7NREqbc","id":"7czQVaYoO03FCbx7NREqbc","is_local":false,"is_playable":true,"name":"Inner City Life (Radio Edit) - 2020 Remaster","track_number":7,"type":"track","uri":"spotify:track:7czQVaYoO03FCbx7NREqbc"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"external_urls":{"spotify":"https://open.spotify.com/album/3rxHbhPAmoGImWy88izfzm"},"href":"https://api.spotify.com/v1/albums/3rxHbhPAmoGImWy88izfzm","id":"3rxHbhPAmoGImWy88izfzm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2d37519ee1d0fb5b89921f3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2d37519ee1d0fb5b89921f3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2d37519ee1d0fb5b89921f3"}],"is_playable":true,"name":"Inner City Life 2017","release_date":"2017-07-28","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:3rxHbhPAmoGImWy88izfzm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2NXlktjI0V3TFsU9yHLbSc"},"href":"https://api.spotify.com/v1/artists/2NXlktjI0V3TFsU9yHLbSc","id":"2NXlktjI0V3TFsU9yHLbSc","name":"Espa","type":"artist","uri":"spotify:artist:2NXlktjI0V3TFsU9yHLbSc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0uCCBpmg6MrPb1KY2msceF"},"href":"https://api.spotify.com/v1/artists/0uCCBpmg6MrPb1KY2msceF","id":"0uCCBpmg6MrPb1KY2msceF","name":"Burial","type":"artist","uri":"spotify:artist:0uCCBpmg6MrPb1KY2msceF"}],"disc_number":1,"duration_ms":419240,"explicit":false,"external_ids":{"isrc":"GBBHF1310347"},"external_urls":{"spotify":"https://open.spotify.com/track/0kG4KgvaSA9kCr0lr0dmvU"},"href":"https://api.spotify.com/v1/tracks/0kG4KgvaSA9kCr0lr0dmvU","id":"0kG4KgvaSA9kCr0lr0dmvU","is_local":false,"is_playable":true,"name":"Inner City Life - Burial Remix","track_number":2,"type":"track","uri":"spotify:track:0kG4KgvaSA9kCr0lr0dmvU"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"external_urls":{"spotify":"https://open.spotify.com/album/1yzvkE7KPp9AGrEPfiIHzn"},"href":"https://api.spotify.com/v1/albums/1yzvkE7KPp9AGrEPfiIHzn","id":"1yzvkE7KPp9AGrEPfiIHzn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ec1457d7afbe36a23fa78092"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ec1457d7afbe36a23fa78092"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ec1457d7afbe36a23fa78092"}],"is_playable":true,"name":"Inner City Life (Timeless 25 Remaster)","release_date":"2020-11-18","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:1yzvkE7KPp9AGrEPfiIHzn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"disc_number":1,"duration_ms":422182,"explicit":false,"external_ids":{"isrc":"GBAAP2000236"},"external_urls":{"spotify":"https://open.spotify.com/track/3YepI5xpaXqIqp9DtASxTn"},"href":"https://api.spotify.com/v1/tracks/3YepI5xpaXqIqp9DtASxTn","id":"3YepI5xpaXqIqp9DtASxTn","is_local":false,"is_playable":true,"name":"Inner City Life - 2020 Remaster","track_number":1,"type":"track","uri":"spotify:track:3YepI5xpaXqIqp9DtASxTn"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"}],"external_urls":{"spotify":"https://open.spotify.com/album/67HPieOqDZ6G7WOM09Egbk"},"href":"https://api.spotify.com/v1/albums/67HPieOqDZ6G7WOM09Egbk","id":"67HPieOqDZ6G7WOM09Egbk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f01599fdaf6fbc0a3d1e11c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f01599fdaf6fbc0a3d1e11c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f01599fdaf6fbc0a3d1e11c"}],"is_playable":true,"name":"Timeless","release_date":"1995-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:67HPieOqDZ6G7WOM09Egbk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SYqJ3uDLLXZNyZdLKBy4M"},"href":"https://api.spotify.com/v1/artists/2SYqJ3uDLLXZNyZdLKBy4M","id":"2SYqJ3uDLLXZNyZdLKBy4M","name":"Goldie","type":"artist","uri":"spotify:artist:2SYqJ3uDLLXZNyZdLKBy4M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6r9gUD6bIMsJ2yc2PhIg4E"},"href":"https://api.spotify.com/v1/artists/6r9gUD6bIMsJ2yc2PhIg4E","id":"6r9gUD6bIMsJ2yc2PhIg4E","name":"Rabbit In The Moon","type":"artist","uri":"spotify:artist:6r9gUD6bIMsJ2yc2PhIg4E"}],"disc_number":1,"duration_ms":260720,"explicit":false,"external_ids":{"isrc":"GBAAP0100796"},"external_urls":{"spotify":"https://open.spotify.com/track/2kbRQO1eqTnbFb4LBRzTz9"},"href":"https://api.spotify.com/v1/tracks/2kbRQO1eqTnbFb4LBRzTz9","id":"2kbRQO1eqTnbFb4LBRzTz9","is_local":false,"is_playable":true,"name":"Inner City Life - Rabbit's Short Attention Span Edit","track_number":14,"type":"track","uri":"spotify:track:2kbRQO1eqTnbFb4LBRzTz9"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMklubmVyJTIwQ2l0eSUyMExpZmUlMjIlMjBhcnRpc3QlM0ElMjJHb2xkaWUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTWXFKM3VETExYWk55WmRMS0J5NE0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNZcUozdURMTFhaTnlaZExLQnk0TSIsImlkIjoiMlNZcUozdURMTFhaTnlaZExLQnk0TSIsIm5hbWUiOiJHb2xkaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNZcUozdURMTFhaTnlaZExLQnk0TSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNubFB2MGRJY0Y4Q05haVZ6c0hCc1kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zbmxQdjBkSWNGOENOYWlWenNIQnNZIiwiaWQiOiIzbmxQdjBkSWNGOENOYWlWenNIQnNZIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzc1OTk0Yjg0NTFhODM4ZjdhNWRiNTRkNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3NTk5NGI4NDUxYTgzOGY3YTVkYjU0ZDcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTc1OTk0Yjg0NTFhODM4ZjdhNWRiNTRkNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbm5lciBDaXR5IExpZmUiLCJyZWxlYXNlX2RhdGUiOiIxOTk0LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozbmxQdjBkSWNGOENOYWlWenNIQnNZIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNZcUozdURMTFhaTnlaZExLQnk0TSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIiwiaWQiOiIyU1lxSjN1RExMWFpOeVpkTA==", + "S0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDIwMjY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBQVA5NTAwNDYyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wTzd4RkVxZVByY1RVZ09pNHFlMHVCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvME83eEZFcWVQcmNUVWdPaTRxZTB1QiIsImlkIjoiME83eEZFcWVQcmNUVWdPaTRxZTB1QiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbm5lciBDaXR5IExpZmUiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6ME83eEZFcWVQcmNUVWdPaTRxZTB1QiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJpZCI6IjJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zbmxQdjBkSWNGOENOYWlWenNIQnNZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM25sUHYwZEljRjhDTmFpVnpzSEJzWSIsImlkIjoiM25sUHYwZEljRjhDTmFpVnpzSEJzWSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3NTk5NGI4NDUxYTgzOGY3YTVkYjU0ZDcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzU5OTRiODQ1MWE4MzhmN2E1ZGI1NGQ3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3NTk5NGI4NDUxYTgzOGY3YTVkYjU0ZDcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW5uZXIgQ2l0eSBMaWZlIiwicmVsZWFzZV9kYXRlIjoiMTk5NC0wMS0wMSIsInJlbGVhc2VfZGF0ZQ==", + "X3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozbmxQdjBkSWNGOENOYWlWenNIQnNZIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNZcUozdURMTFhaTnlaZExLQnk0TSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIiwiaWQiOiIyU1lxSjN1RExMWFpOeVpkTEtCeTRNIiwibmFtZSI6IkdvbGRpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU1lxSjN1RExMWFpOeVpkTEtCeTRNIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzMTk3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQU5SOTQwMDA2OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFRPSWR5aHh6MXhnQWxycnoySEhoVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRUT0lkeWh4ejF4Z0FscnJ6MkhIaFQiLCJpZCI6IjRUT0lkeWh4ejF4Z0FscnJ6MkhIaFQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW5uZXIgQ2l0eSBMaWZlIC0gUmFkaW8gRWRpdCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0VE9JZHloeHoxeGdBbHJyejJISGhUIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJpZCI6IjJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0Z0Q0dNQzBwY0hQbHJaV21ZZTlYTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83RnRDR01DMHBjSFBsclpXbVllOVhNIiwiaWQiOiI3RnRDR01DMHBjSFBsclpXbVllOVhNIiwibmFtZSI6IkJyZWFrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdGdENHTUMwcGNIUGxyWldtWWU5WE0ifV0sImV4dGVybmFsX3VybHMiOg==", + "eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc5OHZ0Rll4ZTJxQW1CNlhSNUJDd2gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83OTh2dEZZeGUycUFtQjZYUjVCQ3doIiwiaWQiOiI3OTh2dEZZeGUycUFtQjZYUjVCQ3doIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzgxMWRkY2MyZmFlMjk2OTRkMmI2MDc3ZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4MTFkZGNjMmZhZTI5Njk0ZDJiNjA3N2QifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTgxMWRkY2MyZmFlMjk2OTRkMmI2MDc3ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbm5lciBDaXR5IExpZmUgKEJyZWFrIFJlbWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDUtMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc5OHZ0Rll4ZTJxQW1CNlhSNUJDd2gifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJpZCI6IjJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0Z0Q0dNQzBwY0hQbHJaV21ZZTlYTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83RnRDR01DMHBjSFBsclpXbVllOVhNIiwiaWQiOiI3RnRDR01DMHBjSFBsclpXbVllOVhNIiwibmFtZSI6IkJyZWFrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdGdENHTUMwcGNIUGxyWldtWWU5WE0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzcwNTU3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBQVAyMjAwMDQ1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wTzBXV1E3aXdJVkU4ek1GdFhsVDc5Ig==", + "fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wTzBXV1E3aXdJVkU4ek1GdFhsVDc5IiwiaWQiOiIwTzBXV1E3aXdJVkU4ek1GdFhsVDc5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IklubmVyIENpdHkgTGlmZSAtIEJyZWFrIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBPMFdXUTdpd0lWRTh6TUZ0WGxUNzkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNZcUozdURMTFhaTnlaZExLQnk0TSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIiwiaWQiOiIyU1lxSjN1RExMWFpOeVpkTEtCeTRNIiwibmFtZSI6IkdvbGRpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU1lxSjN1RExMWFpOeVpkTEtCeTRNIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM25sUHYwZEljRjhDTmFpVnpzSEJzWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNubFB2MGRJY0Y4Q05haVZ6c0hCc1kiLCJpZCI6IjNubFB2MGRJY0Y4Q05haVZ6c0hCc1kiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzU5OTRiODQ1MWE4MzhmN2E1ZGI1NGQ3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjc1OTk0Yjg0NTFhODM4ZjdhNWRiNTRkNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzU5OTRiODQ1MWE4MzhmN2E1ZGI1NGQ3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IklubmVyIENpdHkgTGlmZSIsInJlbGVhc2VfZGF0ZSI6IjE5OTQtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNubFB2MGRJY0Y4Q05haVZ6c0hCc1kifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWg==", + "TnlaZExLQnk0TSIsImlkIjoiMlNZcUozdURMTFhaTnlaZExLQnk0TSIsIm5hbWUiOiJHb2xkaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNZcUozdURMTFhaTnlaZExLQnk0TSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80OTFjSEtralJWY0dhQ2h5NDBsNEJoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzQ5MWNIS2tqUlZjR2FDaHk0MGw0QmgiLCJpZCI6IjQ5MWNIS2tqUlZjR2FDaHk0MGw0QmgiLCJuYW1lIjoiTm9va2llIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjQ5MWNIS2tqUlZjR2FDaHk0MGw0QmgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzQ2MjI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBQVAxODEyMzE1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zYkU2ajY3VVFucEhvelk3ajhRWTR3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM2JFNmo2N1VRbnBIb3pZN2o4UVk0dyIsImlkIjoiM2JFNmo2N1VRbnBIb3pZN2o4UVk0dyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbm5lciBDaXR5IExpZmUgLSBOb29raWUgUmVtaXgiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2JFNmo2N1VRbnBIb3pZN2o4UVk0dyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNZcUozdURMTFhaTnlaZExLQnk0TSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIiwiaWQiOiIyU1lxSjN1RExMWFpOeVpkTEtCeTRNIiwibmFtZSI6IkdvbGRpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU1lxSjN1RExMWFpOeVpkTEtCeTRNIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNEVDSGdLNlhBZXpqSFg4MXpWMzZmOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRFQ0hnSzZYQWV6akhYODF6VjM2ZjkiLCJpZCI6IjRFQ0hnSzZYQWV6akhYODF6VjM2ZjkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMg==", + "NzM1NTNlNGE2NzhiMjI5NTEyM2RhMDgxOTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTUzZTRhNjc4YjIyOTUxMjNkYTA4MTk2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1NTNlNGE2NzhiMjI5NTEyM2RhMDgxOTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW5uZXIgQ2l0eSBMaWZlIChUaGUgUmVtaXhlcykiLCJyZWxlYXNlX2RhdGUiOiIxOTk0LTExLTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEVDSGdLNlhBZXpqSFg4MXpWMzZmOSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTWXFKM3VETExYWk55WmRMS0J5NE0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNZcUozdURMTFhaTnlaZExLQnk0TSIsImlkIjoiMlNZcUozdURMTFhaTnlaZExLQnk0TSIsIm5hbWUiOiJHb2xkaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNZcUozdURMTFhaTnlaZExLQnk0TSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wRkxxZmZrcVd1T0M2Vm9Rek1RZHRGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBGTHFmZmtxV3VPQzZWb1F6TVFkdEYiLCJpZCI6IjBGTHFmZmtxV3VPQzZWb1F6TVFkdEYiLCJuYW1lIjoiTWV0YWxoZWFkeiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowRkxxZmZrcVd1T0M2Vm9Rek1RZHRGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NTY5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQU5SOTUwMDAxNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnk2c1B5RExjeVcwd1d5TElTbldWTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ5NnNQeURMY3lXMHdXeUxJU25XVk8iLCJpZCI6IjZ5NnNQeURMY3lXMHdXeUxJU25XVk8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW5uZXIgQ2l0eSBMaWZlIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZ5NnNQeURMY3lXMHdXeUxJU25XVk8ifSx7Ig==", + "YWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJpZCI6IjJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82N0hQaWVPcURaNkc3V09NMDlFZ2JrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjdIUGllT3FEWjZHN1dPTTA5RWdiayIsImlkIjoiNjdIUGllT3FEWjZHN1dPTTA5RWdiayIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZjAxNTk5ZmRhZjZmYmMwYTNkMWUxMWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGYwMTU5OWZkYWY2ZmJjMGEzZDFlMTFjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwZjAxNTk5ZmRhZjZmYmMwYTNkMWUxMWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGltZWxlc3MiLCJyZWxlYXNlX2RhdGUiOiIxOTk1LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NjdIUGllT3FEWjZHN1dPTTA5RWdiayJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTWXFKM3VETExYWk55WmRMS0J5NE0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNZcUozdURMTFhaTnlaZExLQnk0TSIsImlkIjoiMlNZcUozdURMTFhaTnlaZExLQnk0TSIsIm5hbWUiOiJHb2xkaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNZcUozdURMTFhaTnlaZExLQnk0TSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81V3lkSno5ZERHZmFwbnVDOEhkR3pGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVXeWRKejlkRA==", + "R2ZhcG51QzhIZEd6RiIsImlkIjoiNVd5ZEp6OWRER2ZhcG51QzhIZEd6RiIsIm5hbWUiOiJCYWJ5IEJveXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVd5ZEp6OWRER2ZhcG51QzhIZEd6RiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTczNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFBUDAxMDA3OTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZwSk1NczVJMnUycGp0T0RLT2xwdm4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82cEpNTXM1STJ1MnBqdE9ES09scHZuIiwiaWQiOiI2cEpNTXM1STJ1MnBqdE9ES09scHZuIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IklubmVyIENpdHkgTGlmZSAtIEJhYnkgQm95J3MgRWRpdCIsInRyYWNrX251bWJlciI6MTMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NnBKTU1zNUkydTJwanRPREtPbHB2biJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJpZCI6IjJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xeXp2a0U3S1BwOUFHckVQZmlJSHpuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMXl6dmtFN0tQcDlBR3JFUGZpSUh6biIsImlkIjoiMXl6dmtFN0tQcDlBR3JFUGZpSUh6biIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlYzE0NTdkN2FmYmUzNmEyM2ZhNzgwOTIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZWMxNDU3ZDdhZmJlMzZhMjNmYTc4MDkyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlYzE0NTdkN2FmYmUzNmEyM2ZhNzgwOTIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIg==", + "OiJJbm5lciBDaXR5IExpZmUgKFRpbWVsZXNzIDI1IFJlbWFzdGVyKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTEtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjF5enZrRTdLUHA5QUdyRVBmaUlIem4ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJpZCI6IjJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMwMjc0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBQVAyMDAwMjQxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83Y3pRVmFZb08wM0ZDYng3TlJFcWJjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2N6UVZhWW9PMDNGQ2J4N05SRXFiYyIsImlkIjoiN2N6UVZhWW9PMDNGQ2J4N05SRXFiYyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbm5lciBDaXR5IExpZmUgKFJhZGlvIEVkaXQpIC0gMjAyMCBSZW1hc3RlciIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3Y3pRVmFZb08wM0ZDYng3TlJFcWJjIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJpZCI6IjJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zcnhIYmhQQW1vR0ltV3k4OGl6ZnptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM3J4SGJoUEFtb0dJbVd5ODhpemZ6bSIsImlkIjoiM3J4SGJoUEFtb0dJbVd5ODhpemZ6bQ==", + "IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2YyZDM3NTE5ZWUxZDBmYjViODk5MjFmMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmMmQzNzUxOWVlMWQwZmI1Yjg5OTIxZjMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWYyZDM3NTE5ZWUxZDBmYjViODk5MjFmMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbm5lciBDaXR5IExpZmUgMjAxNyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDctMjgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNyeEhiaFBBbW9HSW1XeTg4aXpmem0ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJpZCI6IjJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk5YbGt0akkwVjNURnNVOXlITGJTYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTlhsa3RqSTBWM1RGc1U5eUhMYlNjIiwiaWQiOiIyTlhsa3RqSTBWM1RGc1U5eUhMYlNjIiwibmFtZSI6IkVzcGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk5YbGt0akkwVjNURnNVOXlITGJTYyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdUNDQnBtZzZNclBiMUtZMm1zY2VGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB1Q0NCcG1nNk1yUGIxS1kybXNjZUYiLCJpZCI6IjB1Q0NCcG1nNk1yUGIxS1kybXNjZUYiLCJuYW1lIjoiQnVyaWFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjB1Q0NCcG1nNk1yUGIxS1kybXNjZUYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDE5MjQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JCSEYxMw==", + "MTAzNDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBrRzRLZ3ZhU0E5a0NyMGxyMGRtdlUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wa0c0S2d2YVNBOWtDcjBscjBkbXZVIiwiaWQiOiIwa0c0S2d2YVNBOWtDcjBscjBkbXZVIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IklubmVyIENpdHkgTGlmZSAtIEJ1cmlhbCBSZW1peCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowa0c0S2d2YVNBOWtDcjBscjBkbXZVIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTWXFKM3VETExYWk55WmRMS0J5NE0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNZcUozdURMTFhaTnlaZExLQnk0TSIsImlkIjoiMlNZcUozdURMTFhaTnlaZExLQnk0TSIsIm5hbWUiOiJHb2xkaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNZcUozdURMTFhaTnlaZExLQnk0TSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzF5enZrRTdLUHA5QUdyRVBmaUlIem4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xeXp2a0U3S1BwOUFHckVQZmlJSHpuIiwiaWQiOiIxeXp2a0U3S1BwOUFHckVQZmlJSHpuIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2VjMTQ1N2Q3YWZiZTM2YTIzZmE3ODA5MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlYzE0NTdkN2FmYmUzNmEyM2ZhNzgwOTIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVjMTQ1N2Q3YWZiZTM2YTIzZmE3ODA5MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbm5lciBDaXR5IExpZmUgKFRpbWVsZXNzIDI1IFJlbWFz", + "dGVyKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTEtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjF5enZrRTdLUHA5QUdyRVBmaUlIem4ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJpZCI6IjJTWXFKM3VETExYWk55WmRMS0J5NE0iLCJuYW1lIjoiR29sZGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTWXFKM3VETExYWk55WmRMS0J5NE0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDIyMTgyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBQVAyMDAwMjM2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zWWVwSTV4cGFYcUlxcDlEdEFTeFRuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM1llcEk1eHBhWHFJcXA5RHRBU3hUbiIsImlkIjoiM1llcEk1eHBhWHFJcXA5RHRBU3hUbiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbm5lciBDaXR5IExpZmUgLSAyMDIwIFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNZZXBJNXhwYVhxSXFwOUR0QVN4VG4ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNZcUozdURMTFhaTnlaZExLQnk0TSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU1lxSjN1RExMWFpOeVpkTEtCeTRNIiwiaWQiOiIyU1lxSjN1RExMWFpOeVpkTEtCeTRNIiwibmFtZSI6IkdvbGRpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU1lxSjN1RExMWFpOeVpkTEtCeTRNIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNjdIUGllT3FEWjZHN1dPTTA5RWdiayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzY3SFBpZU9xRFo2RzdXT00wOUVnYmsiLCJpZCI6IjY3SFBpZU9xRFo2RzdXT00wOUVnYmsiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwcw==", + "Oi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZjAxNTk5ZmRhZjZmYmMwYTNkMWUxMWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGYwMTU5OWZkYWY2ZmJjMGEzZDFlMTFjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwZjAxNTk5ZmRhZjZmYmMwYTNkMWUxMWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGltZWxlc3MiLCJyZWxlYXNlX2RhdGUiOiIxOTk1LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NjdIUGllT3FEWjZHN1dPTTA5RWdiayJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTWXFKM3VETExYWk55WmRMS0J5NE0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNZcUozdURMTFhaTnlaZExLQnk0TSIsImlkIjoiMlNZcUozdURMTFhaTnlaZExLQnk0TSIsIm5hbWUiOiJHb2xkaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNZcUozdURMTFhaTnlaZExLQnk0TSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82cjlnVUQ2YklNc0oyeWMyUGhJZzRFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZyOWdVRDZiSU1zSjJ5YzJQaElnNEUiLCJpZCI6IjZyOWdVRDZiSU1zSjJ5YzJQaElnNEUiLCJuYW1lIjoiUmFiYml0IEluIFRoZSBNb29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZyOWdVRDZiSU1zSjJ5YzJQaElnNEUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjYwNzIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBQVAwMTAwNzk2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8ya2JSUU8xZXFUbmJGYjRMQlJ6VHo5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMmtiUlFPMWVxVG5iRmI0TEJSelR6OSIsImlkIjoiMmtiUlFPMWVxVG5iRmI0TEJSelR6OSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbm5lciBDaXR5IExpZmUgLSBSYWJiaXQncyBTaG9ydCBBdHRlbnRpb24gU3BhbiBFZGl0IiwidHJhY2tfbnVtYmVyIjoxNCwidHlwZQ==", + "IjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJrYlJRTzFlcVRuYkZiNExCUnpUejkifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Inner+City+Life%22+artist%3A%22Goldie%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Wish%20You%20Well%20High%20Contrast&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Wish%20You%20Well%20High%20Contrast&type=track","offset":0,"previous":null,"total":14,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1bDXdxSg3Ve7V7f3bteIyk"},"href":"https://api.spotify.com/v1/artists/1bDXdxSg3Ve7V7f3bteIyk","id":"1bDXdxSg3Ve7V7f3bteIyk","name":"Dreamers Delight","type":"artist","uri":"spotify:artist:1bDXdxSg3Ve7V7f3bteIyk"}],"external_urls":{"spotify":"https://open.spotify.com/album/0NLkagWt5bMPvjjj9By0EV"},"href":"https://api.spotify.com/v1/albums/0NLkagWt5bMPvjjj9By0EV","id":"0NLkagWt5bMPvjjj9By0EV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c5ef76b4e89d992237d88ffb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c5ef76b4e89d992237d88ffb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c5ef76b4e89d992237d88ffb"}],"is_playable":true,"name":"The Journey","release_date":"2021-06-04","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0NLkagWt5bMPvjjj9By0EV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1bDXdxSg3Ve7V7f3bteIyk"},"href":"https://api.spotify.com/v1/artists/1bDXdxSg3Ve7V7f3bteIyk","id":"1bDXdxSg3Ve7V7f3bteIyk","name":"Dreamers Delight","type":"artist","uri":"spotify:artist:1bDXdxSg3Ve7V7f3bteIyk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/36L4aidPfPFcI1KPY1XDFM"},"href":"https://api.spotify.com/v1/artists/36L4aidPfPFcI1KPY1XDFM","id":"36L4aidPfPFcI1KPY1XDFM","name":"MAYLYN","type":"artist","uri":"spotify:artist:36L4aidPfPFcI1KPY1XDFM"}],"disc_number":1,"duration_ms":190699,"explicit":false,"external_ids":{"isrc":"CAN112100223"},"external_urls":{"spotify":"https://open.spotify.com/track/5h8oWLRWiKep2Nh3s7TJnV"},"href":"https://api.spotify.com/v1/tracks/5h8oWLRWiKep2Nh3s7TJnV","id":"5h8oWLRWiKep2Nh3s7TJnV","is_local":false,"is_playable":true,"name":"The Journey","track_number":1,"type":"track","uri":"spotify:track:5h8oWLRWiKep2Nh3s7TJnV"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Qpa8xhGsGitz4WBf4BkpK"},"href":"https://api.spotify.com/v1/artists/6Qpa8xhGsGitz4WBf4BkpK","id":"6Qpa8xhGsGitz4WBf4BkpK","name":"Baker Boy","type":"artist","uri":"spotify:artist:6Qpa8xhGsGitz4WBf4BkpK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0afemm9P2Bb2LL99xHY32n"},"href":"https://api.spotify.com/v1/artists/0afemm9P2Bb2LL99xHY32n","id":"0afemm9P2Bb2LL99xHY32n","name":"Bernard Fanning","type":"artist","uri":"spotify:artist:0afemm9P2Bb2LL99xHY32n"}],"external_urls":{"spotify":"https://open.spotify.com/album/2xd07PANaM6jBT50rfG50U"},"href":"https://api.spotify.com/v1/albums/2xd07PANaM6jBT50rfG50U","id":"2xd07PANaM6jBT50rfG50U","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731daf4d4dac7a02d9da515285"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021daf4d4dac7a02d9da515285"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511daf4d4dac7a02d9da515285"}],"is_playable":true,"name":"Wish You Well (Feat. Bernard Fanning)","release_date":"2022-06-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2xd07PANaM6jBT50rfG50U"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Qpa8xhGsGitz4WBf4BkpK"},"href":"https://api.spotify.com/v1/artists/6Qpa8xhGsGitz4WBf4BkpK","id":"6Qpa8xhGsGitz4WBf4BkpK","name":"Baker Boy","type":"artist","uri":"spotify:artist:6Qpa8xhGsGitz4WBf4BkpK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0afemm9P2Bb2LL99xHY32n"},"href":"https://api.spotify.com/v1/artists/0afemm9P2Bb2LL99xHY32n","id":"0afemm9P2Bb2LL99xHY32n","name":"Bernard Fanning","type":"artist","uri":"spotify:artist:0afemm9P2Bb2LL99xHY32n"}],"disc_number":1,"duration_ms":170868,"explicit":false,"external_ids":{"isrc":"AU2DY2200134"},"external_urls":{"spotify":"https://open.spotify.com/track/18DoMepvkwmJk4CPH0HCbk"},"href":"https://api.spotify.com/v1/tracks/18DoMepvkwmJk4CPH0HCbk","id":"18DoMepvkwmJk4CPH0HCbk","is_local":false,"is_playable":true,"name":"Wish You Well (Feat. Bernard Fanning)","track_number":1,"type":"track","uri":"spotify:track:18DoMepvkwmJk4CPH0HCbk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"external_urls":{"spotify":"https://open.spotify.com/album/7gsWAHLeT0w7es6FofOXk1"},"href":"https://api.spotify.com/v1/albums/7gsWAHLeT0w7es6FofOXk1","id":"7gsWAHLeT0w7es6FofOXk1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732a7db835b912dc5014bd37f4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022a7db835b912dc5014bd37f4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512a7db835b912dc5014bd37f4"}],"is_playable":true,"name":"The Life Of Pablo","release_date":"2016-06-10","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:7gsWAHLeT0w7es6FofOXk1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"disc_number":1,"duration_ms":301586,"explicit":true,"external_ids":{"isrc":"USUM71603082"},"external_urls":{"spotify":"https://open.spotify.com/track/432hUIl3ISDeytYW5XBQ5h"},"href":"https://api.spotify.com/v1/tracks/432hUIl3ISDeytYW5XBQ5h","id":"432hUIl3ISDeytYW5XBQ5h","is_local":false,"is_playable":true,"name":"Wolves","track_number":13,"type":"track","uri":"spotify:track:432hUIl3ISDeytYW5XBQ5h"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RTLRtXjbXI2lSXc6jxlAz"},"href":"https://api.spotify.com/v1/artists/5RTLRtXjbXI2lSXc6jxlAz","id":"5RTLRtXjbXI2lSXc6jxlAz","name":"Ravyn Lenae","type":"artist","uri":"spotify:artist:5RTLRtXjbXI2lSXc6jxlAz"}],"external_urls":{"spotify":"https://open.spotify.com/album/7I4OxTeNnQgLalOEJZzBqG"},"href":"https://api.spotify.com/v1/albums/7I4OxTeNnQgLalOEJZzBqG","id":"7I4OxTeNnQgLalOEJZzBqG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733ab7676f57b866dd4bb04805"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023ab7676f57b866dd4bb04805"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513ab7676f57b866dd4bb04805"}],"is_playable":true,"name":"Blue Island","release_date":"2026-08-07","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:7I4OxTeNnQgLalOEJZzBqG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5RTLRtXjbXI2lSXc6jxlAz"},"href":"https://api.spotify.com/v1/artists/5RTLRtXjbXI2lSXc6jxlAz","id":"5RTLRtXjbXI2lSXc6jxlAz","name":"Ravyn Lenae","type":"artist","uri":"spotify:artist:5RTLRtXjbXI2lSXc6jxlAz"}],"disc_number":1,"duration_ms":210293,"explicit":false,"external_ids":{"isrc":"USAT22603604"},"external_urls":{"spotify":"https://open.spotify.com/track/22TwGp4fTgPdljzpEgrfgz"},"href":"https://api.spotify.com/v1/tracks/22TwGp4fTgPdljzpEgrfgz","id":"22TwGp4fTgPdljzpEgrfgz","is_local":false,"is_playable":true,"name":"Wish You Well","track_number":11,"type":"track","uri":"spotify:track:22TwGp4fTgPdljzpEgrfgz"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3i1A5Z9zQQApPx49tr0B2f"},"href":"https://api.spotify.com/v1/artists/3i1A5Z9zQQApPx49tr0B2f","id":"3i1A5Z9zQQApPx49tr0B2f","name":"High June","type":"artist","uri":"spotify:artist:3i1A5Z9zQQApPx49tr0B2f"}],"external_urls":{"spotify":"https://open.spotify.com/album/5B4NuMhqJ2zFb8gCTtREaW"},"href":"https://api.spotify.com/v1/albums/5B4NuMhqJ2zFb8gCTtREaW","id":"5B4NuMhqJ2zFb8gCTtREaW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733423241f68b80313835e1aa4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023423241f68b80313835e1aa4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513423241f68b80313835e1aa4"}],"is_playable":true,"name":"It Never Really Mattered","release_date":"2024-10-30","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:5B4NuMhqJ2zFb8gCTtREaW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3i1A5Z9zQQApPx49tr0B2f"},"href":"https://api.spotify.com/v1/artists/3i1A5Z9zQQApPx49tr0B2f","id":"3i1A5Z9zQQApPx49tr0B2f","name":"High June","type":"artist","uri":"spotify:artist:3i1A5Z9zQQApPx49tr0B2f"}],"disc_number":1,"duration_ms":258000,"explicit":false,"external_ids":{"isrc":"QZWFK2498266"},"external_urls":{"spotify":"https://open.spotify.com/track/7gH4MoqoPCvtwFVaVT8tuj"},"href":"https://api.spotify.com/v1/tracks/7gH4MoqoPCvtwFVaVT8tuj","id":"7gH4MoqoPCvtwFVaVT8tuj","is_local":false,"is_playable":true,"name":"Coming Home Soon - 2024 Remaster","track_number":3,"type":"track","uri":"spotify:track:7gH4MoqoPCvtwFVaVT8tuj"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0k17h0D3J5VfsdmQ1iZtE9"},"href":"https://api.spotify.com/v1/artists/0k17h0D3J5VfsdmQ1iZtE9","id":"0k17h0D3J5VfsdmQ1iZtE9","name":"Pink Floyd","type":"artist","uri":"spotify:artist:0k17h0D3J5VfsdmQ1iZtE9"}],"external_urls":{"spotify":"https://open.spotify.com/album/53eu9AgHyg3eQNUiePWRHD"},"href":"https://api.spotify.com/v1/albums/53eu9AgHyg3eQNUiePWRHD","id":"53eu9AgHyg3eQNUiePWRHD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bf828e9fdb5c59c9cf8f5e77"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bf828e9fdb5c59c9cf8f5e77"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bf828e9fdb5c59c9cf8f5e77"}],"is_playable":true,"name":"A Foot in the Door: The Best of Pink Floyd","release_date":"2011","release_date_precision":"year","total_tracks":16,"type":"album","uri":"spotify:album:53eu9AgHyg3eQNUiePWRHD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0k17h0D3J5VfsdmQ1iZtE9"},"href":"https://api.spotify.com/v1/artists/0k17h0D3J5VfsdmQ1iZtE9","id":"0k17h0D3J5VfsdmQ1iZtE9","name":"Pink Floyd","type":"artist","uri":"spotify:artist:0k17h0D3J5VfsdmQ1iZtE9"}],"disc_number":1,"duration_ms":304200,"explicit":false,"external_ids":{"isrc":"GBN9Y1600027"},"external_urls":{"spotify":"https://open.spotify.com/track/0GqGrPWhmiRX9BU93AYFOW"},"href":"https://api.spotify.com/v1/tracks/0GqGrPWhmiRX9BU93AYFOW","id":"0GqGrPWhmiRX9BU93AYFOW","is_local":false,"is_playable":true,"name":"Wish You Were Here","track_number":6,"type":"track","uri":"spotify:track:0GqGrPWhmiRX9BU93AYFOW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5YHb2A9DThy2IFLn6z5bkA"},"href":"https://api.spotify.com/v1/artists/5YHb2A9DThy2IFLn6z5bkA","id":"5YHb2A9DThy2IFLn6z5bkA","name":"NYVE","type":"artist","uri":"spotify:artist:5YHb2A9DThy2IFLn6z5bkA"}],"external_urls":{"spotify":"https://open.spotify.com/album/3LvKwWsV65kw0zBuNaChoA"},"href":"https://api.spotify.com/v1/albums/3LvKwWsV65kw0zBuNaChoA","id":"3LvKwWsV65kw0zBuNaChoA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a3c09467c695874c40eabaed"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a3c09467c695874c40eabaed"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a3c09467c695874c40eabaed"}],"is_playable":true,"name":"I Wish You Well","release_date":"2026-05-01","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3LvKwWsV65kw0zBuNaChoA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5YHb2A9DThy2IFLn6z5bkA"},"href":"https://api.spotify.com/v1/artists/5YHb2A9DThy2IFLn6z5bkA","id":"5YHb2A9DThy2IFLn6z5bkA","name":"NYVE","type":"artist","uri":"spotify:artist:5YHb2A9DThy2IFLn6z5bkA"}],"disc_number":1,"duration_ms":200253,"explicit":false,"external_ids":{"isrc":"NL4SK2600005"},"external_urls":{"spotify":"https://open.spotify.com/track/62MQQhu3ljO21zGvjWEJYV"},"href":"https://api.spotify.com/v1/tracks/62MQQhu3ljO21zGvjWEJYV","id":"62MQQhu3ljO21zGvjWEJYV","is_local":false,"is_playable":true,"name":"I Wish You Well","track_number":1,"type":"track","uri":"spotify:track:62MQQhu3ljO21zGvjWEJYV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZHU5AKrUmIPnCFfr82QER"},"href":"https://api.spotify.com/v1/artists/3ZHU5AKrUmIPnCFfr82QER","id":"3ZHU5AKrUmIPnCFfr82QER","name":"1nonly","type":"artist","uri":"spotify:artist:3ZHU5AKrUmIPnCFfr82QER"}],"external_urls":{"spotify":"https://open.spotify.com/album/7AEttdVjADpIvjqDbSsFDi"},"href":"https://api.spotify.com/v1/albums/7AEttdVjADpIvjqDbSsFDi","id":"7AEttdVjADpIvjqDbSsFDi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bedaa132a338e186689c1d18"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bedaa132a338e186689c1d18"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bedaa132a338e186689c1d18"}],"is_playable":true,"name":"ONLY IF I DIE, WOULD I NOT BE","release_date":"2026-02-20","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7AEttdVjADpIvjqDbSsFDi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZHU5AKrUmIPnCFfr82QER"},"href":"https://api.spotify.com/v1/artists/3ZHU5AKrUmIPnCFfr82QER","id":"3ZHU5AKrUmIPnCFfr82QER","name":"1nonly","type":"artist","uri":"spotify:artist:3ZHU5AKrUmIPnCFfr82QER"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlDsD7y6ccmDm8tuWCU6F"},"href":"https://api.spotify.com/v1/artists/0dlDsD7y6ccmDm8tuWCU6F","id":"0dlDsD7y6ccmDm8tuWCU6F","name":"Freddie Dredd","type":"artist","uri":"spotify:artist:0dlDsD7y6ccmDm8tuWCU6F"}],"disc_number":1,"duration_ms":141021,"explicit":false,"external_ids":{"isrc":"QT4K52565569"},"external_urls":{"spotify":"https://open.spotify.com/track/0HfCBwaSDXXHVTNLdGoIRd"},"href":"https://api.spotify.com/v1/tracks/0HfCBwaSDXXHVTNLdGoIRd","id":"0HfCBwaSDXXHVTNLdGoIRd","is_local":false,"is_playable":true,"name":"GRAILED","track_number":4,"type":"track","uri":"spotify:track:0HfCBwaSDXXHVTNLdGoIRd"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZHU5AKrUmIPnCFfr82QER"},"href":"https://api.spotify.com/v1/artists/3ZHU5AKrUmIPnCFfr82QER","id":"3ZHU5AKrUmIPnCFfr82QER","name":"1nonly","type":"artist","uri":"spotify:artist:3ZHU5AKrUmIPnCFfr82QER"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlDsD7y6ccmDm8tuWCU6F"},"href":"https://api.spotify.com/v1/artists/0dlDsD7y6ccmDm8tuWCU6F","id":"0dlDsD7y6ccmDm8tuWCU6F","name":"Freddie Dredd","type":"artist","uri":"spotify:artist:0dlDsD7y6ccmDm8tuWCU6F"}],"external_urls":{"spotify":"https://open.spotify.com/album/2dGkMTeBCmQKOTMB0vsod3"},"href":"https://api.spotify.com/v1/albums/2dGkMTeBCmQKOTMB0vsod3","id":"2dGkMTeBCmQKOTMB0vsod3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27365929eb27536119fee72d423"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0265929eb27536119fee72d423"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485165929eb27536119fee72d423"}],"is_playable":true,"name":"GRAILED","release_date":"2025-07-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2dGkMTeBCmQKOTMB0vsod3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZHU5AKrUmIPnCFfr82QER"},"href":"https://api.spotify.com/v1/artists/3ZHU5AKrUmIPnCFfr82QER","id":"3ZHU5AKrUmIPnCFfr82QER","name":"1nonly","type":"artist","uri":"spotify:artist:3ZHU5AKrUmIPnCFfr82QER"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlDsD7y6ccmDm8tuWCU6F"},"href":"https://api.spotify.com/v1/artists/0dlDsD7y6ccmDm8tuWCU6F","id":"0dlDsD7y6ccmDm8tuWCU6F","name":"Freddie Dredd","type":"artist","uri":"spotify:artist:0dlDsD7y6ccmDm8tuWCU6F"}],"disc_number":1,"duration_ms":141021,"explicit":true,"external_ids":{"isrc":"QT4K52565569"},"external_urls":{"spotify":"https://open.spotify.com/track/2Kvmj9ifFwU4KUEvZDr0ud"},"href":"https://api.spotify.com/v1/tracks/2Kvmj9ifFwU4KUEvZDr0ud","id":"2Kvmj9ifFwU4KUEvZDr0ud","is_local":false,"is_playable":true,"name":"GRAILED","track_number":1,"type":"track","uri":"spotify:track:2Kvmj9ifFwU4KUEvZDr0ud"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZHU5AKrUmIPnCFfr82QER"},"href":"https://api.spotify.com/v1/artists/3ZHU5AKrUmIPnCFfr82QER","id":"3ZHU5AKrUmIPnCFfr82QER","name":"1nonly","type":"artist","uri":"spotify:artist:3ZHU5AKrUmIPnCFfr82QER"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlDsD7y6ccmDm8tuWCU6F"},"href":"https://api.spotify.com/v1/artists/0dlDsD7y6ccmDm8tuWCU6F","id":"0dlDsD7y6ccmDm8tuWCU6F","name":"Freddie Dredd","type":"artist","uri":"spotify:artist:0dlDsD7y6ccmDm8tuWCU6F"}],"external_urls":{"spotify":"https://open.spotify.com/album/5607tnnJMCbSZ2Gmivw2Vl"},"href":"https://api.spotify.com/v1/albums/5607tnnJMCbSZ2Gmivw2Vl","id":"5607tnnJMCbSZ2Gmivw2Vl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d82dd1bff15168928d1de3c5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d82dd1bff15168928d1de3c5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d82dd1bff15168928d1de3c5"}],"is_playable":true,"name":"GRAILED","release_date":"2025-09-19","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:5607tnnJMCbSZ2Gmivw2Vl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZHU5AKrUmIPnCFfr82QER"},"href":"https://api.spotify.com/v1/artists/3ZHU5AKrUmIPnCFfr82QER","id":"3ZHU5AKrUmIPnCFfr82QER","name":"1nonly","type":"artist","uri":"spotify:artist:3ZHU5AKrUmIPnCFfr82QER"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlDsD7y6ccmDm8tuWCU6F"},"href":"https://api.spotify.com/v1/artists/0dlDsD7y6ccmDm8tuWCU6F","id":"0dlDsD7y6ccmDm8tuWCU6F","name":"Freddie Dredd","type":"artist","uri":"spotify:artist:0dlDsD7y6ccmDm8tuWCU6F"}],"disc_number":1,"duration_ms":141021,"explicit":true,"external_ids":{"isrc":"QT4K52565569"},"external_urls":{"spotify":"https://open.spotify.com/track/1xOVEOJPvdmWPgZjjiroG9"},"href":"https://api.spotify.com/v1/tracks/1xOVEOJPvdmWPgZjjiroG9","id":"1xOVEOJPvdmWPgZjjiroG9","is_local":false,"is_playable":true,"name":"GRAILED","track_number":1,"type":"track","uri":"spotify:track:1xOVEOJPvdmWPgZjjiroG9"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1XaXNoJTIwWW91JTIwV2VsbCUyMEhpZ2glMjBDb250cmFzdCZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvc2VhcmNoP29mZnNldD0xMCZsaW1pdD0xMCZxdWVyeT1XaXNoJTIwWW91JTIwV2VsbCUyMEhpZ2glMjBDb250cmFzdCZ0eXBlPXRyYWNrIiwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjE0LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMWJEWGR4U2czVmU3VjdmM2J0ZUl5ayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xYkRYZHhTZzNWZTdWN2YzYnRlSXlrIiwiaWQiOiIxYkRYZHhTZzNWZTdWN2YzYnRlSXlrIiwibmFtZSI6IkRyZWFtZXJzIERlbGlnaHQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MWJEWGR4U2czVmU3VjdmM2J0ZUl5ayJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBOTGthZ1d0NWJNUHZqamo5QnkwRVYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wTkxrYWdXdDViTVB2ampqOUJ5MEVWIiwi", + "aWQiOiIwTkxrYWdXdDViTVB2ampqOUJ5MEVWIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2M1ZWY3NmI0ZTg5ZDk5MjIzN2Q4OGZmYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjNWVmNzZiNGU4OWQ5OTIyMzdkODhmZmIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM1ZWY3NmI0ZTg5ZDk5MjIzN2Q4OGZmYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgSm91cm5leSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDYtMDQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBOTGthZ1d0NWJNUHZqamo5QnkwRVYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xYkRYZHhTZzNWZTdWN2YzYnRlSXlrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFiRFhkeFNnM1ZlN1Y3ZjNidGVJeWsiLCJpZCI6IjFiRFhkeFNnM1ZlN1Y3ZjNidGVJeWsiLCJuYW1lIjoiRHJlYW1lcnMgRGVsaWdodCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxYkRYZHhTZzNWZTdWN2YzYnRlSXlrIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzM2TDRhaWRQZlBGY0kxS1BZMVhERk0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzZMNGFpZFBmUEZjSTFLUFkxWERGTSIsImlkIjoiMzZMNGFpZFBmUEZjSTFLUFkxWERGTSIsIm5hbWUiOiJNQVlMWU4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MzZMNGFpZFBmUEZjSTFLUFkxWERGTSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTA2OTksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJDQU4xMTIxMDAyMjMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVoOG9XTFJXaUtlcDJOaDNzN1RKblYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81aDhvV0xSV2lLZXAyTmgzczdUSm5WIiwiaWQiOiI1aDhvV0xSV2lLZXAyTmgzczdUSm5WIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ig==", + "VGhlIEpvdXJuZXkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NWg4b1dMUldpS2VwMk5oM3M3VEpuViJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlFwYTh4aEdzR2l0ejRXQmY0QmtwSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82UXBhOHhoR3NHaXR6NFdCZjRCa3BLIiwiaWQiOiI2UXBhOHhoR3NHaXR6NFdCZjRCa3BLIiwibmFtZSI6IkJha2VyIEJveSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2UXBhOHhoR3NHaXR6NFdCZjRCa3BLIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBhZmVtbTlQMkJiMkxMOTl4SFkzMm4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGFmZW1tOVAyQmIyTEw5OXhIWTMybiIsImlkIjoiMGFmZW1tOVAyQmIyTEw5OXhIWTMybiIsIm5hbWUiOiJCZXJuYXJkIEZhbm5pbmciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGFmZW1tOVAyQmIyTEw5OXhIWTMybiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJ4ZDA3UEFOYU02akJUNTByZkc1MFUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yeGQwN1BBTmFNNmpCVDUwcmZHNTBVIiwiaWQiOiIyeGQwN1BBTmFNNmpCVDUwcmZHNTBVIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzFkYWY0ZDRkYWM3YTAyZDlkYTUxNTI4NSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxZGFmNGQ0ZGFjN2EwMmQ5ZGE1MTUyODUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTFkYWY0ZDRkYWM3YTAyZDlkYTUxNTI4NSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXaXNoIFlvdSBXZWxsIChGZWF0LiBCZXJuYXJkIEZhbm5pbmcpIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0wNi0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MnhkMDdQQU5hTTZqQlQ1MHJmRzUwVSJ9LCJhcnRpc3RzIjpbeyJleA==", + "dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlFwYTh4aEdzR2l0ejRXQmY0QmtwSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82UXBhOHhoR3NHaXR6NFdCZjRCa3BLIiwiaWQiOiI2UXBhOHhoR3NHaXR6NFdCZjRCa3BLIiwibmFtZSI6IkJha2VyIEJveSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2UXBhOHhoR3NHaXR6NFdCZjRCa3BLIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBhZmVtbTlQMkJiMkxMOTl4SFkzMm4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGFmZW1tOVAyQmIyTEw5OXhIWTMybiIsImlkIjoiMGFmZW1tOVAyQmIyTEw5OXhIWTMybiIsIm5hbWUiOiJCZXJuYXJkIEZhbm5pbmciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGFmZW1tOVAyQmIyTEw5OXhIWTMybiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzA4NjgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJBVTJEWTIyMDAxMzQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzE4RG9NZXB2a3dtSms0Q1BIMEhDYmsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xOERvTWVwdmt3bUprNENQSDBIQ2JrIiwiaWQiOiIxOERvTWVwdmt3bUprNENQSDBIQ2JrIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ildpc2ggWW91IFdlbGwgKEZlYXQuIEJlcm5hcmQgRmFubmluZykiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MThEb01lcHZrd21KazRDUEgwSENiayJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81SzRXNnJxQkZXRG5BTjZGUVVrUzZ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVLNFc2cnFCRldEbkFONkZRVWtTNngiLCJpZCI6IjVLNFc2cnFCRldEbkFONkZRVWtTNngiLCJuYW1lIjoiS2FueWUgV2VzdCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1SzRXNnJxQkZXRG5BTjZGUVVrUzZ4In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN2dzV0FITGVUMHc3ZXM2Rm9mT1hrMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcA==", + "aS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN2dzV0FITGVUMHc3ZXM2Rm9mT1hrMSIsImlkIjoiN2dzV0FITGVUMHc3ZXM2Rm9mT1hrMSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyYTdkYjgzNWI5MTJkYzUwMTRiZDM3ZjQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmE3ZGI4MzViOTEyZGM1MDE0YmQzN2Y0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyYTdkYjgzNWI5MTJkYzUwMTRiZDM3ZjQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIExpZmUgT2YgUGFibG8iLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTA2LTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N2dzV0FITGVUMHc3ZXM2Rm9mT1hrMSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVLNFc2cnFCRldEbkFONkZRVWtTNngifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUs0VzZycUJGV0RuQU42RlFVa1M2eCIsImlkIjoiNUs0VzZycUJGV0RuQU42RlFVa1M2eCIsIm5hbWUiOiJLYW55ZSBXZXN0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVLNFc2cnFCRldEbkFONkZRVWtTNngifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzAxNTg2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzE2MDMwODIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzQzMmhVSWwzSVNEZXl0WVc1WEJRNWgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80MzJoVUlsM0lTRGV5dFlXNVhCUTVoIiwiaWQiOiI0MzJoVUlsM0lTRGV5dFlXNVhCUTVoIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldvbHZlcyIsInRyYWNrX251bWJlciI6MTMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NDMyaFVJbDNJU0RleXRZVzVYQlE1aCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81UlRMUnRYamJYSTJsU1hjNmp4bEF6Ig==", + "fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJUTFJ0WGpiWEkybFNYYzZqeGxBeiIsImlkIjoiNVJUTFJ0WGpiWEkybFNYYzZqeGxBeiIsIm5hbWUiOiJSYXZ5biBMZW5hZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1UlRMUnRYamJYSTJsU1hjNmp4bEF6In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN0k0T3hUZU5uUWdMYWxPRUpaekJxRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdJNE94VGVOblFnTGFsT0VKWnpCcUciLCJpZCI6IjdJNE94VGVOblFnTGFsT0VKWnpCcUciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczM2FiNzY3NmY1N2I4NjZkZDRiYjA0ODA1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjNhYjc2NzZmNTdiODY2ZGQ0YmIwNDgwNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxM2FiNzY3NmY1N2I4NjZkZDRiYjA0ODA1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJsdWUgSXNsYW5kIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wOC0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdJNE94VGVOblFnTGFsT0VKWnpCcUcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81UlRMUnRYamJYSTJsU1hjNmp4bEF6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVSVExSdFhqYlhJMmxTWGM2anhsQXoiLCJpZCI6IjVSVExSdFhqYlhJMmxTWGM2anhsQXoiLCJuYW1lIjoiUmF2eW4gTGVuYWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVJUTFJ0WGpiWEkybFNYYzZqeGxBeiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTAyOTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FUMjI2MDM2MDQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzIyVHdHcDRmVGdQZGxqenBFZ3JmZ3oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yMlR3R3A0ZlRnUGRsanpwRWdyZmd6IiwiaWQiOg==", + "IjIyVHdHcDRmVGdQZGxqenBFZ3JmZ3oiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2lzaCBZb3UgV2VsbCIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MjJUd0dwNGZUZ1BkbGp6cEVncmZneiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2kxQTVaOXpRUUFwUHg0OXRyMEIyZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zaTFBNVo5elFRQXBQeDQ5dHIwQjJmIiwiaWQiOiIzaTFBNVo5elFRQXBQeDQ5dHIwQjJmIiwibmFtZSI6IkhpZ2ggSnVuZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozaTFBNVo5elFRQXBQeDQ5dHIwQjJmIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUI0TnVNaHFKMnpGYjhnQ1R0UkVhVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVCNE51TWhxSjJ6RmI4Z0NUdFJFYVciLCJpZCI6IjVCNE51TWhxSjJ6RmI4Z0NUdFJFYVciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzQyMzI0MWY2OGI4MDMxMzgzNWUxYWE0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjM0MjMyNDFmNjhiODAzMTM4MzVlMWFhNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzQyMzI0MWY2OGI4MDMxMzgzNWUxYWE0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikl0IE5ldmVyIFJlYWxseSBNYXR0ZXJlZCIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMTAtMzAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVCNE51TWhxSjJ6RmI4Z0NUdFJFYVcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zaTFBNVo5elFRQXBQeDQ5dHIwQjJmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNpMUE1Wjl6UVFBcFB4NDl0cjBCMmYiLCJpZCI6IjNpMUE1Wjl6UVFBcFB4NDl0cjBCMmYiLCJuYW1lIjoiSGlnaCBKdW5lIiwidHlwZSI6ImFydGlzdA==", + "IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2kxQTVaOXpRUUFwUHg0OXRyMEIyZiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTgwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWldGSzI0OTgyNjYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdnSDRNb3FvUEN2dHdGVmFWVDh0dWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83Z0g0TW9xb1BDdnR3RlZhVlQ4dHVqIiwiaWQiOiI3Z0g0TW9xb1BDdnR3RlZhVlQ4dHVqIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbWluZyBIb21lIFNvb24gLSAyMDI0IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdnSDRNb3FvUEN2dHdGVmFWVDh0dWoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGsxN2gwRDNKNVZmc2RtUTFpWnRFOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wazE3aDBEM0o1VmZzZG1RMWladEU5IiwiaWQiOiIwazE3aDBEM0o1VmZzZG1RMWladEU5IiwibmFtZSI6IlBpbmsgRmxveWQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGsxN2gwRDNKNVZmc2RtUTFpWnRFOSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzUzZXU5QWdIeWczZVFOVWllUFdSSEQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81M2V1OUFnSHlnM2VRTlVpZVBXUkhEIiwiaWQiOiI1M2V1OUFnSHlnM2VRTlVpZVBXUkhEIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2JmODI4ZTlmZGI1YzU5YzljZjhmNWU3NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiZjgyOGU5ZmRiNWM1OWM5Y2Y4ZjVlNzcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWJmODI4ZTlmZGI1YzU5YzljZjhmNWU3NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBIEZvb3QgaW4gdGhlIERvb3I6IFRoZSBCZXN0IG9mIFBpbmsgRmxveWQiLCJyZWxlYXNlX2RhdGUiOiIyMDExIiwicg==", + "ZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NTNldTlBZ0h5ZzNlUU5VaWVQV1JIRCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBrMTdoMEQzSjVWZnNkbVExaVp0RTkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGsxN2gwRDNKNVZmc2RtUTFpWnRFOSIsImlkIjoiMGsxN2gwRDNKNVZmc2RtUTFpWnRFOSIsIm5hbWUiOiJQaW5rIEZsb3lkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBrMTdoMEQzSjVWZnNkbVExaVp0RTkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzA0MjAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JOOVkxNjAwMDI3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wR3FHclBXaG1pUlg5QlU5M0FZRk9XIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMEdxR3JQV2htaVJYOUJVOTNBWUZPVyIsImlkIjoiMEdxR3JQV2htaVJYOUJVOTNBWUZPVyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXaXNoIFlvdSBXZXJlIEhlcmUiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MEdxR3JQV2htaVJYOUJVOTNBWUZPVyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVlIYjJBOURUaHkySUZMbjZ6NWJrQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81WUhiMkE5RFRoeTJJRkxuNno1YmtBIiwiaWQiOiI1WUhiMkE5RFRoeTJJRkxuNno1YmtBIiwibmFtZSI6Ik5ZVkUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVlIYjJBOURUaHkySUZMbjZ6NWJrQSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNMdkt3V3NWNjVrdzB6QnVOYUNob0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zTHZLd1dzVjY1a3cwekJ1TmFDaG9BIiwiaWQiOiIzTHZLd1dzVjY1a3cwekJ1TmFDaG9BIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2EzYzA5NDY3Yw==", + "Njk1ODc0YzQwZWFiYWVkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEzYzA5NDY3YzY5NTg3NGM0MGVhYmFlZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTNjMDk0NjdjNjk1ODc0YzQwZWFiYWVkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkkgV2lzaCBZb3UgV2VsbCIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDUtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNMdkt3V3NWNjVrdzB6QnVOYUNob0EifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81WUhiMkE5RFRoeTJJRkxuNno1YmtBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVZSGIyQTlEVGh5MklGTG42ejVia0EiLCJpZCI6IjVZSGIyQTlEVGh5MklGTG42ejVia0EiLCJuYW1lIjoiTllWRSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1WUhiMkE5RFRoeTJJRkxuNno1YmtBIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwMDI1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MNFNLMjYwMDAwNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNjJNUVFodTNsak8yMXpHdmpXRUpZViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzYyTVFRaHUzbGpPMjF6R3ZqV0VKWVYiLCJpZCI6IjYyTVFRaHUzbGpPMjF6R3ZqV0VKWVYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSBXaXNoIFlvdSBXZWxsIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjYyTVFRaHUzbGpPMjF6R3ZqV0VKWVYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1pIVTVBS3JVbUlQbkNGZnI4MlFFUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zWkhVNUFLclVtSVBuQ0ZmcjgyUUVSIiwiaWQiOiIzWkhVNUFLclVtSVBuQ0ZmcjgyUUVSIiwibmFtZSI6IjFub25seSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozWkhVNUFLclVtSVBuQ0Zmcg==", + "ODJRRVIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83QUV0dGRWakFEcEl2anFEYlNzRkRpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0FFdHRkVmpBRHBJdmpxRGJTc0ZEaSIsImlkIjoiN0FFdHRkVmpBRHBJdmpxRGJTc0ZEaSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiZWRhYTEzMmEzMzhlMTg2Njg5YzFkMTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmVkYWExMzJhMzM4ZTE4NjY4OWMxZDE4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiZWRhYTEzMmEzMzhlMTg2Njg5YzFkMTgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT05MWSBJRiBJIERJRSwgV09VTEQgSSBOT1QgQkUiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTAyLTIwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0FFdHRkVmpBRHBJdmpxRGJTc0ZEaSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNaSFU1QUtyVW1JUG5DRmZyODJRRVIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM1pIVTVBS3JVbUlQbkNGZnI4MlFFUiIsImlkIjoiM1pIVTVBS3JVbUlQbkNGZnI4MlFFUiIsIm5hbWUiOiIxbm9ubHkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1pIVTVBS3JVbUlQbkNGZnI4MlFFUiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZGxEc0Q3eTZjY21EbTh0dVdDVTZGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBkbERzRDd5NmNjbURtOHR1V0NVNkYiLCJpZCI6IjBkbERzRDd5NmNjbURtOHR1V0NVNkYiLCJuYW1lIjoiRnJlZGRpZSBEcmVkZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZGxEc0Q3eTZjY21EbTh0dVdDVTZGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0MTAyMSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFUNEs1MjU2NTU2OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeQ==", + "LmNvbS90cmFjay8wSGZDQndhU0RYWEhWVE5MZEdvSVJkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMEhmQ0J3YVNEWFhIVlROTGRHb0lSZCIsImlkIjoiMEhmQ0J3YVNEWFhIVlROTGRHb0lSZCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHUkFJTEVEIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBIZkNCd2FTRFhYSFZUTkxkR29JUmQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNaSFU1QUtyVW1JUG5DRmZyODJRRVIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM1pIVTVBS3JVbUlQbkNGZnI4MlFFUiIsImlkIjoiM1pIVTVBS3JVbUlQbkNGZnI4MlFFUiIsIm5hbWUiOiIxbm9ubHkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1pIVTVBS3JVbUlQbkNGZnI4MlFFUiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZGxEc0Q3eTZjY21EbTh0dVdDVTZGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBkbERzRDd5NmNjbURtOHR1V0NVNkYiLCJpZCI6IjBkbERzRDd5NmNjbURtOHR1V0NVNkYiLCJuYW1lIjoiRnJlZGRpZSBEcmVkZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZGxEc0Q3eTZjY21EbTh0dVdDVTZGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMmRHa01UZUJDbVFLT1RNQjB2c29kMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJkR2tNVGVCQ21RS09UTUIwdnNvZDMiLCJpZCI6IjJkR2tNVGVCQ21RS09UTUIwdnNvZDMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNjU5MjllYjI3NTM2MTE5ZmVlNzJkNDIzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjY1OTI5ZWIyNzUzNjExOWZlZTcyZDQyMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjU5MjllYjI3NTM2MTE5ZmVlNzJkNDIzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdSQUlMRUQiLCJyZWxlYXNlX2RhdGUiOg==", + "IjIwMjUtMDctMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJkR2tNVGVCQ21RS09UTUIwdnNvZDMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zWkhVNUFLclVtSVBuQ0ZmcjgyUUVSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNaSFU1QUtyVW1JUG5DRmZyODJRRVIiLCJpZCI6IjNaSFU1QUtyVW1JUG5DRmZyODJRRVIiLCJuYW1lIjoiMW5vbmx5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNaSFU1QUtyVW1JUG5DRmZyODJRRVIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGRsRHNEN3k2Y2NtRG04dHVXQ1U2RiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wZGxEc0Q3eTZjY21EbTh0dVdDVTZGIiwiaWQiOiIwZGxEc0Q3eTZjY21EbTh0dVdDVTZGIiwibmFtZSI6IkZyZWRkaWUgRHJlZGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGRsRHNEN3k2Y2NtRG04dHVXQ1U2RiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDEwMjEsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFUNEs1MjU2NTU2OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMkt2bWo5aWZGd1U0S1VFdlpEcjB1ZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJLdm1qOWlmRndVNEtVRXZaRHIwdWQiLCJpZCI6IjJLdm1qOWlmRndVNEtVRXZaRHIwdWQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR1JBSUxFRCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyS3ZtajlpZkZ3VTRLVUV2WkRyMHVkIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zWkhVNUFLclVtSVBuQ0ZmcjgyUUVSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNaSFU1QUtyVW1JUG5DRmZyODJRRVIiLCJpZCI6IjNaSFU1QUtyVW1JUG5DRmZyODJRRVIiLCJuYW1lIjoiMW5vbmx5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNaSFU1QUtyVW1JUG5DRmZyODJRRVIifSx7ImV4dA==", + "ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZGxEc0Q3eTZjY21EbTh0dVdDVTZGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBkbERzRDd5NmNjbURtOHR1V0NVNkYiLCJpZCI6IjBkbERzRDd5NmNjbURtOHR1V0NVNkYiLCJuYW1lIjoiRnJlZGRpZSBEcmVkZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZGxEc0Q3eTZjY21EbTh0dVdDVTZGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNTYwN3RubkpNQ2JTWjJHbWl2dzJWbCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzU2MDd0bm5KTUNiU1oyR21pdncyVmwiLCJpZCI6IjU2MDd0bm5KTUNiU1oyR21pdncyVmwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDgyZGQxYmZmMTUxNjg5MjhkMWRlM2M1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQ4MmRkMWJmZjE1MTY4OTI4ZDFkZTNjNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDgyZGQxYmZmMTUxNjg5MjhkMWRlM2M1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdSQUlMRUQiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA5LTE5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1NjA3dG5uSk1DYlNaMkdtaXZ3MlZsIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1pIVTVBS3JVbUlQbkNGZnI4MlFFUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zWkhVNUFLclVtSVBuQ0ZmcjgyUUVSIiwiaWQiOiIzWkhVNUFLclVtSVBuQ0ZmcjgyUUVSIiwibmFtZSI6IjFub25seSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozWkhVNUFLclVtSVBuQ0ZmcjgyUUVSIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBkbERzRDd5NmNjbURtOHR1V0NVNkYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGRsRHNEN3k2Y2NtRG04dHVXQ1U2RiIsImlkIjoiMGRsRHNEN3k2Y2NtRG04dHVXQw==", + "VTZGIiwibmFtZSI6IkZyZWRkaWUgRHJlZGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGRsRHNEN3k2Y2NtRG04dHVXQ1U2RiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDEwMjEsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFUNEs1MjU2NTU2OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXhPVkVPSlB2ZG1XUGdaamppcm9HOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzF4T1ZFT0pQdmRtV1BnWmpqaXJvRzkiLCJpZCI6IjF4T1ZFT0pQdmRtV1BnWmpqaXJvRzkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR1JBSUxFRCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxeE9WRU9KUHZkbVdQZ1pqamlyb0c5In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Wish+You+Well+High+Contrast&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Speed%20Trials%20Goldie&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Speed%20Trials%20Goldie&type=track","offset":0,"previous":null,"total":11,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ApaG60P4r0yhBoDCGD8YG"},"href":"https://api.spotify.com/v1/artists/2ApaG60P4r0yhBoDCGD8YG","id":"2ApaG60P4r0yhBoDCGD8YG","name":"Elliott Smith","type":"artist","uri":"spotify:artist:2ApaG60P4r0yhBoDCGD8YG"}],"external_urls":{"spotify":"https://open.spotify.com/album/5hryhrT7wEdLnZCbJX9F6L"},"href":"https://api.spotify.com/v1/albums/5hryhrT7wEdLnZCbJX9F6L","id":"5hryhrT7wEdLnZCbJX9F6L","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ea7ac80765aa4549d18a27b9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ea7ac80765aa4549d18a27b9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ea7ac80765aa4549d18a27b9"}],"is_playable":true,"name":"Either/Or","release_date":"1997-02-25","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5hryhrT7wEdLnZCbJX9F6L"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ApaG60P4r0yhBoDCGD8YG"},"href":"https://api.spotify.com/v1/artists/2ApaG60P4r0yhBoDCGD8YG","id":"2ApaG60P4r0yhBoDCGD8YG","name":"Elliott Smith","type":"artist","uri":"spotify:artist:2ApaG60P4r0yhBoDCGD8YG"}],"disc_number":1,"duration_ms":182560,"explicit":false,"external_ids":{"isrc":"USKRS0326901"},"external_urls":{"spotify":"https://open.spotify.com/track/4gRySBzWoWD2JqEFZnfPuX"},"href":"https://api.spotify.com/v1/tracks/4gRySBzWoWD2JqEFZnfPuX","id":"4gRySBzWoWD2JqEFZnfPuX","is_local":false,"is_playable":true,"name":"Speed Trials","track_number":1,"type":"track","uri":"spotify:track:4gRySBzWoWD2JqEFZnfPuX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1anyVhU62p31KFi8MEzkbf"},"href":"https://api.spotify.com/v1/artists/1anyVhU62p31KFi8MEzkbf","id":"1anyVhU62p31KFi8MEzkbf","name":"Chance the Rapper","type":"artist","uri":"spotify:artist:1anyVhU62p31KFi8MEzkbf"}],"external_urls":{"spotify":"https://open.spotify.com/album/4if1BvvWfmG4go4uAmow8h"},"href":"https://api.spotify.com/v1/albums/4if1BvvWfmG4go4uAmow8h","id":"4if1BvvWfmG4go4uAmow8h","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738662864101c7b89d77ff2e3e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028662864101c7b89d77ff2e3e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518662864101c7b89d77ff2e3e"}],"is_playable":true,"name":"STAR LINE","release_date":"2025-08-15","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:4if1BvvWfmG4go4uAmow8h"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1anyVhU62p31KFi8MEzkbf"},"href":"https://api.spotify.com/v1/artists/1anyVhU62p31KFi8MEzkbf","id":"1anyVhU62p31KFi8MEzkbf","name":"Chance the Rapper","type":"artist","uri":"spotify:artist:1anyVhU62p31KFi8MEzkbf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0u6b6Qa5VJEvr3SgzzeVOB"},"href":"https://api.spotify.com/v1/artists/0u6b6Qa5VJEvr3SgzzeVOB","id":"0u6b6Qa5VJEvr3SgzzeVOB","name":"Do Or Die","type":"artist","uri":"spotify:artist:0u6b6Qa5VJEvr3SgzzeVOB"}],"disc_number":1,"duration_ms":179368,"explicit":true,"external_ids":{"isrc":"GXHG92506333"},"external_urls":{"spotify":"https://open.spotify.com/track/7M6yyDtLr2UvdSfpM30oDe"},"href":"https://api.spotify.com/v1/tracks/7M6yyDtLr2UvdSfpM30oDe","id":"7M6yyDtLr2UvdSfpM30oDe","is_local":false,"is_playable":true,"name":"Ride (feat. Do or Die)","track_number":2,"type":"track","uri":"spotify:track:7M6yyDtLr2UvdSfpM30oDe"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1anyVhU62p31KFi8MEzkbf"},"href":"https://api.spotify.com/v1/artists/1anyVhU62p31KFi8MEzkbf","id":"1anyVhU62p31KFi8MEzkbf","name":"Chance the Rapper","type":"artist","uri":"spotify:artist:1anyVhU62p31KFi8MEzkbf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0u6b6Qa5VJEvr3SgzzeVOB"},"href":"https://api.spotify.com/v1/artists/0u6b6Qa5VJEvr3SgzzeVOB","id":"0u6b6Qa5VJEvr3SgzzeVOB","name":"Do Or Die","type":"artist","uri":"spotify:artist:0u6b6Qa5VJEvr3SgzzeVOB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6vbY3hOaCAhC7VjucswgdS"},"href":"https://api.spotify.com/v1/artists/6vbY3hOaCAhC7VjucswgdS","id":"6vbY3hOaCAhC7VjucswgdS","name":"Twista","type":"artist","uri":"spotify:artist:6vbY3hOaCAhC7VjucswgdS"}],"external_urls":{"spotify":"https://open.spotify.com/album/1E1Mc2Y52Dp6uN1fRENcKB"},"href":"https://api.spotify.com/v1/albums/1E1Mc2Y52Dp6uN1fRENcKB","id":"1E1Mc2Y52Dp6uN1fRENcKB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27332f1d2a31896f3fe97e395b9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0232f1d2a31896f3fe97e395b9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485132f1d2a31896f3fe97e395b9"}],"is_playable":true,"name":"Ride (Remix)","release_date":"2025-08-14","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:1E1Mc2Y52Dp6uN1fRENcKB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1anyVhU62p31KFi8MEzkbf"},"href":"https://api.spotify.com/v1/artists/1anyVhU62p31KFi8MEzkbf","id":"1anyVhU62p31KFi8MEzkbf","name":"Chance the Rapper","type":"artist","uri":"spotify:artist:1anyVhU62p31KFi8MEzkbf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0u6b6Qa5VJEvr3SgzzeVOB"},"href":"https://api.spotify.com/v1/artists/0u6b6Qa5VJEvr3SgzzeVOB","id":"0u6b6Qa5VJEvr3SgzzeVOB","name":"Do Or Die","type":"artist","uri":"spotify:artist:0u6b6Qa5VJEvr3SgzzeVOB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6vbY3hOaCAhC7VjucswgdS"},"href":"https://api.spotify.com/v1/artists/6vbY3hOaCAhC7VjucswgdS","id":"6vbY3hOaCAhC7VjucswgdS","name":"Twista","type":"artist","uri":"spotify:artist:6vbY3hOaCAhC7VjucswgdS"}],"disc_number":1,"duration_ms":234860,"explicit":false,"external_ids":{"isrc":"GXHND2585548"},"external_urls":{"spotify":"https://open.spotify.com/track/6YkFV8cxpd8SdtY6jobaBG"},"href":"https://api.spotify.com/v1/tracks/6YkFV8cxpd8SdtY6jobaBG","id":"6YkFV8cxpd8SdtY6jobaBG","is_local":false,"is_playable":true,"name":"Ride (Remix)","track_number":1,"type":"track","uri":"spotify:track:6YkFV8cxpd8SdtY6jobaBG"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Qh82StgP4KW4r49iTjrTb"},"href":"https://api.spotify.com/v1/artists/1Qh82StgP4KW4r49iTjrTb","id":"1Qh82StgP4KW4r49iTjrTb","name":"Dr Bigf MC","type":"artist","uri":"spotify:artist:1Qh82StgP4KW4r49iTjrTb"}],"external_urls":{"spotify":"https://open.spotify.com/album/0WJ1Mn67JEpEMTEWHDfWvO"},"href":"https://api.spotify.com/v1/albums/0WJ1Mn67JEpEMTEWHDfWvO","id":"0WJ1Mn67JEpEMTEWHDfWvO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736a461a5e441675be627f15dc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026a461a5e441675be627f15dc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516a461a5e441675be627f15dc"}],"is_playable":true,"name":"DnB","release_date":"2025-02-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0WJ1Mn67JEpEMTEWHDfWvO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Qh82StgP4KW4r49iTjrTb"},"href":"https://api.spotify.com/v1/artists/1Qh82StgP4KW4r49iTjrTb","id":"1Qh82StgP4KW4r49iTjrTb","name":"Dr Bigf MC","type":"artist","uri":"spotify:artist:1Qh82StgP4KW4r49iTjrTb"}],"disc_number":1,"duration_ms":219615,"explicit":false,"external_ids":{"isrc":"QMDA62493067"},"external_urls":{"spotify":"https://open.spotify.com/track/4mmp5iOvaCvjB7acJDMcGw"},"href":"https://api.spotify.com/v1/tracks/4mmp5iOvaCvjB7acJDMcGw","id":"4mmp5iOvaCvjB7acJDMcGw","is_local":false,"is_playable":true,"name":"DnB","track_number":1,"type":"track","uri":"spotify:track:4mmp5iOvaCvjB7acJDMcGw"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1anyVhU62p31KFi8MEzkbf"},"href":"https://api.spotify.com/v1/artists/1anyVhU62p31KFi8MEzkbf","id":"1anyVhU62p31KFi8MEzkbf","name":"Chance the Rapper","type":"artist","uri":"spotify:artist:1anyVhU62p31KFi8MEzkbf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0u6b6Qa5VJEvr3SgzzeVOB"},"href":"https://api.spotify.com/v1/artists/0u6b6Qa5VJEvr3SgzzeVOB","id":"0u6b6Qa5VJEvr3SgzzeVOB","name":"Do Or Die","type":"artist","uri":"spotify:artist:0u6b6Qa5VJEvr3SgzzeVOB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6vbY3hOaCAhC7VjucswgdS"},"href":"https://api.spotify.com/v1/artists/6vbY3hOaCAhC7VjucswgdS","id":"6vbY3hOaCAhC7VjucswgdS","name":"Twista","type":"artist","uri":"spotify:artist:6vbY3hOaCAhC7VjucswgdS"}],"external_urls":{"spotify":"https://open.spotify.com/album/1E1Mc2Y52Dp6uN1fRENcKB"},"href":"https://api.spotify.com/v1/albums/1E1Mc2Y52Dp6uN1fRENcKB","id":"1E1Mc2Y52Dp6uN1fRENcKB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27332f1d2a31896f3fe97e395b9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0232f1d2a31896f3fe97e395b9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485132f1d2a31896f3fe97e395b9"}],"is_playable":true,"name":"Ride (Remix)","release_date":"2025-08-14","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:1E1Mc2Y52Dp6uN1fRENcKB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1anyVhU62p31KFi8MEzkbf"},"href":"https://api.spotify.com/v1/artists/1anyVhU62p31KFi8MEzkbf","id":"1anyVhU62p31KFi8MEzkbf","name":"Chance the Rapper","type":"artist","uri":"spotify:artist:1anyVhU62p31KFi8MEzkbf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0u6b6Qa5VJEvr3SgzzeVOB"},"href":"https://api.spotify.com/v1/artists/0u6b6Qa5VJEvr3SgzzeVOB","id":"0u6b6Qa5VJEvr3SgzzeVOB","name":"Do Or Die","type":"artist","uri":"spotify:artist:0u6b6Qa5VJEvr3SgzzeVOB"}],"disc_number":1,"duration_ms":179368,"explicit":false,"external_ids":{"isrc":"GXHG92506333"},"external_urls":{"spotify":"https://open.spotify.com/track/70yffFIgGyGllmueOLj40q"},"href":"https://api.spotify.com/v1/tracks/70yffFIgGyGllmueOLj40q","id":"70yffFIgGyGllmueOLj40q","is_local":false,"is_playable":true,"name":"Ride (feat. Do or Die)","track_number":2,"type":"track","uri":"spotify:track:70yffFIgGyGllmueOLj40q"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3krHIfEy37pVe0zjdisDBk"},"href":"https://api.spotify.com/v1/artists/3krHIfEy37pVe0zjdisDBk","id":"3krHIfEy37pVe0zjdisDBk","name":"Goldkimono","type":"artist","uri":"spotify:artist:3krHIfEy37pVe0zjdisDBk"}],"external_urls":{"spotify":"https://open.spotify.com/album/71ilqLbb5gDqfinSIDDiyQ"},"href":"https://api.spotify.com/v1/albums/71ilqLbb5gDqfinSIDDiyQ","id":"71ilqLbb5gDqfinSIDDiyQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27389b6fbb0266ea50c4ec5d136"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0289b6fbb0266ea50c4ec5d136"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485189b6fbb0266ea50c4ec5d136"}],"is_playable":true,"name":"This One's On The House","release_date":"2025-06-13","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:71ilqLbb5gDqfinSIDDiyQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3krHIfEy37pVe0zjdisDBk"},"href":"https://api.spotify.com/v1/artists/3krHIfEy37pVe0zjdisDBk","id":"3krHIfEy37pVe0zjdisDBk","name":"Goldkimono","type":"artist","uri":"spotify:artist:3krHIfEy37pVe0zjdisDBk"}],"disc_number":1,"duration_ms":256578,"explicit":false,"external_ids":{"isrc":"NL3FX2000052"},"external_urls":{"spotify":"https://open.spotify.com/track/31XU5OnEw7YcjeVz8kjWxJ"},"href":"https://api.spotify.com/v1/tracks/31XU5OnEw7YcjeVz8kjWxJ","id":"31XU5OnEw7YcjeVz8kjWxJ","is_local":false,"is_playable":true,"name":"Lifetime","track_number":7,"type":"track","uri":"spotify:track:31XU5OnEw7YcjeVz8kjWxJ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3USpNaxpX1iNqNnQWqg9ob"},"href":"https://api.spotify.com/v1/artists/3USpNaxpX1iNqNnQWqg9ob","id":"3USpNaxpX1iNqNnQWqg9ob","name":"Mack 10","type":"artist","uri":"spotify:artist:3USpNaxpX1iNqNnQWqg9ob"}],"external_urls":{"spotify":"https://open.spotify.com/album/0SIJmYjQu1tjhRpZpdPyAO"},"href":"https://api.spotify.com/v1/albums/0SIJmYjQu1tjhRpZpdPyAO","id":"0SIJmYjQu1tjhRpZpdPyAO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e7eb920ba3a38455d3a0055b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e7eb920ba3a38455d3a0055b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e7eb920ba3a38455d3a0055b"}],"is_playable":true,"name":"Mack 10","release_date":"1995-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:0SIJmYjQu1tjhRpZpdPyAO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3USpNaxpX1iNqNnQWqg9ob"},"href":"https://api.spotify.com/v1/artists/3USpNaxpX1iNqNnQWqg9ob","id":"3USpNaxpX1iNqNnQWqg9ob","name":"Mack 10","type":"artist","uri":"spotify:artist:3USpNaxpX1iNqNnQWqg9ob"}],"disc_number":1,"duration_ms":251936,"explicit":true,"external_ids":{"isrc":"USPO19500007"},"external_urls":{"spotify":"https://open.spotify.com/track/0189NSt55rDEbds6EyYuPt"},"href":"https://api.spotify.com/v1/tracks/0189NSt55rDEbds6EyYuPt","id":"0189NSt55rDEbds6EyYuPt","is_local":false,"is_playable":true,"name":"Here Comes The G","track_number":7,"type":"track","uri":"spotify:track:0189NSt55rDEbds6EyYuPt"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1iSde2pm2FFAWNl8X6WYrc"},"href":"https://api.spotify.com/v1/albums/1iSde2pm2FFAWNl8X6WYrc","id":"1iSde2pm2FFAWNl8X6WYrc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bc0d8d05553a8bd740a4b03b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bc0d8d05553a8bd740a4b03b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bc0d8d05553a8bd740a4b03b"}],"is_playable":true,"name":"90s Rap","release_date":"2018-04-20","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:1iSde2pm2FFAWNl8X6WYrc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vbY3hOaCAhC7VjucswgdS"},"href":"https://api.spotify.com/v1/artists/6vbY3hOaCAhC7VjucswgdS","id":"6vbY3hOaCAhC7VjucswgdS","name":"Twista","type":"artist","uri":"spotify:artist:6vbY3hOaCAhC7VjucswgdS"}],"disc_number":1,"duration_ms":272426,"explicit":true,"external_ids":{"isrc":"USAT20300978"},"external_urls":{"spotify":"https://open.spotify.com/track/78LQeaAB8Q8SIk2274paOU"},"href":"https://api.spotify.com/v1/tracks/78LQeaAB8Q8SIk2274paOU","id":"78LQeaAB8Q8SIk2274paOU","is_local":false,"is_playable":true,"name":"Emotions","track_number":15,"type":"track","uri":"spotify:track:78LQeaAB8Q8SIk2274paOU"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4VEHcs1rBs2m0CeCwcwjCG"},"href":"https://api.spotify.com/v1/albums/4VEHcs1rBs2m0CeCwcwjCG","id":"4VEHcs1rBs2m0CeCwcwjCG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739dabfe5e761d2739ae3ad871"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029dabfe5e761d2739ae3ad871"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519dabfe5e761d2739ae3ad871"}],"is_playable":true,"name":"Hip Hop Originals 90s","release_date":"2019-06-07","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:4VEHcs1rBs2m0CeCwcwjCG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vbY3hOaCAhC7VjucswgdS"},"href":"https://api.spotify.com/v1/artists/6vbY3hOaCAhC7VjucswgdS","id":"6vbY3hOaCAhC7VjucswgdS","name":"Twista","type":"artist","uri":"spotify:artist:6vbY3hOaCAhC7VjucswgdS"}],"disc_number":1,"duration_ms":272426,"explicit":true,"external_ids":{"isrc":"USAT20300978"},"external_urls":{"spotify":"https://open.spotify.com/track/6I3nhzjx0L764Gv14R1NwM"},"href":"https://api.spotify.com/v1/tracks/6I3nhzjx0L764Gv14R1NwM","id":"6I3nhzjx0L764Gv14R1NwM","is_local":false,"is_playable":true,"name":"Emotions","track_number":10,"type":"track","uri":"spotify:track:6I3nhzjx0L764Gv14R1NwM"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Ldum5WYigIxh35xTAEIo4"},"href":"https://api.spotify.com/v1/albums/5Ldum5WYigIxh35xTAEIo4","id":"5Ldum5WYigIxh35xTAEIo4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738de5ef6a0d1b9a6a76aa2b4a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028de5ef6a0d1b9a6a76aa2b4a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518de5ef6a0d1b9a6a76aa2b4a"}],"is_playable":true,"name":"Classic Gym Rap","release_date":"2026-07-27","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:5Ldum5WYigIxh35xTAEIo4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vbY3hOaCAhC7VjucswgdS"},"href":"https://api.spotify.com/v1/artists/6vbY3hOaCAhC7VjucswgdS","id":"6vbY3hOaCAhC7VjucswgdS","name":"Twista","type":"artist","uri":"spotify:artist:6vbY3hOaCAhC7VjucswgdS"}],"disc_number":1,"duration_ms":272426,"explicit":true,"external_ids":{"isrc":"USAT20300978"},"external_urls":{"spotify":"https://open.spotify.com/track/1RwWhz14b11E5dj4KNQfVn"},"href":"https://api.spotify.com/v1/tracks/1RwWhz14b11E5dj4KNQfVn","id":"1RwWhz14b11E5dj4KNQfVn","is_local":false,"is_playable":true,"name":"Emotions","track_number":17,"type":"track","uri":"spotify:track:1RwWhz14b11E5dj4KNQfVn"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1TcGVlZCUyMFRyaWFscyUyMEdvbGRpZSZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvc2VhcmNoP29mZnNldD0xMCZsaW1pdD0xMCZxdWVyeT1TcGVlZCUyMFRyaWFscyUyMEdvbGRpZSZ0eXBlPXRyYWNrIiwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjExLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQXBhRzYwUDRyMHloQm9EQ0dEOFlHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJBcGFHNjBQNHIweWhCb0RDR0Q4WUciLCJpZCI6IjJBcGFHNjBQNHIweWhCb0RDR0Q4WUciLCJuYW1lIjoiRWxsaW90dCBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQXBhRzYwUDRyMHloQm9EQ0dEOFlHIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNWhyeWhyVDd3RWRMblpDYkpYOUY2TCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVocnloclQ3d0VkTG5aQ2JKWDlGNkwiLCJpZCI6IjVocnloclQ3d0VkTG5aQ2JKWDlGNkwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZWE3YWM4MDc2NWFhNDU0OWQxOGEyN2I5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmVhN2FjODA3NjVhYTQ1NDlkMThhMjdiOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZWE3YWM4MDc2NWFhNDU0OWQxOGEyN2I5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVpdGhlci9PciIsInJlbGVhc2VfZGF0ZSI6IjE5OTctMDItMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1aHJ5aHJUN3dFZExuWkNiSlg5RjZMIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkFwYUc2MFA0cjB5aEJvRENHRDhZRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jbw==", + "bS92MS9hcnRpc3RzLzJBcGFHNjBQNHIweWhCb0RDR0Q4WUciLCJpZCI6IjJBcGFHNjBQNHIweWhCb0RDR0Q4WUciLCJuYW1lIjoiRWxsaW90dCBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQXBhRzYwUDRyMHloQm9EQ0dEOFlHIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4MjU2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTS1JTMDMyNjkwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGdSeVNCeldvV0QySnFFRlpuZlB1WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRnUnlTQnpXb1dEMkpxRUZabmZQdVgiLCJpZCI6IjRnUnlTQnpXb1dEMkpxRUZabmZQdVgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3BlZWQgVHJpYWxzIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRnUnlTQnpXb1dEMkpxRUZabmZQdVgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMWFueVZoVTYycDMxS0ZpOE1FemtiZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xYW55VmhVNjJwMzFLRmk4TUV6a2JmIiwiaWQiOiIxYW55VmhVNjJwMzFLRmk4TUV6a2JmIiwibmFtZSI6IkNoYW5jZSB0aGUgUmFwcGVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFhbnlWaFU2MnAzMUtGaThNRXprYmYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80aWYxQnZ2V2ZtRzRnbzR1QW1vdzhoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNGlmMUJ2dldmbUc0Z280dUFtb3c4aCIsImlkIjoiNGlmMUJ2dldmbUc0Z280dUFtb3c4aCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4NjYyODY0MTAxYzdiODlkNzdmZjJlM2UifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODY2Mjg2NDEwMWM3Yjg5ZDc3ZmYyZTNlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4NjYyODY0MTAxYzdiODlkNzdmZjJlM2UifV0sImlzX3BsYXlhYg==", + "bGUiOnRydWUsIm5hbWUiOiJTVEFSIExJTkUiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA4LTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NGlmMUJ2dldmbUc0Z280dUFtb3c4aCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFhbnlWaFU2MnAzMUtGaThNRXprYmYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMWFueVZoVTYycDMxS0ZpOE1FemtiZiIsImlkIjoiMWFueVZoVTYycDMxS0ZpOE1FemtiZiIsIm5hbWUiOiJDaGFuY2UgdGhlIFJhcHBlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxYW55VmhVNjJwMzFLRmk4TUV6a2JmIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzB1NmI2UWE1VkpFdnIzU2d6emVWT0IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiIsImlkIjoiMHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiIsIm5hbWUiOiJEbyBPciBEaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzkzNjgsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdYSEc5MjUwNjMzMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN002eXlEdExyMlV2ZFNmcE0zMG9EZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdNNnl5RHRMcjJVdmRTZnBNMzBvRGUiLCJpZCI6IjdNNnl5RHRMcjJVdmRTZnBNMzBvRGUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmlkZSAoZmVhdC4gRG8gb3IgRGllKSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3TTZ5eUR0THIyVXZkU2ZwTTMwb0RlIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xYW55VmhVNjJwMzFLRmk4TUV6a2JmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFhbnlWaFU2MnAzMUtGaThNRXprYmYiLCJpZCI6IjFhbnlWaFU2MnAzMUtGaThNRXprYmYiLCJuYW1lIjoiQ2hhbmNlIHRoZQ==", + "IFJhcHBlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxYW55VmhVNjJwMzFLRmk4TUV6a2JmIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzB1NmI2UWE1VkpFdnIzU2d6emVWT0IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiIsImlkIjoiMHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiIsIm5hbWUiOiJEbyBPciBEaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82dmJZM2hPYUNBaEM3Vmp1Y3N3Z2RTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ2YlkzaE9hQ0FoQzdWanVjc3dnZFMiLCJpZCI6IjZ2YlkzaE9hQ0FoQzdWanVjc3dnZFMiLCJuYW1lIjoiVHdpc3RhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ2YlkzaE9hQ0FoQzdWanVjc3dnZFMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xRTFNYzJZNTJEcDZ1TjFmUkVOY0tCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUUxTWMyWTUyRHA2dU4xZlJFTmNLQiIsImlkIjoiMUUxTWMyWTUyRHA2dU4xZlJFTmNLQiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzMmYxZDJhMzE4OTZmM2ZlOTdlMzk1YjkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzJmMWQyYTMxODk2ZjNmZTk3ZTM5NWI5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzMmYxZDJhMzE4OTZmM2ZlOTdlMzk1YjkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmlkZSAoUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wOC0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MUUxTWMyWTUyRHA2dU4xZlJFTmNLQiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFhbnlWaFU2MnAzMUtGaThNRXprYmYifSwiaHJlZiI6Imh0dHBzOg==", + "Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xYW55VmhVNjJwMzFLRmk4TUV6a2JmIiwiaWQiOiIxYW55VmhVNjJwMzFLRmk4TUV6a2JmIiwibmFtZSI6IkNoYW5jZSB0aGUgUmFwcGVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFhbnlWaFU2MnAzMUtGaThNRXprYmYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wdTZiNlFhNVZKRXZyM1NnenplVk9CIiwiaWQiOiIwdTZiNlFhNVZKRXZyM1NnenplVk9CIiwibmFtZSI6IkRvIE9yIERpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowdTZiNlFhNVZKRXZyM1NnenplVk9CIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ2YlkzaE9hQ0FoQzdWanVjc3dnZFMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnZiWTNoT2FDQWhDN1ZqdWNzd2dkUyIsImlkIjoiNnZiWTNoT2FDQWhDN1ZqdWNzd2dkUyIsIm5hbWUiOiJUd2lzdGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnZiWTNoT2FDQWhDN1ZqdWNzd2dkUyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzQ4NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHWEhORDI1ODU1NDgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZZa0ZWOGN4cGQ4U2R0WTZqb2JhQkcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82WWtGVjhjeHBkOFNkdFk2am9iYUJHIiwiaWQiOiI2WWtGVjhjeHBkOFNkdFk2am9iYUJHIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJpZGUgKFJlbWl4KSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2WWtGVjhjeHBkOFNkdFk2am9iYUJHIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xUWg4MlN0Z1A0S1c0cjQ5aVRqclRiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFRaDgyU3RnUDRLVzRyNDlpVGpyVGIiLCJpZCI6IjFRaDgyU3RnUDRLVzRyNDlpVGpyVGIiLCJuYW1lIjoiRHIgQmlnZiBNQyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOg==", + "InNwb3RpZnk6YXJ0aXN0OjFRaDgyU3RnUDRLVzRyNDlpVGpyVGIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wV0oxTW42N0pFcEVNVEVXSERmV3ZPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMFdKMU1uNjdKRXBFTVRFV0hEZld2TyIsImlkIjoiMFdKMU1uNjdKRXBFTVRFV0hEZld2TyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2YTQ2MWE1ZTQ0MTY3NWJlNjI3ZjE1ZGMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNmE0NjFhNWU0NDE2NzViZTYyN2YxNWRjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2YTQ2MWE1ZTQ0MTY3NWJlNjI3ZjE1ZGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRG5CIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMi0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MFdKMU1uNjdKRXBFTVRFV0hEZld2TyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFRaDgyU3RnUDRLVzRyNDlpVGpyVGIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVFoODJTdGdQNEtXNHI0OWlUanJUYiIsImlkIjoiMVFoODJTdGdQNEtXNHI0OWlUanJUYiIsIm5hbWUiOiJEciBCaWdmIE1DIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFRaDgyU3RnUDRLVzRyNDlpVGpyVGIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE5NjE1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU1EQTYyNDkzMDY3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80bW1wNWlPdmFDdmpCN2FjSkRNY0d3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNG1tcDVpT3ZhQ3ZqQjdhY0pETWNHdyIsImlkIjoiNG1tcDVpT3ZhQ3ZqQjdhY0pETWNHdyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEbkIiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NG1tcDVpT3ZhQ3ZqQjdhY0pETWNHdyJ9LA==", + "eyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xYW55VmhVNjJwMzFLRmk4TUV6a2JmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFhbnlWaFU2MnAzMUtGaThNRXprYmYiLCJpZCI6IjFhbnlWaFU2MnAzMUtGaThNRXprYmYiLCJuYW1lIjoiQ2hhbmNlIHRoZSBSYXBwZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MWFueVZoVTYycDMxS0ZpOE1FemtiZiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdTZiNlFhNVZKRXZyM1NnenplVk9CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB1NmI2UWE1VkpFdnIzU2d6emVWT0IiLCJpZCI6IjB1NmI2UWE1VkpFdnIzU2d6emVWT0IiLCJuYW1lIjoiRG8gT3IgRGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjB1NmI2UWE1VkpFdnIzU2d6emVWT0IifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnZiWTNoT2FDQWhDN1ZqdWNzd2dkUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82dmJZM2hPYUNBaEM3Vmp1Y3N3Z2RTIiwiaWQiOiI2dmJZM2hPYUNBaEM3Vmp1Y3N3Z2RTIiwibmFtZSI6IlR3aXN0YSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2dmJZM2hPYUNBaEM3Vmp1Y3N3Z2RTIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMUUxTWMyWTUyRHA2dU4xZlJFTmNLQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFFMU1jMlk1MkRwNnVOMWZSRU5jS0IiLCJpZCI6IjFFMU1jMlk1MkRwNnVOMWZSRU5jS0IiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzJmMWQyYTMxODk2ZjNmZTk3ZTM5NWI5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjMyZjFkMmEzMTg5NmYzZmU5N2UzOTViOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzJmMWQyYTMxODk2ZjNmZTk3ZTM5NWI5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJpZGUgKFJlbWl4KSIsInJlbA==", + "ZWFzZV9kYXRlIjoiMjAyNS0wOC0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MUUxTWMyWTUyRHA2dU4xZlJFTmNLQiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFhbnlWaFU2MnAzMUtGaThNRXprYmYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMWFueVZoVTYycDMxS0ZpOE1FemtiZiIsImlkIjoiMWFueVZoVTYycDMxS0ZpOE1FemtiZiIsIm5hbWUiOiJDaGFuY2UgdGhlIFJhcHBlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxYW55VmhVNjJwMzFLRmk4TUV6a2JmIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzB1NmI2UWE1VkpFdnIzU2d6emVWT0IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiIsImlkIjoiMHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiIsIm5hbWUiOiJEbyBPciBEaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHU2YjZRYTVWSkV2cjNTZ3p6ZVZPQiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzkzNjgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHWEhHOTI1MDYzMzMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzcweWZmRklnR3lHbGxtdWVPTGo0MHEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83MHlmZkZJZ0d5R2xsbXVlT0xqNDBxIiwiaWQiOiI3MHlmZkZJZ0d5R2xsbXVlT0xqNDBxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJpZGUgKGZlYXQuIERvIG9yIERpZSkiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NzB5ZmZGSWdHeUdsbG11ZU9MajQwcSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8za3JISWZFeTM3cFZlMHpqZGlzREJrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNrckhJZkV5MzdwVmUwempkaXNEQmsiLCJpZCI6IjNrckhJZkV5MzdwVmUwempkaXNEQmsiLCJuYW1lIjoiR29sZGtpbW9ubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5Og==", + "YXJ0aXN0OjNrckhJZkV5MzdwVmUwempkaXNEQmsifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83MWlscUxiYjVnRHFmaW5TSUREaXlRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzFpbHFMYmI1Z0RxZmluU0lERGl5USIsImlkIjoiNzFpbHFMYmI1Z0RxZmluU0lERGl5USIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4OWI2ZmJiMDI2NmVhNTBjNGVjNWQxMzYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODliNmZiYjAyNjZlYTUwYzRlYzVkMTM2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4OWI2ZmJiMDI2NmVhNTBjNGVjNWQxMzYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhpcyBPbmUncyBPbiBUaGUgSG91c2UiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA2LTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzFpbHFMYmI1Z0RxZmluU0lERGl5USJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNrckhJZkV5MzdwVmUwempkaXNEQmsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2tySElmRXkzN3BWZTB6amRpc0RCayIsImlkIjoiM2tySElmRXkzN3BWZTB6amRpc0RCayIsIm5hbWUiOiJHb2xka2ltb25vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNrckhJZkV5MzdwVmUwempkaXNEQmsifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjU2NTc4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkwzRlgyMDAwMDUyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zMVhVNU9uRXc3WWNqZVZ6OGtqV3hKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzFYVTVPbkV3N1ljamVWejhrald4SiIsImlkIjoiMzFYVTVPbkV3N1ljamVWejhrald4SiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMaWZldGltZSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozMVhVNU9uRQ==", + "dzdZY2plVno4a2pXeEoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1VTcE5heHBYMWlOcU5uUVdxZzlvYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zVVNwTmF4cFgxaU5xTm5RV3FnOW9iIiwiaWQiOiIzVVNwTmF4cFgxaU5xTm5RV3FnOW9iIiwibmFtZSI6Ik1hY2sgMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1VTcE5heHBYMWlOcU5uUVdxZzlvYiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBTSUptWWpRdTF0amhScFpwZFB5QU8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wU0lKbVlqUXUxdGpoUnBacGRQeUFPIiwiaWQiOiIwU0lKbVlqUXUxdGpoUnBacGRQeUFPIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2U3ZWI5MjBiYTNhMzg0NTVkM2EwMDU1YiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlN2ViOTIwYmEzYTM4NDU1ZDNhMDA1NWIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWU3ZWI5MjBiYTNhMzg0NTVkM2EwMDU1YiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNYWNrIDEwIiwicmVsZWFzZV9kYXRlIjoiMTk5NS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBTSUptWWpRdTF0amhScFpwZFB5QU8ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVVNwTmF4cFgxaU5xTm5RV3FnOW9iIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNVU3BOYXhwWDFpTnFOblFXcWc5b2IiLCJpZCI6IjNVU3BOYXhwWDFpTnFOblFXcWc5b2IiLCJuYW1lIjoiTWFjayAxMCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozVVNwTmF4cFgxaU5xTm5RV3FnOW9iIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1MTkzNiwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNQTzE5NTAwMDA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeQ==", + "IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzAxODlOU3Q1NXJERWJkczZFeVl1UHQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wMTg5TlN0NTVyREViZHM2RXlZdVB0IiwiaWQiOiIwMTg5TlN0NTVyREViZHM2RXlZdVB0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhlcmUgQ29tZXMgVGhlIEciLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MDE4OU5TdDU1ckRFYmRzNkV5WXVQdCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xaVNkZTJwbTJGRkFXTmw4WDZXWXJjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWlTZGUycG0yRkZBV05sOFg2V1lyYyIsImlkIjoiMWlTZGUycG0yRkZBV05sOFg2V1lyYyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiYzBkOGQwNTU1M2E4YmQ3NDBhNGIwM2IifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmMwZDhkMDU1NTNhOGJkNzQwYTRiMDNiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiYzBkOGQwNTU1M2E4YmQ3NDBhNGIwM2IifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiOTBzIFJhcCIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDQtMjAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxaVNkZTJwbTJGRkFXTmw4WDZXWXJjIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnZiWTNoT2FDQWhDN1ZqdWNzd2dkUyJ9LCJocg==", + "ZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ2YlkzaE9hQ0FoQzdWanVjc3dnZFMiLCJpZCI6IjZ2YlkzaE9hQ0FoQzdWanVjc3dnZFMiLCJuYW1lIjoiVHdpc3RhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ2YlkzaE9hQ0FoQzdWanVjc3dnZFMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjcyNDI2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FUMjAzMDA5NzgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzc4TFFlYUFCOFE4U0lrMjI3NHBhT1UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83OExRZWFBQjhROFNJazIyNzRwYU9VIiwiaWQiOiI3OExRZWFBQjhROFNJazIyNzRwYU9VIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVtb3Rpb25zIiwidHJhY2tfbnVtYmVyIjoxNSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3OExRZWFBQjhROFNJazIyNzRwYU9VIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRWRUhjczFyQnMybTBDZUN3Y3dqQ0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80VkVIY3MxckJzMm0wQ2VDd2N3akNHIiwiaWQiOiI0VkVIY3MxckJzMm0wQ2VDd2N3akNHIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzlkYWJmZTVlNzYxZDI3MzlhZTNhZDg3MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5ZGFiZmU1ZTc2MWQyNzM5YWUzYWQ4NzEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTlkYWJmZTVlNzYxZDI3MzlhZQ==", + "M2FkODcxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhpcCBIb3AgT3JpZ2luYWxzIDkwcyIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDYtMDciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0VkVIY3MxckJzMm0wQ2VDd2N3akNHIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnZiWTNoT2FDQWhDN1ZqdWNzd2dkUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82dmJZM2hPYUNBaEM3Vmp1Y3N3Z2RTIiwiaWQiOiI2dmJZM2hPYUNBaEM3Vmp1Y3N3Z2RTIiwibmFtZSI6IlR3aXN0YSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2dmJZM2hPYUNBaEM3Vmp1Y3N3Z2RTIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI3MjQyNiwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBVDIwMzAwOTc4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82STNuaHpqeDBMNzY0R3YxNFIxTndNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNkkzbmh6angwTDc2NEd2MTRSMU53TSIsImlkIjoiNkkzbmh6angwTDc2NEd2MTRSMU53TSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJFbW90aW9ucyIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Nkkzbmh6angwTDc2NEd2MTRSMU53TSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81TGR1bTVXWWlnSXhoMzV4VEFFSW80In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUxkdW01V1lpZ0l4aDM1eFRBRUlvNCIsImlkIjoiNUxkdW01V1lpZ0l4aDM1eFRBRUlvNCIsIg==", + "aW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzhkZTVlZjZhMGQxYjlhNmE3NmFhMmI0YSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4ZGU1ZWY2YTBkMWI5YTZhNzZhYTJiNGEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MThkZTVlZjZhMGQxYjlhNmE3NmFhMmI0YSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDbGFzc2ljIEd5bSBSYXAiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA3LTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUxkdW01V1lpZ0l4aDM1eFRBRUlvNCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ2YlkzaE9hQ0FoQzdWanVjc3dnZFMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnZiWTNoT2FDQWhDN1ZqdWNzd2dkUyIsImlkIjoiNnZiWTNoT2FDQWhDN1ZqdWNzd2dkUyIsIm5hbWUiOiJUd2lzdGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnZiWTNoT2FDQWhDN1ZqdWNzd2dkUyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNzI0MjYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQVQyMDMwMDk3OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVJ3V2h6MTRiMTFFNWRqNEtOUWZWbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFSd1doejE0YjExRTVkajRLTlFmVm4iLCJpZCI6IjFSd1doejE0YjExRTVkajRLTlFmVm4iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRW1vdGlvbnMiLCJ0cmFja19udW1iZXIiOjE3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFSd1doejE0YjExRTVkajRLTlFmVm4ifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Speed+Trials+Goldie&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Location%22%20artist%3A%22Dave%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"}],"external_urls":{"spotify":"https://open.spotify.com/album/4LU4HbH4wC2pW40UT6mnPv"},"href":"https://api.spotify.com/v1/albums/4LU4HbH4wC2pW40UT6mnPv","id":"4LU4HbH4wC2pW40UT6mnPv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273565f69a950084775df6a4e77"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02565f69a950084775df6a4e77"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851565f69a950084775df6a4e77"}],"is_playable":true,"name":"PSYCHODRAMA","release_date":"2019-03-08","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4LU4HbH4wC2pW40UT6mnPv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/6KFWubocLBhrLs31RpEdR9"},"href":"https://api.spotify.com/v1/tracks/6KFWubocLBhrLs31RpEdR9","id":"6KFWubocLBhrLs31RpEdR9","is_local":false,"is_playable":true,"name":"Location (feat. Burna Boy)","track_number":5,"type":"track","uri":"spotify:track:6KFWubocLBhrLs31RpEdR9"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/47NVhdktZbY7ZF7pyG7wj5"},"href":"https://api.spotify.com/v1/albums/47NVhdktZbY7ZF7pyG7wj5","id":"47NVhdktZbY7ZF7pyG7wj5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27342890c4ceb537edb4b888d2a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0242890c4ceb537edb4b888d2a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485142890c4ceb537edb4b888d2a"}],"is_playable":true,"name":"Romantic Weekend","release_date":"2023-08-29","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:47NVhdktZbY7ZF7pyG7wj5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/0DPxIKOinT0BG2FYWLr6CR"},"href":"https://api.spotify.com/v1/tracks/0DPxIKOinT0BG2FYWLr6CR","id":"0DPxIKOinT0BG2FYWLr6CR","is_local":false,"is_playable":true,"name":"Location","track_number":5,"type":"track","uri":"spotify:track:0DPxIKOinT0BG2FYWLr6CR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6RkBknh6Ry98uAOLEnhd0P"},"href":"https://api.spotify.com/v1/albums/6RkBknh6Ry98uAOLEnhd0P","id":"6RkBknh6Ry98uAOLEnhd0P","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27324342f44703de922af7c5877"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0224342f44703de922af7c5877"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485124342f44703de922af7c5877"}],"is_playable":true,"name":"Afrobeats 2023 I Afro Hits I Afropop","release_date":"2023-03-13","release_date_precision":"day","total_tracks":35,"type":"album","uri":"spotify:album:6RkBknh6Ry98uAOLEnhd0P"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/4cilxSPZMGdl6EubAEdMkf"},"href":"https://api.spotify.com/v1/tracks/4cilxSPZMGdl6EubAEdMkf","id":"4cilxSPZMGdl6EubAEdMkf","is_local":false,"is_playable":true,"name":"Location","track_number":12,"type":"track","uri":"spotify:track:4cilxSPZMGdl6EubAEdMkf"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/24oDE0vaH0JH83VNAQ7pGL"},"href":"https://api.spotify.com/v1/artists/24oDE0vaH0JH83VNAQ7pGL","id":"24oDE0vaH0JH83VNAQ7pGL","name":"Nick Marks","type":"artist","uri":"spotify:artist:24oDE0vaH0JH83VNAQ7pGL"}],"external_urls":{"spotify":"https://open.spotify.com/album/3p8skRnnsYB1rZOODgyyhr"},"href":"https://api.spotify.com/v1/albums/3p8skRnnsYB1rZOODgyyhr","id":"3p8skRnnsYB1rZOODgyyhr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27314c2b617e2789ac325698467"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0214c2b617e2789ac325698467"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485114c2b617e2789ac325698467"}],"is_playable":true,"name":"Cinematic Chromatics Vol. III","release_date":"2025-02-07","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:3p8skRnnsYB1rZOODgyyhr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/24oDE0vaH0JH83VNAQ7pGL"},"href":"https://api.spotify.com/v1/artists/24oDE0vaH0JH83VNAQ7pGL","id":"24oDE0vaH0JH83VNAQ7pGL","name":"Nick Marks","type":"artist","uri":"spotify:artist:24oDE0vaH0JH83VNAQ7pGL"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0994Up3Ob4zUFm3OFOWpzJ"},"href":"https://api.spotify.com/v1/artists/0994Up3Ob4zUFm3OFOWpzJ","id":"0994Up3Ob4zUFm3OFOWpzJ","name":"CARRTOONS","type":"artist","uri":"spotify:artist:0994Up3Ob4zUFm3OFOWpzJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7gBlwt8sGulq5GXOmgCY0x"},"href":"https://api.spotify.com/v1/artists/7gBlwt8sGulq5GXOmgCY0x","id":"7gBlwt8sGulq5GXOmgCY0x","name":"Dave Levy","type":"artist","uri":"spotify:artist:7gBlwt8sGulq5GXOmgCY0x"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0DlkcshSnSMw3Hk7SBNZwC"},"href":"https://api.spotify.com/v1/artists/0DlkcshSnSMw3Hk7SBNZwC","id":"0DlkcshSnSMw3Hk7SBNZwC","name":"Chien Chien Lu","type":"artist","uri":"spotify:artist:0DlkcshSnSMw3Hk7SBNZwC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3DgNAIw7AsEgqkGbI2MsMX"},"href":"https://api.spotify.com/v1/artists/3DgNAIw7AsEgqkGbI2MsMX","id":"3DgNAIw7AsEgqkGbI2MsMX","name":"Chris Ott","type":"artist","uri":"spotify:artist:3DgNAIw7AsEgqkGbI2MsMX"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4sPCH1tWFrUWRvJrA2YVjR"},"href":"https://api.spotify.com/v1/artists/4sPCH1tWFrUWRvJrA2YVjR","id":"4sPCH1tWFrUWRvJrA2YVjR","name":"Brittany Harris","type":"artist","uri":"spotify:artist:4sPCH1tWFrUWRvJrA2YVjR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5uLyADgoaWkfY0YYhnH9uU"},"href":"https://api.spotify.com/v1/artists/5uLyADgoaWkfY0YYhnH9uU","id":"5uLyADgoaWkfY0YYhnH9uU","name":"Doron Lev","type":"artist","uri":"spotify:artist:5uLyADgoaWkfY0YYhnH9uU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Iqi4vGZ1YDxUn9oAqqxXH"},"href":"https://api.spotify.com/v1/artists/1Iqi4vGZ1YDxUn9oAqqxXH","id":"1Iqi4vGZ1YDxUn9oAqqxXH","name":"Benjamin Furman","type":"artist","uri":"spotify:artist:1Iqi4vGZ1YDxUn9oAqqxXH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1eIZ7Vm6CvnaQog3Bs1JaH"},"href":"https://api.spotify.com/v1/artists/1eIZ7Vm6CvnaQog3Bs1JaH","id":"1eIZ7Vm6CvnaQog3Bs1JaH","name":"Sarpay Ozcagatay","type":"artist","uri":"spotify:artist:1eIZ7Vm6CvnaQog3Bs1JaH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1U0BLmf5xzFer1LoQHrhkn"},"href":"https://api.spotify.com/v1/artists/1U0BLmf5xzFer1LoQHrhkn","id":"1U0BLmf5xzFer1LoQHrhkn","name":"Leandro Pellegrino","type":"artist","uri":"spotify:artist:1U0BLmf5xzFer1LoQHrhkn"}],"disc_number":1,"duration_ms":244174,"explicit":false,"external_ids":{"isrc":"QZZEB2498984"},"external_urls":{"spotify":"https://open.spotify.com/track/5GfuxjkgreyoCVmb0FYxcH"},"href":"https://api.spotify.com/v1/tracks/5GfuxjkgreyoCVmb0FYxcH","id":"5GfuxjkgreyoCVmb0FYxcH","is_local":false,"is_playable":true,"name":"Current Location","track_number":1,"type":"track","uri":"spotify:track:5GfuxjkgreyoCVmb0FYxcH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6wGSlC6jYescUdw2LV4Cpj"},"href":"https://api.spotify.com/v1/albums/6wGSlC6jYescUdw2LV4Cpj","id":"6wGSlC6jYescUdw2LV4Cpj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dec55598c6743f537e2c4f2b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dec55598c6743f537e2c4f2b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dec55598c6743f537e2c4f2b"}],"is_playable":true,"name":"2021 Frosh Week","release_date":"2022-05-25","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:6wGSlC6jYescUdw2LV4Cpj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/59YEufF59Lv34MX3wrUF9M"},"href":"https://api.spotify.com/v1/tracks/59YEufF59Lv34MX3wrUF9M","id":"59YEufF59Lv34MX3wrUF9M","is_local":false,"is_playable":true,"name":"Location","track_number":22,"type":"track","uri":"spotify:track:59YEufF59Lv34MX3wrUF9M"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7EQz3R6P9BWhH9Mj0h29wo"},"href":"https://api.spotify.com/v1/albums/7EQz3R6P9BWhH9Mj0h29wo","id":"7EQz3R6P9BWhH9Mj0h29wo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27328669ef7f096b2ef16761584"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0228669ef7f096b2ef16761584"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485128669ef7f096b2ef16761584"}],"is_playable":true,"name":"Soir\u00e9e Afro","release_date":"2024-12-13","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:7EQz3R6P9BWhH9Mj0h29wo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/3ZYkyGIFDg31U550qm1CuG"},"href":"https://api.spotify.com/v1/tracks/3ZYkyGIFDg31U550qm1CuG","id":"3ZYkyGIFDg31U550qm1CuG","is_local":false,"is_playable":true,"name":"Location","track_number":11,"type":"track","uri":"spotify:track:3ZYkyGIFDg31U550qm1CuG"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5k6nLi3HfwdbUY4la0dIex"},"href":"https://api.spotify.com/v1/albums/5k6nLi3HfwdbUY4la0dIex","id":"5k6nLi3HfwdbUY4la0dIex","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739b21a15f8f5597cee20df955"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029b21a15f8f5597cee20df955"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519b21a15f8f5597cee20df955"}],"is_playable":true,"name":"African Heatwave: Afrobeats Party Anthems","release_date":"2023-06-26","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:5k6nLi3HfwdbUY4la0dIex"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/0XyRaApXK6vLcqhdz09evP"},"href":"https://api.spotify.com/v1/tracks/0XyRaApXK6vLcqhdz09evP","id":"0XyRaApXK6vLcqhdz09evP","is_local":false,"is_playable":true,"name":"Location","track_number":16,"type":"track","uri":"spotify:track:0XyRaApXK6vLcqhdz09evP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0zr6rTmFdN2gRgaTnqdwF4"},"href":"https://api.spotify.com/v1/albums/0zr6rTmFdN2gRgaTnqdwF4","id":"0zr6rTmFdN2gRgaTnqdwF4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732f8f8fd3a353bd6b4d0ae732"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022f8f8fd3a353bd6b4d0ae732"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512f8f8fd3a353bd6b4d0ae732"}],"is_playable":true,"name":"Hip Hop Motivation","release_date":"2025-03-14","release_date_precision":"day","total_tracks":76,"type":"album","uri":"spotify:album:0zr6rTmFdN2gRgaTnqdwF4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/4UlGS963EhepMtaWhWy1wR"},"href":"https://api.spotify.com/v1/tracks/4UlGS963EhepMtaWhWy1wR","id":"4UlGS963EhepMtaWhWy1wR","is_local":false,"is_playable":true,"name":"Location","track_number":17,"type":"track","uri":"spotify:track:4UlGS963EhepMtaWhWy1wR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3NLUVIMXPslOxKDXGClpku"},"href":"https://api.spotify.com/v1/albums/3NLUVIMXPslOxKDXGClpku","id":"3NLUVIMXPslOxKDXGClpku","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732df926d873d81a7c38ac421f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022df926d873d81a7c38ac421f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512df926d873d81a7c38ac421f"}],"is_playable":true,"name":"Music Is Freedom Vol 4","release_date":"2023-05-06","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:3NLUVIMXPslOxKDXGClpku"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/3llKSvsorjTQSpLsZAazsR"},"href":"https://api.spotify.com/v1/tracks/3llKSvsorjTQSpLsZAazsR","id":"3llKSvsorjTQSpLsZAazsR","is_local":false,"is_playable":true,"name":"Location","track_number":17,"type":"track","uri":"spotify:track:3llKSvsorjTQSpLsZAazsR"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Location%22%20artist%3A%22Dave%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"}],"external_urls":{"spotify":"https://open.spotify.com/album/4LU4HbH4wC2pW40UT6mnPv"},"href":"https://api.spotify.com/v1/albums/4LU4HbH4wC2pW40UT6mnPv","id":"4LU4HbH4wC2pW40UT6mnPv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273565f69a950084775df6a4e77"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02565f69a950084775df6a4e77"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851565f69a950084775df6a4e77"}],"is_playable":true,"name":"PSYCHODRAMA","release_date":"2019-03-08","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4LU4HbH4wC2pW40UT6mnPv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/6KFWubocLBhrLs31RpEdR9"},"href":"https://api.spotify.com/v1/tracks/6KFWubocLBhrLs31RpEdR9","id":"6KFWubocLBhrLs31RpEdR9","is_local":false,"is_playable":true,"name":"Location (feat. Burna Boy)","track_number":5,"type":"track","uri":"spotify:track:6KFWubocLBhrLs31RpEdR9"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/47NVhdktZbY7ZF7pyG7wj5"},"href":"https://api.spotify.com/v1/albums/47NVhdktZbY7ZF7pyG7wj5","id":"47NVhdktZbY7ZF7pyG7wj5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27342890c4ceb537edb4b888d2a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0242890c4ceb537edb4b888d2a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485142890c4ceb537edb4b888d2a"}],"is_playable":true,"name":"Romantic Weekend","release_date":"2023-08-29","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:47NVhdktZbY7ZF7pyG7wj5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/0DPxIKOinT0BG2FYWLr6CR"},"href":"https://api.spotify.com/v1/tracks/0DPxIKOinT0BG2FYWLr6CR","id":"0DPxIKOinT0BG2FYWLr6CR","is_local":false,"is_playable":true,"name":"Location","track_number":5,"type":"track","uri":"spotify:track:0DPxIKOinT0BG2FYWLr6CR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6RkBknh6Ry98uAOLEnhd0P"},"href":"https://api.spotify.com/v1/albums/6RkBknh6Ry98uAOLEnhd0P","id":"6RkBknh6Ry98uAOLEnhd0P","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27324342f44703de922af7c5877"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0224342f44703de922af7c5877"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485124342f44703de922af7c5877"}],"is_playable":true,"name":"Afrobeats 2023 I Afro Hits I Afropop","release_date":"2023-03-13","release_date_precision":"day","total_tracks":35,"type":"album","uri":"spotify:album:6RkBknh6Ry98uAOLEnhd0P"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/4cilxSPZMGdl6EubAEdMkf"},"href":"https://api.spotify.com/v1/tracks/4cilxSPZMGdl6EubAEdMkf","id":"4cilxSPZMGdl6EubAEdMkf","is_local":false,"is_playable":true,"name":"Location","track_number":12,"type":"track","uri":"spotify:track:4cilxSPZMGdl6EubAEdMkf"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/24oDE0vaH0JH83VNAQ7pGL"},"href":"https://api.spotify.com/v1/artists/24oDE0vaH0JH83VNAQ7pGL","id":"24oDE0vaH0JH83VNAQ7pGL","name":"Nick Marks","type":"artist","uri":"spotify:artist:24oDE0vaH0JH83VNAQ7pGL"}],"external_urls":{"spotify":"https://open.spotify.com/album/3p8skRnnsYB1rZOODgyyhr"},"href":"https://api.spotify.com/v1/albums/3p8skRnnsYB1rZOODgyyhr","id":"3p8skRnnsYB1rZOODgyyhr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27314c2b617e2789ac325698467"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0214c2b617e2789ac325698467"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485114c2b617e2789ac325698467"}],"is_playable":true,"name":"Cinematic Chromatics Vol. III","release_date":"2025-02-07","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:3p8skRnnsYB1rZOODgyyhr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/24oDE0vaH0JH83VNAQ7pGL"},"href":"https://api.spotify.com/v1/artists/24oDE0vaH0JH83VNAQ7pGL","id":"24oDE0vaH0JH83VNAQ7pGL","name":"Nick Marks","type":"artist","uri":"spotify:artist:24oDE0vaH0JH83VNAQ7pGL"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0994Up3Ob4zUFm3OFOWpzJ"},"href":"https://api.spotify.com/v1/artists/0994Up3Ob4zUFm3OFOWpzJ","id":"0994Up3Ob4zUFm3OFOWpzJ","name":"CARRTOONS","type":"artist","uri":"spotify:artist:0994Up3Ob4zUFm3OFOWpzJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7gBlwt8sGulq5GXOmgCY0x"},"href":"https://api.spotify.com/v1/artists/7gBlwt8sGulq5GXOmgCY0x","id":"7gBlwt8sGulq5GXOmgCY0x","name":"Dave Levy","type":"artist","uri":"spotify:artist:7gBlwt8sGulq5GXOmgCY0x"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0DlkcshSnSMw3Hk7SBNZwC"},"href":"https://api.spotify.com/v1/artists/0DlkcshSnSMw3Hk7SBNZwC","id":"0DlkcshSnSMw3Hk7SBNZwC","name":"Chien Chien Lu","type":"artist","uri":"spotify:artist:0DlkcshSnSMw3Hk7SBNZwC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3DgNAIw7AsEgqkGbI2MsMX"},"href":"https://api.spotify.com/v1/artists/3DgNAIw7AsEgqkGbI2MsMX","id":"3DgNAIw7AsEgqkGbI2MsMX","name":"Chris Ott","type":"artist","uri":"spotify:artist:3DgNAIw7AsEgqkGbI2MsMX"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4sPCH1tWFrUWRvJrA2YVjR"},"href":"https://api.spotify.com/v1/artists/4sPCH1tWFrUWRvJrA2YVjR","id":"4sPCH1tWFrUWRvJrA2YVjR","name":"Brittany Harris","type":"artist","uri":"spotify:artist:4sPCH1tWFrUWRvJrA2YVjR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5uLyADgoaWkfY0YYhnH9uU"},"href":"https://api.spotify.com/v1/artists/5uLyADgoaWkfY0YYhnH9uU","id":"5uLyADgoaWkfY0YYhnH9uU","name":"Doron Lev","type":"artist","uri":"spotify:artist:5uLyADgoaWkfY0YYhnH9uU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Iqi4vGZ1YDxUn9oAqqxXH"},"href":"https://api.spotify.com/v1/artists/1Iqi4vGZ1YDxUn9oAqqxXH","id":"1Iqi4vGZ1YDxUn9oAqqxXH","name":"Benjamin Furman","type":"artist","uri":"spotify:artist:1Iqi4vGZ1YDxUn9oAqqxXH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1eIZ7Vm6CvnaQog3Bs1JaH"},"href":"https://api.spotify.com/v1/artists/1eIZ7Vm6CvnaQog3Bs1JaH","id":"1eIZ7Vm6CvnaQog3Bs1JaH","name":"Sarpay Ozcagatay","type":"artist","uri":"spotify:artist:1eIZ7Vm6CvnaQog3Bs1JaH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1U0BLmf5xzFer1LoQHrhkn"},"href":"https://api.spotify.com/v1/artists/1U0BLmf5xzFer1LoQHrhkn","id":"1U0BLmf5xzFer1LoQHrhkn","name":"Leandro Pellegrino","type":"artist","uri":"spotify:artist:1U0BLmf5xzFer1LoQHrhkn"}],"disc_number":1,"duration_ms":244174,"explicit":false,"external_ids":{"isrc":"QZZEB2498984"},"external_urls":{"spotify":"https://open.spotify.com/track/5GfuxjkgreyoCVmb0FYxcH"},"href":"https://api.spotify.com/v1/tracks/5GfuxjkgreyoCVmb0FYxcH","id":"5GfuxjkgreyoCVmb0FYxcH","is_local":false,"is_playable":true,"name":"Current Location","track_number":1,"type":"track","uri":"spotify:track:5GfuxjkgreyoCVmb0FYxcH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6wGSlC6jYescUdw2LV4Cpj"},"href":"https://api.spotify.com/v1/albums/6wGSlC6jYescUdw2LV4Cpj","id":"6wGSlC6jYescUdw2LV4Cpj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dec55598c6743f537e2c4f2b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dec55598c6743f537e2c4f2b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dec55598c6743f537e2c4f2b"}],"is_playable":true,"name":"2021 Frosh Week","release_date":"2022-05-25","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:6wGSlC6jYescUdw2LV4Cpj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/59YEufF59Lv34MX3wrUF9M"},"href":"https://api.spotify.com/v1/tracks/59YEufF59Lv34MX3wrUF9M","id":"59YEufF59Lv34MX3wrUF9M","is_local":false,"is_playable":true,"name":"Location","track_number":22,"type":"track","uri":"spotify:track:59YEufF59Lv34MX3wrUF9M"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7EQz3R6P9BWhH9Mj0h29wo"},"href":"https://api.spotify.com/v1/albums/7EQz3R6P9BWhH9Mj0h29wo","id":"7EQz3R6P9BWhH9Mj0h29wo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27328669ef7f096b2ef16761584"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0228669ef7f096b2ef16761584"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485128669ef7f096b2ef16761584"}],"is_playable":true,"name":"Soir\u00e9e Afro","release_date":"2024-12-13","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:7EQz3R6P9BWhH9Mj0h29wo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/3ZYkyGIFDg31U550qm1CuG"},"href":"https://api.spotify.com/v1/tracks/3ZYkyGIFDg31U550qm1CuG","id":"3ZYkyGIFDg31U550qm1CuG","is_local":false,"is_playable":true,"name":"Location","track_number":11,"type":"track","uri":"spotify:track:3ZYkyGIFDg31U550qm1CuG"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5k6nLi3HfwdbUY4la0dIex"},"href":"https://api.spotify.com/v1/albums/5k6nLi3HfwdbUY4la0dIex","id":"5k6nLi3HfwdbUY4la0dIex","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739b21a15f8f5597cee20df955"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029b21a15f8f5597cee20df955"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519b21a15f8f5597cee20df955"}],"is_playable":true,"name":"African Heatwave: Afrobeats Party Anthems","release_date":"2023-06-26","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:5k6nLi3HfwdbUY4la0dIex"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/0XyRaApXK6vLcqhdz09evP"},"href":"https://api.spotify.com/v1/tracks/0XyRaApXK6vLcqhdz09evP","id":"0XyRaApXK6vLcqhdz09evP","is_local":false,"is_playable":true,"name":"Location","track_number":16,"type":"track","uri":"spotify:track:0XyRaApXK6vLcqhdz09evP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0zr6rTmFdN2gRgaTnqdwF4"},"href":"https://api.spotify.com/v1/albums/0zr6rTmFdN2gRgaTnqdwF4","id":"0zr6rTmFdN2gRgaTnqdwF4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732f8f8fd3a353bd6b4d0ae732"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022f8f8fd3a353bd6b4d0ae732"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512f8f8fd3a353bd6b4d0ae732"}],"is_playable":true,"name":"Hip Hop Motivation","release_date":"2025-03-14","release_date_precision":"day","total_tracks":76,"type":"album","uri":"spotify:album:0zr6rTmFdN2gRgaTnqdwF4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/4UlGS963EhepMtaWhWy1wR"},"href":"https://api.spotify.com/v1/tracks/4UlGS963EhepMtaWhWy1wR","id":"4UlGS963EhepMtaWhWy1wR","is_local":false,"is_playable":true,"name":"Location","track_number":17,"type":"track","uri":"spotify:track:4UlGS963EhepMtaWhWy1wR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3NLUVIMXPslOxKDXGClpku"},"href":"https://api.spotify.com/v1/albums/3NLUVIMXPslOxKDXGClpku","id":"3NLUVIMXPslOxKDXGClpku","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732df926d873d81a7c38ac421f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022df926d873d81a7c38ac421f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512df926d873d81a7c38ac421f"}],"is_playable":true,"name":"Music Is Freedom Vol 4","release_date":"2023-05-06","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:3NLUVIMXPslOxKDXGClpku"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ip8FS7vWT1uKkJSweANQK"},"href":"https://api.spotify.com/v1/artists/6Ip8FS7vWT1uKkJSweANQK","id":"6Ip8FS7vWT1uKkJSweANQK","name":"Dave","type":"artist","uri":"spotify:artist:6Ip8FS7vWT1uKkJSweANQK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":241293,"explicit":true,"external_ids":{"isrc":"GBUM71900578"},"external_urls":{"spotify":"https://open.spotify.com/track/3llKSvsorjTQSpLsZAazsR"},"href":"https://api.spotify.com/v1/tracks/3llKSvsorjTQSpLsZAazsR","id":"3llKSvsorjTQSpLsZAazsR","is_local":false,"is_playable":true,"name":"Location","track_number":17,"type":"track","uri":"spotify:track:3llKSvsorjTQSpLsZAazsR"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Location%22+artist%3A%22Dave%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Alright%22%20artist%3A%22Kendrick%20Lamar%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":6,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/7ycBtnsMtyVbbwTfJwRjSP"},"href":"https://api.spotify.com/v1/albums/7ycBtnsMtyVbbwTfJwRjSP","id":"7ycBtnsMtyVbbwTfJwRjSP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cdb645498cd3d8a2db4d05e1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cdb645498cd3d8a2db4d05e1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cdb645498cd3d8a2db4d05e1"}],"is_playable":true,"name":"To Pimp A Butterfly","release_date":"2015-03-16","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:7ycBtnsMtyVbbwTfJwRjSP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":219333,"explicit":true,"external_ids":{"isrc":"USUM71502498"},"external_urls":{"spotify":"https://open.spotify.com/track/3iVcZ5G6tvkXZkZKlMpIUs"},"href":"https://api.spotify.com/v1/tracks/3iVcZ5G6tvkXZkZKlMpIUs","id":"3iVcZ5G6tvkXZkZKlMpIUs","is_local":false,"is_playable":true,"name":"Alright","track_number":7,"type":"track","uri":"spotify:track:3iVcZ5G6tvkXZkZKlMpIUs"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/3VHFFHjes58Bu52Kyec26i"},"href":"https://api.spotify.com/v1/albums/3VHFFHjes58Bu52Kyec26i","id":"3VHFFHjes58Bu52Kyec26i","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734e267faafd063f288b4890bc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024e267faafd063f288b4890bc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514e267faafd063f288b4890bc"}],"is_playable":true,"name":"Alright","release_date":"2015-10-16","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3VHFFHjes58Bu52Kyec26i"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":194490,"explicit":true,"external_ids":{"isrc":"USUM71516644"},"external_urls":{"spotify":"https://open.spotify.com/track/0ECs7wpW9157Tk5yBUGbE0"},"href":"https://api.spotify.com/v1/tracks/0ECs7wpW9157Tk5yBUGbE0","id":"0ECs7wpW9157Tk5yBUGbE0","is_local":false,"is_playable":true,"name":"Alright","track_number":1,"type":"track","uri":"spotify:track:0ECs7wpW9157Tk5yBUGbE0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/6w7lqIsvDPgTChMrPw5oIL"},"href":"https://api.spotify.com/v1/albums/6w7lqIsvDPgTChMrPw5oIL","id":"6w7lqIsvDPgTChMrPw5oIL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c54f244336fd6e0e1518fe77"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c54f244336fd6e0e1518fe77"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c54f244336fd6e0e1518fe77"}],"is_playable":true,"name":"To Pimp A Butterfly","release_date":"2015-03-16","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:6w7lqIsvDPgTChMrPw5oIL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":219333,"explicit":false,"external_ids":{"isrc":"USUM71502653"},"external_urls":{"spotify":"https://open.spotify.com/track/72yHa0Zcman8jBILFZHnpG"},"href":"https://api.spotify.com/v1/tracks/72yHa0Zcman8jBILFZHnpG","id":"72yHa0Zcman8jBILFZHnpG","is_local":false,"is_playable":true,"name":"Alright","track_number":7,"type":"track","uri":"spotify:track:72yHa0Zcman8jBILFZHnpG"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0AAYy4xTc8mW495Gp9Z8Lv"},"href":"https://api.spotify.com/v1/artists/0AAYy4xTc8mW495Gp9Z8Lv","id":"0AAYy4xTc8mW495Gp9Z8Lv","name":"Gino White","type":"artist","uri":"spotify:artist:0AAYy4xTc8mW495Gp9Z8Lv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4xWrkd4ofZptXgELr80bUG"},"href":"https://api.spotify.com/v1/albums/4xWrkd4ofZptXgELr80bUG","id":"4xWrkd4ofZptXgELr80bUG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a765d273dff62b6faf9ff614"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a765d273dff62b6faf9ff614"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a765d273dff62b6faf9ff614"}],"is_playable":true,"name":"Keep It A Hunnid (The Lost Album)","release_date":"2024-06-12","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4xWrkd4ofZptXgELr80bUG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0AAYy4xTc8mW495Gp9Z8Lv"},"href":"https://api.spotify.com/v1/artists/0AAYy4xTc8mW495Gp9Z8Lv","id":"0AAYy4xTc8mW495Gp9Z8Lv","name":"Gino White","type":"artist","uri":"spotify:artist:0AAYy4xTc8mW495Gp9Z8Lv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Z6DAD7Tee7tfMxLQhFSoB"},"href":"https://api.spotify.com/v1/artists/3Z6DAD7Tee7tfMxLQhFSoB","id":"3Z6DAD7Tee7tfMxLQhFSoB","name":"Mr. KB","type":"artist","uri":"spotify:artist:3Z6DAD7Tee7tfMxLQhFSoB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7iyz5W6PYe0O7EbZbpslSj"},"href":"https://api.spotify.com/v1/artists/7iyz5W6PYe0O7EbZbpslSj","id":"7iyz5W6PYe0O7EbZbpslSj","name":"Ken P","type":"artist","uri":"spotify:artist:7iyz5W6PYe0O7EbZbpslSj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3jf5RgLcdTtNTBufSegLAa"},"href":"https://api.spotify.com/v1/artists/3jf5RgLcdTtNTBufSegLAa","id":"3jf5RgLcdTtNTBufSegLAa","name":"MacT","type":"artist","uri":"spotify:artist:3jf5RgLcdTtNTBufSegLAa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7MrRu2p3CpbpsGNkGLnWNP"},"href":"https://api.spotify.com/v1/artists/7MrRu2p3CpbpsGNkGLnWNP","id":"7MrRu2p3CpbpsGNkGLnWNP","name":"LaMarcus Q. White","type":"artist","uri":"spotify:artist:7MrRu2p3CpbpsGNkGLnWNP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4nYLdnSvawwKy9Gq4NWfEV"},"href":"https://api.spotify.com/v1/artists/4nYLdnSvawwKy9Gq4NWfEV","id":"4nYLdnSvawwKy9Gq4NWfEV","name":"Keith Ballentine","type":"artist","uri":"spotify:artist:4nYLdnSvawwKy9Gq4NWfEV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/36q88ytrQToZavYEYrWv9u"},"href":"https://api.spotify.com/v1/artists/36q88ytrQToZavYEYrWv9u","id":"36q88ytrQToZavYEYrWv9u","name":"Kendrick Patton","type":"artist","uri":"spotify:artist:36q88ytrQToZavYEYrWv9u"}],"disc_number":1,"duration_ms":255233,"explicit":true,"external_ids":{"isrc":"QZSYP2490408"},"external_urls":{"spotify":"https://open.spotify.com/track/2ip1UIykZycqZToCaYwH81"},"href":"https://api.spotify.com/v1/tracks/2ip1UIykZycqZToCaYwH81","id":"2ip1UIykZycqZToCaYwH81","is_local":false,"is_playable":true,"name":"Make It Alright","track_number":6,"type":"track","uri":"spotify:track:2ip1UIykZycqZToCaYwH81"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3dSBCdYaODjsaBHceBiLyv"},"href":"https://api.spotify.com/v1/albums/3dSBCdYaODjsaBHceBiLyv","id":"3dSBCdYaODjsaBHceBiLyv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e45081495e3a5c7241b20854"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e45081495e3a5c7241b20854"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e45081495e3a5c7241b20854"}],"is_playable":true,"name":"Temazos Variados Pal Viaje En Carro","release_date":"2025-03-21","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:3dSBCdYaODjsaBHceBiLyv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":219333,"explicit":true,"external_ids":{"isrc":"USUM71502498"},"external_urls":{"spotify":"https://open.spotify.com/track/0T2aVnAZs5ObAUvIsQ8idW"},"href":"https://api.spotify.com/v1/tracks/0T2aVnAZs5ObAUvIsQ8idW","id":"0T2aVnAZs5ObAUvIsQ8idW","is_local":false,"is_playable":true,"name":"Alright","track_number":14,"type":"track","uri":"spotify:track:0T2aVnAZs5ObAUvIsQ8idW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6P6fj2IMjHS4IJ9ScyKAjq"},"href":"https://api.spotify.com/v1/albums/6P6fj2IMjHS4IJ9ScyKAjq","id":"6P6fj2IMjHS4IJ9ScyKAjq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734e8abf1b6436604fa11cd942"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024e8abf1b6436604fa11cd942"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514e8abf1b6436604fa11cd942"}],"is_playable":true,"name":"Gym Hip-Hopping","release_date":"2025-03-21","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:6P6fj2IMjHS4IJ9ScyKAjq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":219333,"explicit":true,"external_ids":{"isrc":"USUM71502498"},"external_urls":{"spotify":"https://open.spotify.com/track/1ls7CJHrAAVVO2tMSlxP7p"},"href":"https://api.spotify.com/v1/tracks/1ls7CJHrAAVVO2tMSlxP7p","id":"1ls7CJHrAAVVO2tMSlxP7p","is_local":false,"is_playable":true,"name":"Alright","track_number":8,"type":"track","uri":"spotify:track:1ls7CJHrAAVVO2tMSlxP7p"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkFscmlnaHQlMjIlMjBhcnRpc3QlM0ElMjJLZW5kcmljayUyMExhbWFyJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo2LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzd5Y0J0bnNNdHlWYmJ3VGZKd1JqU1AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83eWNCdG5zTXR5VmJid1RmSndSalNQIiwiaWQiOiI3eWNCdG5zTXR5VmJid1RmSndSalNQIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4u", + "Y28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2NkYjY0NTQ5OGNkM2Q4YTJkYjRkMDVlMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjZGI2NDU0OThjZDNkOGEyZGI0ZDA1ZTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWNkYjY0NTQ5OGNkM2Q4YTJkYjRkMDVlMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUbyBQaW1wIEEgQnV0dGVyZmx5IiwicmVsZWFzZV9kYXRlIjoiMjAxNS0wMy0xNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjd5Y0J0bnNNdHlWYmJ3VGZKd1JqU1AifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTkzMzMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTUwMjQ5OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2lWY1o1RzZ0dmtYWmtaS2xNcElVcyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNpVmNaNUc2dHZrWFprWktsTXBJVXMiLCJpZCI6IjNpVmNaNUc2dHZrWFprWktsTXBJVXMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWxyaWdodCIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozaVZjWjVHNnR2a1haa1pLbE1wSVVzIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIg==", + "OiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM1ZIRkZIamVzNThCdTUyS3llYzI2aSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNWSEZGSGplczU4QnU1Mkt5ZWMyNmkiLCJpZCI6IjNWSEZGSGplczU4QnU1Mkt5ZWMyNmkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNGUyNjdmYWFmZDA2M2YyODhiNDg5MGJjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjRlMjY3ZmFhZmQwNjNmMjg4YjQ4OTBiYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNGUyNjdmYWFmZDA2M2YyODhiNDg5MGJjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFscmlnaHQiLCJyZWxlYXNlX2RhdGUiOiIyMDE1LTEwLTE2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozVkhGRkhqZXM1OEJ1NTJLeWVjMjZpIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwiaWQiOiIyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwibmFtZSI6IktlbmRyaWNrIExhbWFyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk0NDkwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzE1MTY2NDQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBFQ3M3d3BXOTE1N1RrNXlCVUdiRTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wRUNzN3dwVzkxNTdUazV5QlVHYkUwIiwiaWQiOiIwRUNzN3dwVzkxNTdUazV5QlVHYkUwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFscmlnaHQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhYw==", + "azowRUNzN3dwVzkxNTdUazV5QlVHYkUwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsImlkIjoiMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsIm5hbWUiOiJLZW5kcmljayBMYW1hciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNnc3bHFJc3ZEUGdUQ2hNclB3NW9JTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZ3N2xxSXN2RFBnVENoTXJQdzVvSUwiLCJpZCI6IjZ3N2xxSXN2RFBnVENoTXJQdzVvSUwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzU0ZjI0NDMzNmZkNmUwZTE1MThmZTc3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM1NGYyNDQzMzZmZDZlMGUxNTE4ZmU3NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzU0ZjI0NDMzNmZkNmUwZTE1MThmZTc3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvIFBpbXAgQSBCdXR0ZXJmbHkiLCJyZWxlYXNlX2RhdGUiOiIyMDE1LTAzLTE2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nnc3bHFJc3ZEUGdUQ2hNclB3NW9JTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsImlkIjoiMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsIm5hbWUiOiJLZW5kcmljayBMYW1hciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxOTMzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVQ==", + "TTcxNTAyNjUzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83MnlIYTBaY21hbjhqQklMRlpIbnBHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNzJ5SGEwWmNtYW44akJJTEZaSG5wRyIsImlkIjoiNzJ5SGEwWmNtYW44akJJTEZaSG5wRyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbHJpZ2h0IiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjcyeUhhMFpjbWFuOGpCSUxGWkhucEcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBBQVl5NHhUYzhtVzQ5NUdwOVo4THYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEFBWXk0eFRjOG1XNDk1R3A5WjhMdiIsImlkIjoiMEFBWXk0eFRjOG1XNDk1R3A5WjhMdiIsIm5hbWUiOiJHaW5vIFdoaXRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBBQVl5NHhUYzhtVzQ5NUdwOVo4THYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80eFdya2Q0b2ZacHRYZ0VMcjgwYlVHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHhXcmtkNG9mWnB0WGdFTHI4MGJVRyIsImlkIjoiNHhXcmtkNG9mWnB0WGdFTHI4MGJVRyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhNzY1ZDI3M2RmZjYyYjZmYWY5ZmY2MTQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTc2NWQyNzNkZmY2MmI2ZmFmOWZmNjE0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhNzY1ZDI3M2RmZjYyYjZmYWY5ZmY2MTQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS2VlcCBJdCBBIEh1bm5pZCAoVGhlIExvc3QgQWxidW0pIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wNi0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjR4V3JrZDRvZlpwdFhnRUxyODBiVUcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwbw==", + "dGlmeS5jb20vYXJ0aXN0LzBBQVl5NHhUYzhtVzQ5NUdwOVo4THYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEFBWXk0eFRjOG1XNDk1R3A5WjhMdiIsImlkIjoiMEFBWXk0eFRjOG1XNDk1R3A5WjhMdiIsIm5hbWUiOiJHaW5vIFdoaXRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBBQVl5NHhUYzhtVzQ5NUdwOVo4THYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1o2REFEN1RlZTd0Zk14TFFoRlNvQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zWjZEQUQ3VGVlN3RmTXhMUWhGU29CIiwiaWQiOiIzWjZEQUQ3VGVlN3RmTXhMUWhGU29CIiwibmFtZSI6Ik1yLiBLQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozWjZEQUQ3VGVlN3RmTXhMUWhGU29CIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdpeXo1VzZQWWUwTzdFYlpicHNsU2oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2l5ejVXNlBZZTBPN0ViWmJwc2xTaiIsImlkIjoiN2l5ejVXNlBZZTBPN0ViWmJwc2xTaiIsIm5hbWUiOiJLZW4gUCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3aXl6NVc2UFllME83RWJaYnBzbFNqIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNqZjVSZ0xjZFR0TlRCdWZTZWdMQWEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2pmNVJnTGNkVHROVEJ1ZlNlZ0xBYSIsImlkIjoiM2pmNVJnTGNkVHROVEJ1ZlNlZ0xBYSIsIm5hbWUiOiJNYWNUIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNqZjVSZ0xjZFR0TlRCdWZTZWdMQWEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01yUnUycDNDcGJwc0dOa0dMbldOUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXJSdTJwM0NwYnBzR05rR0xuV05QIiwiaWQiOiI3TXJSdTJwM0NwYnBzR05rR0xuV05QIiwibmFtZSI6IkxhTWFyY3VzIFEuIFdoaXRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNclJ1MnAzQ3BicHNHTmtHTG5XTlAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG5ZTGRuU3Zhd3dLeTlHcTROV2ZFViJ9LCJocmVmIjoiaHR0cHM6Lw==", + "L2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRuWUxkblN2YXd3S3k5R3E0TldmRVYiLCJpZCI6IjRuWUxkblN2YXd3S3k5R3E0TldmRVYiLCJuYW1lIjoiS2VpdGggQmFsbGVudGluZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0bllMZG5TdmF3d0t5OUdxNE5XZkVWIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzM2cTg4eXRyUVRvWmF2WUVZcld2OXUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzZxODh5dHJRVG9aYXZZRVlyV3Y5dSIsImlkIjoiMzZxODh5dHJRVG9aYXZZRVlyV3Y5dSIsIm5hbWUiOiJLZW5kcmljayBQYXR0b24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MzZxODh5dHJRVG9aYXZZRVlyV3Y5dSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTUyMzMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaU1lQMjQ5MDQwOCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMmlwMVVJeWtaeWNxWlRvQ2FZd0g4MSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJpcDFVSXlrWnljcVpUb0NhWXdIODEiLCJpZCI6IjJpcDFVSXlrWnljcVpUb0NhWXdIODEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWFrZSBJdCBBbHJpZ2h0IiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJpcDFVSXlrWnljcVpUb0NhWXdIODEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2RTQkNkWWFPRGpzYUJIY2VCaUx5diJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNkU0JDZFlhT0Rqc2FCSGNlQmlMeXYiLCJpZCI6IjNkU0JDZFlhT0Rqc2FCSGNlQmlMeXYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLA==", + "IndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlNDUwODE0OTVlM2E1YzcyNDFiMjA4NTQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTQ1MDgxNDk1ZTNhNWM3MjQxYjIwODU0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlNDUwODE0OTVlM2E1YzcyNDFiMjA4NTQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGVtYXpvcyBWYXJpYWRvcyBQYWwgVmlhamUgRW4gQ2Fycm8iLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTAzLTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2RTQkNkWWFPRGpzYUJIY2VCaUx5diJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsImlkIjoiMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsIm5hbWUiOiJLZW5kcmljayBMYW1hciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxOTMzMywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxNTAyNDk4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wVDJhVm5BWnM1T2JBVXZJc1E4aWRXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMFQyYVZuQVpzNU9iQVV2SXNROGlkVyIsImlkIjoiMFQyYVZuQVpzNU9iQVV2SXNROGlkVyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbHJpZ2h0IiwidHJhY2tfbnVtYmVyIjoxNCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowVDJhVm5BWnM1T2JBVXZJc1E4aWRXIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIg==", + "OiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNlA2ZmoySU1qSFM0SUo5U2N5S0FqcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZQNmZqMklNakhTNElKOVNjeUtBanEiLCJpZCI6IjZQNmZqMklNakhTNElKOVNjeUtBanEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNGU4YWJmMWI2NDM2NjA0ZmExMWNkOTQyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjRlOGFiZjFiNjQzNjYwNGZhMTFjZDk0MiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNGU4YWJmMWI2NDM2NjA0ZmExMWNkOTQyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikd5bSBIaXAtSG9wcGluZyIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDMtMjEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2UDZmajJJTWpIUzRJSjlTY3lLQWpxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwiaWQiOiIyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwibmFtZSI6IktlbmRyaWNrIExhbWFyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE5MzMzLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzE1MDI0OTgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFsczdDSkhyQUFWVk8ydE1TbHhQN3AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xbHM3Q0pIckFBVlZPMnRNU2x4UDdwIiwiaWQiOiIxbHM3Q0pIckFBVlZPMnRNU2x4UDdwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibg==", + "YW1lIjoiQWxyaWdodCIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxbHM3Q0pIckFBVlZPMnRNU2x4UDdwIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Alright%22+artist%3A%22Kendrick+Lamar%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Ladbroke%20Grove%22%20artist%3A%22AJ%20Tracey%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Xi6LSfFqv26XgP9NKN26U"},"href":"https://api.spotify.com/v1/artists/4Xi6LSfFqv26XgP9NKN26U","id":"4Xi6LSfFqv26XgP9NKN26U","name":"AJ Tracey","type":"artist","uri":"spotify:artist:4Xi6LSfFqv26XgP9NKN26U"}],"external_urls":{"spotify":"https://open.spotify.com/album/45UWSDr4RrFAwNfqiFelNj"},"href":"https://api.spotify.com/v1/albums/45UWSDr4RrFAwNfqiFelNj","id":"45UWSDr4RrFAwNfqiFelNj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c66802be82ab680ce70ba32a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c66802be82ab680ce70ba32a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c66802be82ab680ce70ba32a"}],"is_playable":true,"name":"AJ Tracey","release_date":"2019-02-08","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:45UWSDr4RrFAwNfqiFelNj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Xi6LSfFqv26XgP9NKN26U"},"href":"https://api.spotify.com/v1/artists/4Xi6LSfFqv26XgP9NKN26U","id":"4Xi6LSfFqv26XgP9NKN26U","name":"AJ Tracey","type":"artist","uri":"spotify:artist:4Xi6LSfFqv26XgP9NKN26U"}],"disc_number":1,"duration_ms":190537,"explicit":false,"external_ids":{"isrc":"UKQNW1800013"},"external_urls":{"spotify":"https://open.spotify.com/track/7AODNxFNPnKaz4hURLzw5l"},"href":"https://api.spotify.com/v1/tracks/7AODNxFNPnKaz4hURLzw5l","id":"7AODNxFNPnKaz4hURLzw5l","is_local":false,"is_playable":true,"name":"Ladbroke Grove","track_number":11,"type":"track","uri":"spotify:track:7AODNxFNPnKaz4hURLzw5l"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Xi6LSfFqv26XgP9NKN26U"},"href":"https://api.spotify.com/v1/artists/4Xi6LSfFqv26XgP9NKN26U","id":"4Xi6LSfFqv26XgP9NKN26U","name":"AJ Tracey","type":"artist","uri":"spotify:artist:4Xi6LSfFqv26XgP9NKN26U"}],"external_urls":{"spotify":"https://open.spotify.com/album/1aq5dh3BA8SOhrtjmAHroM"},"href":"https://api.spotify.com/v1/albums/1aq5dh3BA8SOhrtjmAHroM","id":"1aq5dh3BA8SOhrtjmAHroM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730d07b6c0e5f8a69e8562e9f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020d07b6c0e5f8a69e8562e9f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510d07b6c0e5f8a69e8562e9f7"}],"is_playable":true,"name":"AJ Tracey (Deluxe)","release_date":"2019-10-25","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:1aq5dh3BA8SOhrtjmAHroM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Xi6LSfFqv26XgP9NKN26U"},"href":"https://api.spotify.com/v1/artists/4Xi6LSfFqv26XgP9NKN26U","id":"4Xi6LSfFqv26XgP9NKN26U","name":"AJ Tracey","type":"artist","uri":"spotify:artist:4Xi6LSfFqv26XgP9NKN26U"}],"disc_number":1,"duration_ms":190537,"explicit":false,"external_ids":{"isrc":"UKQNW1800013"},"external_urls":{"spotify":"https://open.spotify.com/track/2DIibSdhPpww0nW81VOQTk"},"href":"https://api.spotify.com/v1/tracks/2DIibSdhPpww0nW81VOQTk","id":"2DIibSdhPpww0nW81VOQTk","is_local":false,"is_playable":true,"name":"Ladbroke Grove","track_number":11,"type":"track","uri":"spotify:track:2DIibSdhPpww0nW81VOQTk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Xi6LSfFqv26XgP9NKN26U"},"href":"https://api.spotify.com/v1/artists/4Xi6LSfFqv26XgP9NKN26U","id":"4Xi6LSfFqv26XgP9NKN26U","name":"AJ Tracey","type":"artist","uri":"spotify:artist:4Xi6LSfFqv26XgP9NKN26U"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2bHgAaZ7qbGbMMXwAQm48I"},"href":"https://api.spotify.com/v1/artists/2bHgAaZ7qbGbMMXwAQm48I","id":"2bHgAaZ7qbGbMMXwAQm48I","name":"General Levy","type":"artist","uri":"spotify:artist:2bHgAaZ7qbGbMMXwAQm48I"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4OPTZC24954HYBeHKeoLSc"},"href":"https://api.spotify.com/v1/artists/4OPTZC24954HYBeHKeoLSc","id":"4OPTZC24954HYBeHKeoLSc","name":"Novelist","type":"artist","uri":"spotify:artist:4OPTZC24954HYBeHKeoLSc"}],"external_urls":{"spotify":"https://open.spotify.com/album/45m8SK13zAmIyF0Fmc2ON8"},"href":"https://api.spotify.com/v1/albums/45m8SK13zAmIyF0Fmc2ON8","id":"45m8SK13zAmIyF0Fmc2ON8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b77a06d55ac91be374d24dac"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b77a06d55ac91be374d24dac"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b77a06d55ac91be374d24dac"}],"is_playable":true,"name":"Ladbroke Grove (Remix) [feat. General Levy & Novelist]","release_date":"2019-06-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:45m8SK13zAmIyF0Fmc2ON8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Xi6LSfFqv26XgP9NKN26U"},"href":"https://api.spotify.com/v1/artists/4Xi6LSfFqv26XgP9NKN26U","id":"4Xi6LSfFqv26XgP9NKN26U","name":"AJ Tracey","type":"artist","uri":"spotify:artist:4Xi6LSfFqv26XgP9NKN26U"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2bHgAaZ7qbGbMMXwAQm48I"},"href":"https://api.spotify.com/v1/artists/2bHgAaZ7qbGbMMXwAQm48I","id":"2bHgAaZ7qbGbMMXwAQm48I","name":"General Levy","type":"artist","uri":"spotify:artist:2bHgAaZ7qbGbMMXwAQm48I"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4OPTZC24954HYBeHKeoLSc"},"href":"https://api.spotify.com/v1/artists/4OPTZC24954HYBeHKeoLSc","id":"4OPTZC24954HYBeHKeoLSc","name":"Novelist","type":"artist","uri":"spotify:artist:4OPTZC24954HYBeHKeoLSc"}],"disc_number":1,"duration_ms":185184,"explicit":true,"external_ids":{"isrc":"UKQNW1800021"},"external_urls":{"spotify":"https://open.spotify.com/track/0s2bqeJ8Sr9YAjcmELP7dh"},"href":"https://api.spotify.com/v1/tracks/0s2bqeJ8Sr9YAjcmELP7dh","id":"0s2bqeJ8Sr9YAjcmELP7dh","is_local":false,"is_playable":true,"name":"Ladbroke Grove (Remix) [feat. General Levy & Novelist]","track_number":1,"type":"track","uri":"spotify:track:0s2bqeJ8Sr9YAjcmELP7dh"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1lMcg4Y7nW5hHgIVsN9Shn"},"href":"https://api.spotify.com/v1/artists/1lMcg4Y7nW5hHgIVsN9Shn","id":"1lMcg4Y7nW5hHgIVsN9Shn","name":"Conducta","type":"artist","uri":"spotify:artist:1lMcg4Y7nW5hHgIVsN9Shn"}],"external_urls":{"spotify":"https://open.spotify.com/album/6vJ5kjSmxUvdxBhQS2Cigl"},"href":"https://api.spotify.com/v1/albums/6vJ5kjSmxUvdxBhQS2Cigl","id":"6vJ5kjSmxUvdxBhQS2Cigl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273443097f140426b9397d5b63b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02443097f140426b9397d5b63b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851443097f140426b9397d5b63b"}],"is_playable":true,"name":"The Kiwi Sound (DJ Mix)","release_date":"2020-03-06","release_date_precision":"day","total_tracks":38,"type":"album","uri":"spotify:album:6vJ5kjSmxUvdxBhQS2Cigl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Xi6LSfFqv26XgP9NKN26U"},"href":"https://api.spotify.com/v1/artists/4Xi6LSfFqv26XgP9NKN26U","id":"4Xi6LSfFqv26XgP9NKN26U","name":"AJ Tracey","type":"artist","uri":"spotify:artist:4Xi6LSfFqv26XgP9NKN26U"}],"disc_number":1,"duration_ms":113240,"explicit":false,"external_ids":{"isrc":"UKQNV2000030"},"external_urls":{"spotify":"https://open.spotify.com/track/6xoxGJjKdJokXhPEpNfzFI"},"href":"https://api.spotify.com/v1/tracks/6xoxGJjKdJokXhPEpNfzFI","id":"6xoxGJjKdJokXhPEpNfzFI","is_local":false,"is_playable":true,"name":"Ladbroke Grove - Mixed","track_number":1,"type":"track","uri":"spotify:track:6xoxGJjKdJokXhPEpNfzFI"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkxhZGJyb2tlJTIwR3JvdmUlMjIlMjBhcnRpc3QlM0ElMjJBSiUyMFRyYWNleSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFhpNkxTZkZxdjI2WGdQOU5LTjI2VSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80WGk2TFNmRnF2MjZYZ1A5TktOMjZVIiwiaWQiOiI0WGk2TFNmRnF2MjZYZ1A5TktOMjZVIiwibmFtZSI6IkFKIFRyYWNleSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0WGk2TFNmRnF2MjZYZ1A5TktOMjZVIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNDVVV1NEcjRSckZBd05mcWlGZWxOaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzQ1VVdTRHI0UnJGQXdOZnFpRmVsTmoiLCJpZCI6IjQ1VVdTRHI0UnJGQXdOZnFpRmVsTmoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jbw==", + "L2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjNjY4MDJiZTgyYWI2ODBjZTcwYmEzMmEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzY2ODAyYmU4MmFiNjgwY2U3MGJhMzJhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNjY4MDJiZTgyYWI2ODBjZTcwYmEzMmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQUogVHJhY2V5IiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wMi0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjQ1VVdTRHI0UnJGQXdOZnFpRmVsTmoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80WGk2TFNmRnF2MjZYZ1A5TktOMjZVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRYaTZMU2ZGcXYyNlhnUDlOS04yNlUiLCJpZCI6IjRYaTZMU2ZGcXYyNlhnUDlOS04yNlUiLCJuYW1lIjoiQUogVHJhY2V5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRYaTZMU2ZGcXYyNlhnUDlOS04yNlUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTkwNTM3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVUtRTlcxODAwMDEzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83QU9ETnhGTlBuS2F6NGhVUkx6dzVsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN0FPRE54Rk5QbkthejRoVVJMenc1bCIsImlkIjoiN0FPRE54Rk5QbkthejRoVVJMenc1bCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMYWRicm9rZSBHcm92ZSIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N0FPRE54Rk5QbkthejRoVVJMenc1bCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80WGk2TFNmRnF2MjZYZ1A5TktOMjZVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRYaTZMU2ZGcXYyNlhnUDlOS04yNlUiLCJpZCI6IjRYaTZMU2ZGcXYyNlhnUDlOS04yNlUiLCJuYW1lIjoiQUogVHJhY2V5IiwidHlwZSI6ImFydGlzdCIsInVyaQ==", + "Ijoic3BvdGlmeTphcnRpc3Q6NFhpNkxTZkZxdjI2WGdQOU5LTjI2VSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFhcTVkaDNCQThTT2hydGptQUhyb00ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xYXE1ZGgzQkE4U09ocnRqbUFIcm9NIiwiaWQiOiIxYXE1ZGgzQkE4U09ocnRqbUFIcm9NIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzBkMDdiNmMwZTVmOGE2OWU4NTYyZTlmNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwZDA3YjZjMGU1ZjhhNjllODU2MmU5ZjcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTBkMDdiNmMwZTVmOGE2OWU4NTYyZTlmNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBSiBUcmFjZXkgKERlbHV4ZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTEwLTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MWFxNWRoM0JBOFNPaHJ0am1BSHJvTSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRYaTZMU2ZGcXYyNlhnUDlOS04yNlUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFhpNkxTZkZxdjI2WGdQOU5LTjI2VSIsImlkIjoiNFhpNkxTZkZxdjI2WGdQOU5LTjI2VSIsIm5hbWUiOiJBSiBUcmFjZXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFhpNkxTZkZxdjI2WGdQOU5LTjI2VSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTA1MzcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVS1FOVzE4MDAwMTMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJESWliU2RoUHB3dzBuVzgxVk9RVGsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yRElpYlNkaFBwd3cwblc4MVZPUVRrIiwiaWQiOiIyRElpYlNkaFBwd3cwblc4MVZPUVRrIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxhZGJyb2tlIEdyb3ZlIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cg==", + "YWNrOjJESWliU2RoUHB3dzBuVzgxVk9RVGsifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRYaTZMU2ZGcXYyNlhnUDlOS04yNlUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFhpNkxTZkZxdjI2WGdQOU5LTjI2VSIsImlkIjoiNFhpNkxTZkZxdjI2WGdQOU5LTjI2VSIsIm5hbWUiOiJBSiBUcmFjZXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFhpNkxTZkZxdjI2WGdQOU5LTjI2VSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yYkhnQWFaN3FiR2JNTVh3QVFtNDhJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJiSGdBYVo3cWJHYk1NWHdBUW00OEkiLCJpZCI6IjJiSGdBYVo3cWJHYk1NWHdBUW00OEkiLCJuYW1lIjoiR2VuZXJhbCBMZXZ5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJiSGdBYVo3cWJHYk1NWHdBUW00OEkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNE9QVFpDMjQ5NTRIWUJlSEtlb0xTYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80T1BUWkMyNDk1NEhZQmVIS2VvTFNjIiwiaWQiOiI0T1BUWkMyNDk1NEhZQmVIS2VvTFNjIiwibmFtZSI6Ik5vdmVsaXN0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRPUFRaQzI0OTU0SFlCZUhLZW9MU2MifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80NW04U0sxM3pBbUl5RjBGbWMyT044In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNDVtOFNLMTN6QW1JeUYwRm1jMk9OOCIsImlkIjoiNDVtOFNLMTN6QW1JeUYwRm1jMk9OOCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiNzdhMDZkNTVhYzkxYmUzNzRkMjRkYWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjc3YTA2ZDU1YWM5MWJlMzc0ZDI0ZGFjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiNzdhMDZkNTVhYzkxYmUzNzRkMjRkYWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLA==", + "Im5hbWUiOiJMYWRicm9rZSBHcm92ZSAoUmVtaXgpIFtmZWF0LiBHZW5lcmFsIExldnkgJiBOb3ZlbGlzdF0iLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA2LTAzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0NW04U0sxM3pBbUl5RjBGbWMyT044In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFhpNkxTZkZxdjI2WGdQOU5LTjI2VSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80WGk2TFNmRnF2MjZYZ1A5TktOMjZVIiwiaWQiOiI0WGk2TFNmRnF2MjZYZ1A5TktOMjZVIiwibmFtZSI6IkFKIFRyYWNleSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0WGk2TFNmRnF2MjZYZ1A5TktOMjZVIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJiSGdBYVo3cWJHYk1NWHdBUW00OEkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmJIZ0FhWjdxYkdiTU1Yd0FRbTQ4SSIsImlkIjoiMmJIZ0FhWjdxYkdiTU1Yd0FRbTQ4SSIsIm5hbWUiOiJHZW5lcmFsIExldnkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmJIZ0FhWjdxYkdiTU1Yd0FRbTQ4SSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80T1BUWkMyNDk1NEhZQmVIS2VvTFNjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRPUFRaQzI0OTU0SFlCZUhLZW9MU2MiLCJpZCI6IjRPUFRaQzI0OTU0SFlCZUhLZW9MU2MiLCJuYW1lIjoiTm92ZWxpc3QiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NE9QVFpDMjQ5NTRIWUJlSEtlb0xTYyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODUxODQsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVLUU5XMTgwMDAyMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHMyYnFlSjhTcjlZQWpjbUVMUDdkaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBzMmJxZUo4U3I5WUFqY21FTFA3ZGgiLCJpZCI6IjBzMmJxZUo4U3I5WUFqY21FTFA3ZGgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGFkYnJva2UgR3JvdmUgKFJlbWl4KSBbZmVhdC4gR2VuZXJhbCBMZXZ5ICYgTm92ZWxpcw==", + "dF0iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHMyYnFlSjhTcjlZQWpjbUVMUDdkaCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xbE1jZzRZN25XNWhIZ0lWc045U2huIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFsTWNnNFk3blc1aEhnSVZzTjlTaG4iLCJpZCI6IjFsTWNnNFk3blc1aEhnSVZzTjlTaG4iLCJuYW1lIjoiQ29uZHVjdGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MWxNY2c0WTduVzVoSGdJVnNOOVNobiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ2SjVralNteFV2ZHhCaFFTMkNpZ2wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82dko1a2pTbXhVdmR4QmhRUzJDaWdsIiwiaWQiOiI2dko1a2pTbXhVdmR4QmhRUzJDaWdsIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQ0MzA5N2YxNDA0MjZiOTM5N2Q1YjYzYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0NDMwOTdmMTQwNDI2YjkzOTdkNWI2M2IifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQ0MzA5N2YxNDA0MjZiOTM5N2Q1YjYzYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgS2l3aSBTb3VuZCAoREogTWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDMtMDYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2dko1a2pTbXhVdmR4QmhRUzJDaWdsIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFhpNkxTZkZxdjI2WGdQOU5LTjI2VSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80WGk2TFNmRnF2MjZYZ1A5TktOMjZVIiwiaWQiOiI0WGk2TFNmRnF2MjZYZ1A5TktOMjZVIiwibmFtZSI6IkFKIFRyYWNleSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0WGk2TFNmRnF2MjZYZ1A5TktOMjZVIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjExMw==", + "MjQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVUtRTlYyMDAwMDMwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82eG94R0pqS2RKb2tYaFBFcE5mekZJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNnhveEdKaktkSm9rWGhQRXBOZnpGSSIsImlkIjoiNnhveEdKaktkSm9rWGhQRXBOZnpGSSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMYWRicm9rZSBHcm92ZSAtIE1peGVkIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZ4b3hHSmpLZEpva1hoUEVwTmZ6RkkifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Ladbroke+Grove%22+artist%3A%22AJ+Tracey%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Redbone%22%20artist%3A%22Childish%20Gambino%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"external_urls":{"spotify":"https://open.spotify.com/album/4JCybsNZUXWrK2Jpyn12Ni"},"href":"https://api.spotify.com/v1/albums/4JCybsNZUXWrK2Jpyn12Ni","id":"4JCybsNZUXWrK2Jpyn12Ni","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c29562d6e8c1f55bb1311d5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c29562d6e8c1f55bb1311d5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c29562d6e8c1f55bb1311d5"}],"is_playable":true,"name":"\"Awaken, My Love!\"","release_date":"2016-12-02","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4JCybsNZUXWrK2Jpyn12Ni"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326933,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/3vQ4T78TTMOjQXGfXVKQJo"},"href":"https://api.spotify.com/v1/tracks/3vQ4T78TTMOjQXGfXVKQJo","id":"3vQ4T78TTMOjQXGfXVKQJo","is_local":false,"is_playable":true,"name":"Redbone","track_number":6,"type":"track","uri":"spotify:track:3vQ4T78TTMOjQXGfXVKQJo"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4zudhmy5HSHVZ1y3gPfbAB"},"href":"https://api.spotify.com/v1/albums/4zudhmy5HSHVZ1y3gPfbAB","id":"4zudhmy5HSHVZ1y3gPfbAB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27372c666e8feebbb65253e4fba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0272c666e8feebbb65253e4fba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485172c666e8feebbb65253e4fba"}],"is_playable":true,"name":"Catch Feels","release_date":"2017-08-25","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:4zudhmy5HSHVZ1y3gPfbAB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":325272,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/1DFKBDsyc5eZKp7rhzMeNL"},"href":"https://api.spotify.com/v1/tracks/1DFKBDsyc5eZKp7rhzMeNL","id":"1DFKBDsyc5eZKp7rhzMeNL","is_local":false,"is_playable":true,"name":"Redbone","track_number":4,"type":"track","uri":"spotify:track:1DFKBDsyc5eZKp7rhzMeNL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7039WzytxariZTo4tsLUQF"},"href":"https://api.spotify.com/v1/albums/7039WzytxariZTo4tsLUQF","id":"7039WzytxariZTo4tsLUQF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27352bc5b49e2100091d225f95d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0252bc5b49e2100091d225f95d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485152bc5b49e2100091d225f95d"}],"is_playable":true,"name":"Nova Tunes 3.5","release_date":"2017-03-17","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7039WzytxariZTo4tsLUQF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":324226,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/3aXo6nJjexSdb6wCpN7Ysy"},"href":"https://api.spotify.com/v1/tracks/3aXo6nJjexSdb6wCpN7Ysy","id":"3aXo6nJjexSdb6wCpN7Ysy","is_local":false,"is_playable":true,"name":"Redbone","track_number":8,"type":"track","uri":"spotify:track:3aXo6nJjexSdb6wCpN7Ysy"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/37vQAfEaacxeV4MGN31e9D"},"href":"https://api.spotify.com/v1/albums/37vQAfEaacxeV4MGN31e9D","id":"37vQAfEaacxeV4MGN31e9D","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b230fc4671b83d89951dd23f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b230fc4671b83d89951dd23f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b230fc4671b83d89951dd23f"}],"is_playable":true,"name":"R&Bae","release_date":"2017-07-07","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:37vQAfEaacxeV4MGN31e9D"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":325960,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/41OPM65MGwtCT0D4iAJ6qP"},"href":"https://api.spotify.com/v1/tracks/41OPM65MGwtCT0D4iAJ6qP","id":"41OPM65MGwtCT0D4iAJ6qP","is_local":false,"is_playable":true,"name":"Redbone","track_number":1,"type":"track","uri":"spotify:track:41OPM65MGwtCT0D4iAJ6qP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5TszsWpms1lnB7c6EJ4Ux2"},"href":"https://api.spotify.com/v1/albums/5TszsWpms1lnB7c6EJ4Ux2","id":"5TszsWpms1lnB7c6EJ4Ux2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c05d415d1a371eadd2c4023"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c05d415d1a371eadd2c4023"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c05d415d1a371eadd2c4023"}],"is_playable":true,"name":"Hip Hop Love Songs","release_date":"2017-11-17","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:5TszsWpms1lnB7c6EJ4Ux2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326933,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/6u29Or89nZ784Mhgp1cuz4"},"href":"https://api.spotify.com/v1/tracks/6u29Or89nZ784Mhgp1cuz4","id":"6u29Or89nZ784Mhgp1cuz4","is_local":false,"is_playable":true,"name":"Redbone","track_number":2,"type":"track","uri":"spotify:track:6u29Or89nZ784Mhgp1cuz4"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/770DSqP3I7AwvIcd5pI6Od"},"href":"https://api.spotify.com/v1/albums/770DSqP3I7AwvIcd5pI6Od","id":"770DSqP3I7AwvIcd5pI6Od","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e4938ab9d8b5d085a3c0dfab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e4938ab9d8b5d085a3c0dfab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e4938ab9d8b5d085a3c0dfab"}],"is_playable":true,"name":"21st Century Funk","release_date":"2017-08-11","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:770DSqP3I7AwvIcd5pI6Od"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326229,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/3Bo79uipvzIBiOAG4zJPcm"},"href":"https://api.spotify.com/v1/tracks/3Bo79uipvzIBiOAG4zJPcm","id":"3Bo79uipvzIBiOAG4zJPcm","is_local":false,"is_playable":true,"name":"Redbone","track_number":3,"type":"track","uri":"spotify:track:3Bo79uipvzIBiOAG4zJPcm"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/12JrzzPK17E7V4kArOJJ32"},"href":"https://api.spotify.com/v1/albums/12JrzzPK17E7V4kArOJJ32","id":"12JrzzPK17E7V4kArOJJ32","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a2cc66882283cfb2cb576a19"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a2cc66882283cfb2cb576a19"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a2cc66882283cfb2cb576a19"}],"is_playable":true,"name":"Best Of 2017 Pop","release_date":"2017-12-15","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:12JrzzPK17E7V4kArOJJ32"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326880,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/6wGbDxvg8wLWnk1HxcFTTO"},"href":"https://api.spotify.com/v1/tracks/6wGbDxvg8wLWnk1HxcFTTO","id":"6wGbDxvg8wLWnk1HxcFTTO","is_local":false,"is_playable":true,"name":"Redbone","track_number":7,"type":"track","uri":"spotify:track:6wGbDxvg8wLWnk1HxcFTTO"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/197YY02cK93Yjrtpa1FrMY"},"href":"https://api.spotify.com/v1/albums/197YY02cK93Yjrtpa1FrMY","id":"197YY02cK93Yjrtpa1FrMY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b11ac9a6b727e6e367a4dcd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b11ac9a6b727e6e367a4dcd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b11ac9a6b727e6e367a4dcd"}],"is_playable":true,"name":"Best Of 2017","release_date":"2017-12-08","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:197YY02cK93Yjrtpa1FrMY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326933,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/1QQIwEMJ5ftWNWapBfNbt7"},"href":"https://api.spotify.com/v1/tracks/1QQIwEMJ5ftWNWapBfNbt7","id":"1QQIwEMJ5ftWNWapBfNbt7","is_local":false,"is_playable":true,"name":"Redbone","track_number":15,"type":"track","uri":"spotify:track:1QQIwEMJ5ftWNWapBfNbt7"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJlZGJvbmUlMjIlMjBhcnRpc3QlM0ElMjJDaGlsZGlzaCUyMEdhbWJpbm8lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjgsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80SkN5YnNOWlVYV3JLMkpweW4xMk5pIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNEpDeWJzTlpVWFdySzJKcHluMTJOaSIsImlkIjoiNEpDeWJzTlpVWFdySzJKcHluMTJOaSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5z", + "Y2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYzI5NTYyZDZlOGMxZjU1YmIxMzExZDUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWMyOTU2MmQ2ZThjMWY1NWJiMTMxMWQ1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYzI5NTYyZDZlOGMxZjU1YmIxMzExZDUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiXCJBd2FrZW4sIE15IExvdmUhXCIiLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTEyLTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEpDeWJzTlpVWFdySzJKcHluMTJOaSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI2OTMzLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1lBSDE2MDAxMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzN2UTRUNzhUVE1PalFYR2ZYVktRSm8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zdlE0VDc4VFRNT2pRWEdmWFZLUUpvIiwiaWQiOiIzdlE0VDc4VFRNT2pRWEdmWFZLUUpvIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlZGJvbmUiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M3ZRNFQ3OFRUTU9qUVhHZlhWS1FKbyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcg==", + "dGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzR6dWRobXk1SFNIVloxeTNnUGZiQUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80enVkaG15NUhTSFZaMXkzZ1BmYkFCIiwiaWQiOiI0enVkaG15NUhTSFZaMXkzZ1BmYkFCIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzcyYzY2NmU4ZmVlYmJiNjUyNTNlNGZiYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3MmM2NjZlOGZlZWJiYjY1MjUzZTRmYmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTcyYzY2NmU4ZmVlYmJiNjUyNTNlNGZiYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYXRjaCBGZWVscyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDgtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0enVkaG15NUhTSFZaMXkzZ1BmYkFCIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjUyNzIsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMURGS0JEc3ljNWVaS3A3cmh6TWVOTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFERktCRHN5YzVlWktwN3Joek1lTkwiLCJpZCI6IjFERktCRHN5YzVlWktwN3Joek1lTkwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIg==", + "LCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFERktCRHN5YzVlWktwN3Joek1lTkwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzAzOVd6eXR4YXJpWlRvNHRzTFVRRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzcwMzlXenl0eGFyaVpUbzR0c0xVUUYiLCJpZCI6IjcwMzlXenl0eGFyaVpUbzR0c0xVUUYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTJiYzViNDllMjEwMDA5MWQyMjVmOTVkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUyYmM1YjQ5ZTIxMDAwOTFkMjI1Zjk1ZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTJiYzViNDllMjEwMDA5MWQyMjVmOTVkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vdmEgVHVuZXMgMy41IiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wMy0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjcwMzlXenl0eGFyaVpUbzR0c0xVUUYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNDIyNiwiZXhwbGljaXQiOnRydWUsImV4dA==", + "ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1lBSDE2MDAxMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNhWG82bkpqZXhTZGI2d0NwTjdZc3kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zYVhvNm5KamV4U2RiNndDcE43WXN5IiwiaWQiOiIzYVhvNm5KamV4U2RiNndDcE43WXN5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlZGJvbmUiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2FYbzZuSmpleFNkYjZ3Q3BON1lzeSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zN3ZRQWZFYWFjeGVWNE1HTjMxZTlEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMzd2UUFmRWFhY3hlVjRNR04zMWU5RCIsImlkIjoiMzd2UUFmRWFhY3hlVjRNR04zMWU5RCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiMjMwZmM0NjcxYjgzZDg5OTUxZGQyM2YifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjIzMGZjNDY3MWI4M2Q4OTk1MWRkMjNmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiMjMwZmM0NjcxYjgzZDg5OTUxZGQyM2YifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUiZCYWUiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA3LTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Mzd2UUFmRWFhY3hlVjRNR04zMWU5RCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZQ==", + "bi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjU5NjAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDFPUE02NU1Hd3RDVDBENGlBSjZxUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQxT1BNNjVNR3d0Q1QwRDRpQUo2cVAiLCJpZCI6IjQxT1BNNjVNR3d0Q1QwRDRpQUo2cVAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0MU9QTTY1TUd3dENUMEQ0aUFKNnFQIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVUc3pzV3BtczFsbkI3YzZFSjRVeDIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81VHN6c1dwbXMxbG5CN2M2RUo0VXgyIiwiaWQiOiI1VHN6c1dwbXMxbG5CN2M2RUo0VXgyIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZjMDVkNDE1ZDFhMzcxZWFkZDJjNDAyMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2YzA1ZDQxNWQxYTM3MWVhZGQyYzQwMjMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaA==", + "dHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmMwNWQ0MTVkMWEzNzFlYWRkMmM0MDIzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhpcCBIb3AgTG92ZSBTb25ncyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMTEtMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1VHN6c1dwbXMxbG5CN2M2RUo0VXgyIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjY5MzMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnUyOU9yODluWjc4NE1oZ3AxY3V6NCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ1MjlPcjg5blo3ODRNaGdwMWN1ejQiLCJpZCI6IjZ1MjlPcjg5blo3ODRNaGdwMWN1ejQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2dTI5T3I4OW5aNzg0TWhncDFjdXo0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxLw==", + "YWxidW1zLzc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QiLCJpZCI6Ijc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZTQ5MzhhYjlkOGI1ZDA4NWEzYzBkZmFiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmU0OTM4YWI5ZDhiNWQwODVhM2MwZGZhYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZTQ5MzhhYjlkOGI1ZDA4NWEzYzBkZmFiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjIxc3QgQ2VudHVyeSBGdW5rIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wOC0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNjIyOSwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNZQUgxNjAwMTA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zQm83OXVpcHZ6SUJpT0FHNHpKUGNtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0JvNzl1aXB2eklCaU9BRzR6SlBjbSIsImlkIjoiM0JvNzl1aXB2eklCaU9BRzR6SlBjbSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWRib25lIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNCbzc5dWlwdnpJQmlPQUc0ekpQY20ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocg==", + "ZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xMkpyenpQSzE3RTdWNGtBck9KSjMyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTJKcnp6UEsxN0U3VjRrQXJPSkozMiIsImlkIjoiMTJKcnp6UEsxN0U3VjRrQXJPSkozMiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhMmNjNjY4ODIyODNjZmIyY2I1NzZhMTkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTJjYzY2ODgyMjgzY2ZiMmNiNTc2YTE5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhMmNjNjY4ODIyODNjZmIyY2I1NzZhMTkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmVzdCBPZiAyMDE3IFBvcCIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMTItMTUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0OCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxMkpyenpQSzE3RTdWNGtBck9KSjMyIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjY4ODAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNndHYkR4dmc4d0xXbmsxSHhjRlRUTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ3R2JEeHZnOHdMV25rMUh4Y0ZUVA==", + "TyIsImlkIjoiNndHYkR4dmc4d0xXbmsxSHhjRlRUTyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWRib25lIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZ3R2JEeHZnOHdMV25rMUh4Y0ZUVE8ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMTk3WVkwMmNLOTNZanJ0cGExRnJNWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzE5N1lZMDJjSzkzWWpydHBhMUZyTVkiLCJpZCI6IjE5N1lZMDJjSzkzWWpydHBhMUZyTVkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNWIxMWFjOWE2YjcyN2U2ZTM2N2E0ZGNkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjViMTFhYzlhNmI3MjdlNmUzNjdhNGRjZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNWIxMWFjOWE2YjcyN2U2ZTM2N2E0ZGNkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlc3QgT2YgMjAxNyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMTItMDgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1MCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxOTdZWTAyY0s5M1lqcnRwYTFGck1ZIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIg==", + "OiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNjkzMywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNZQUgxNjAwMTA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xUVFJd0VNSjVmdFdOV2FwQmZOYnQ3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVFRSXdFTUo1ZnRXTldhcEJmTmJ0NyIsImlkIjoiMVFRSXdFTUo1ZnRXTldhcEJmTmJ0NyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWRib25lIiwidHJhY2tfbnVtYmVyIjoxNSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxUVFJd0VNSjVmdFdOV2FwQmZOYnQ3In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Redbone%22+artist%3A%22Childish+Gambino%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Vossi%20Bop%22%20artist%3A%22Stormzy%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"external_urls":{"spotify":"https://open.spotify.com/album/3y4AaloFccKNLQcZNS9L8c"},"href":"https://api.spotify.com/v1/albums/3y4AaloFccKNLQcZNS9L8c","id":"3y4AaloFccKNLQcZNS9L8c","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27303bf634fe9526dfcc79f8526"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0203bf634fe9526dfcc79f8526"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485103bf634fe9526dfcc79f8526"}],"is_playable":true,"name":"Heavy Is The Head","release_date":"2019-12-13","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:3y4AaloFccKNLQcZNS9L8c"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"disc_number":1,"duration_ms":196266,"explicit":true,"external_ids":{"isrc":"GBAHS1900571"},"external_urls":{"spotify":"https://open.spotify.com/track/5DXKtoZLm31msT7tNGNHLG"},"href":"https://api.spotify.com/v1/tracks/5DXKtoZLm31msT7tNGNHLG","id":"5DXKtoZLm31msT7tNGNHLG","is_local":false,"is_playable":true,"name":"Vossi Bop","track_number":16,"type":"track","uri":"spotify:track:5DXKtoZLm31msT7tNGNHLG"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"external_urls":{"spotify":"https://open.spotify.com/album/1feZ7dUgDquoQRddxlI5BH"},"href":"https://api.spotify.com/v1/albums/1feZ7dUgDquoQRddxlI5BH","id":"1feZ7dUgDquoQRddxlI5BH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b2e3470b5c8f8ce8e37276d8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b2e3470b5c8f8ce8e37276d8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b2e3470b5c8f8ce8e37276d8"}],"is_playable":true,"name":"Vossi Bop","release_date":"2019-04-26","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1feZ7dUgDquoQRddxlI5BH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"disc_number":1,"duration_ms":196266,"explicit":true,"external_ids":{"isrc":"GBAHS1900571"},"external_urls":{"spotify":"https://open.spotify.com/track/44ZJ4hLD5onikKsVLQaILr"},"href":"https://api.spotify.com/v1/tracks/44ZJ4hLD5onikKsVLQaILr","id":"44ZJ4hLD5onikKsVLQaILr","is_local":false,"is_playable":true,"name":"Vossi Bop","track_number":1,"type":"track","uri":"spotify:track:44ZJ4hLD5onikKsVLQaILr"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"external_urls":{"spotify":"https://open.spotify.com/album/7vdTsOxv2g1VFlGXDjzAHi"},"href":"https://api.spotify.com/v1/albums/7vdTsOxv2g1VFlGXDjzAHi","id":"7vdTsOxv2g1VFlGXDjzAHi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eec2ab0bdadfaa4410655fce"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eec2ab0bdadfaa4410655fce"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eec2ab0bdadfaa4410655fce"}],"is_playable":true,"name":"Vossi Bop","release_date":"2019-04-26","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7vdTsOxv2g1VFlGXDjzAHi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"disc_number":1,"duration_ms":196226,"explicit":false,"external_ids":{"isrc":"GBAHS1900645"},"external_urls":{"spotify":"https://open.spotify.com/track/3hoHXkrYoASBwF9Ljm8Mdy"},"href":"https://api.spotify.com/v1/tracks/3hoHXkrYoASBwF9Ljm8Mdy","id":"3hoHXkrYoASBwF9Ljm8Mdy","is_local":false,"is_playable":true,"name":"Vossi Bop","track_number":1,"type":"track","uri":"spotify:track:3hoHXkrYoASBwF9Ljm8Mdy"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1eX2QZGKv4RFxpDKUGxgm0"},"href":"https://api.spotify.com/v1/artists/1eX2QZGKv4RFxpDKUGxgm0","id":"1eX2QZGKv4RFxpDKUGxgm0","name":"Aden x Asme","type":"artist","uri":"spotify:artist:1eX2QZGKv4RFxpDKUGxgm0"}],"external_urls":{"spotify":"https://open.spotify.com/album/6uOlhYbHTFoxqEdIqmgUjr"},"href":"https://api.spotify.com/v1/albums/6uOlhYbHTFoxqEdIqmgUjr","id":"6uOlhYbHTFoxqEdIqmgUjr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273af18e5d2e2a1c0b854fa90e3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02af18e5d2e2a1c0b854fa90e3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851af18e5d2e2a1c0b854fa90e3"}],"is_playable":true,"name":"Vossi Bop (Remix) [feat. Aden x Asme]","release_date":"2019-07-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6uOlhYbHTFoxqEdIqmgUjr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1eX2QZGKv4RFxpDKUGxgm0"},"href":"https://api.spotify.com/v1/artists/1eX2QZGKv4RFxpDKUGxgm0","id":"1eX2QZGKv4RFxpDKUGxgm0","name":"Aden x Asme","type":"artist","uri":"spotify:artist:1eX2QZGKv4RFxpDKUGxgm0"}],"disc_number":1,"duration_ms":155280,"explicit":true,"external_ids":{"isrc":"GBAHS1900922"},"external_urls":{"spotify":"https://open.spotify.com/track/0BtmAvlv8mc6lR9ZzxrOFD"},"href":"https://api.spotify.com/v1/tracks/0BtmAvlv8mc6lR9ZzxrOFD","id":"0BtmAvlv8mc6lR9ZzxrOFD","is_local":false,"is_playable":true,"name":"Vossi Bop (Remix) [feat. Aden x Asme]","track_number":1,"type":"track","uri":"spotify:track:0BtmAvlv8mc6lR9ZzxrOFD"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"external_urls":{"spotify":"https://open.spotify.com/album/5kWoenzRB7UycYXiRpH1d5"},"href":"https://api.spotify.com/v1/albums/5kWoenzRB7UycYXiRpH1d5","id":"5kWoenzRB7UycYXiRpH1d5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27340ae15aa945c46c1d1319cc2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0240ae15aa945c46c1d1319cc2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485140ae15aa945c46c1d1319cc2"}],"is_playable":true,"name":"Crown","release_date":"2019-06-21","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:5kWoenzRB7UycYXiRpH1d5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"disc_number":1,"duration_ms":196266,"explicit":true,"external_ids":{"isrc":"GBAHS1900571"},"external_urls":{"spotify":"https://open.spotify.com/track/37dBIimJUarbZWM5v8YY6u"},"href":"https://api.spotify.com/v1/tracks/37dBIimJUarbZWM5v8YY6u","id":"37dBIimJUarbZWM5v8YY6u","is_local":false,"is_playable":true,"name":"Vossi Bop","track_number":2,"type":"track","uri":"spotify:track:37dBIimJUarbZWM5v8YY6u"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3egWSWp7Y4FyCKIyvXbw7L"},"href":"https://api.spotify.com/v1/artists/3egWSWp7Y4FyCKIyvXbw7L","id":"3egWSWp7Y4FyCKIyvXbw7L","name":"Ghali","type":"artist","uri":"spotify:artist:3egWSWp7Y4FyCKIyvXbw7L"}],"external_urls":{"spotify":"https://open.spotify.com/album/0TW9NL0WFEZR4qdL74W0tP"},"href":"https://api.spotify.com/v1/albums/0TW9NL0WFEZR4qdL74W0tP","id":"0TW9NL0WFEZR4qdL74W0tP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273280c25b7b1a781b715663156"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02280c25b7b1a781b715663156"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851280c25b7b1a781b715663156"}],"is_playable":true,"name":"Vossi Bop (Remix) [feat. Ghali]","release_date":"2019-07-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0TW9NL0WFEZR4qdL74W0tP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3egWSWp7Y4FyCKIyvXbw7L"},"href":"https://api.spotify.com/v1/artists/3egWSWp7Y4FyCKIyvXbw7L","id":"3egWSWp7Y4FyCKIyvXbw7L","name":"Ghali","type":"artist","uri":"spotify:artist:3egWSWp7Y4FyCKIyvXbw7L"}],"disc_number":1,"duration_ms":195638,"explicit":true,"external_ids":{"isrc":"GBAHS1900923"},"external_urls":{"spotify":"https://open.spotify.com/track/5gIYpLJqSLyEUSB1tgm7zt"},"href":"https://api.spotify.com/v1/tracks/5gIYpLJqSLyEUSB1tgm7zt","id":"5gIYpLJqSLyEUSB1tgm7zt","is_local":false,"is_playable":true,"name":"Vossi Bop (Remix) [feat. Ghali]","track_number":1,"type":"track","uri":"spotify:track:5gIYpLJqSLyEUSB1tgm7zt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"external_urls":{"spotify":"https://open.spotify.com/album/1NJ3DLBea3RK1ACHdGum1e"},"href":"https://api.spotify.com/v1/albums/1NJ3DLBea3RK1ACHdGum1e","id":"1NJ3DLBea3RK1ACHdGum1e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739ec492e130408e788a8b72d3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029ec492e130408e788a8b72d3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519ec492e130408e788a8b72d3"}],"is_playable":true,"name":"Heavy Is The Head","release_date":"2019-12-13","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:1NJ3DLBea3RK1ACHdGum1e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"disc_number":1,"duration_ms":196226,"explicit":false,"external_ids":{"isrc":"GBAHS1900645"},"external_urls":{"spotify":"https://open.spotify.com/track/6D1J4clKvlafUtldsBPzsS"},"href":"https://api.spotify.com/v1/tracks/6D1J4clKvlafUtldsBPzsS","id":"6D1J4clKvlafUtldsBPzsS","is_local":false,"is_playable":true,"name":"Vossi Bop","track_number":16,"type":"track","uri":"spotify:track:6D1J4clKvlafUtldsBPzsS"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5zK6Y7XOLDFFg0sdThkVxr"},"href":"https://api.spotify.com/v1/artists/5zK6Y7XOLDFFg0sdThkVxr","id":"5zK6Y7XOLDFFg0sdThkVxr","name":"LAUREN","type":"artist","uri":"spotify:artist:5zK6Y7XOLDFFg0sdThkVxr"}],"external_urls":{"spotify":"https://open.spotify.com/album/2pwHeGs3AbQSwMEga6gF2d"},"href":"https://api.spotify.com/v1/albums/2pwHeGs3AbQSwMEga6gF2d","id":"2pwHeGs3AbQSwMEga6gF2d","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273312ce271169d23675129d29a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02312ce271169d23675129d29a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851312ce271169d23675129d29a"}],"is_playable":true,"name":"Vossi Bop (Remix) [feat. LAUREN]","release_date":"2019-07-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2pwHeGs3AbQSwMEga6gF2d"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5zK6Y7XOLDFFg0sdThkVxr"},"href":"https://api.spotify.com/v1/artists/5zK6Y7XOLDFFg0sdThkVxr","id":"5zK6Y7XOLDFFg0sdThkVxr","name":"LAUREN","type":"artist","uri":"spotify:artist:5zK6Y7XOLDFFg0sdThkVxr"}],"disc_number":1,"duration_ms":195253,"explicit":true,"external_ids":{"isrc":"GBAHS1900921"},"external_urls":{"spotify":"https://open.spotify.com/track/3dl98e4LgX6bEHn5BNAOC0"},"href":"https://api.spotify.com/v1/tracks/3dl98e4LgX6bEHn5BNAOC0","id":"3dl98e4LgX6bEHn5BNAOC0","is_local":false,"is_playable":true,"name":"Vossi Bop (Remix) [feat. LAUREN]","track_number":1,"type":"track","uri":"spotify:track:3dl98e4LgX6bEHn5BNAOC0"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZvc3NpJTIwQm9wJTIyJTIwYXJ0aXN0JTNBJTIyU3Rvcm16eSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzN5NEFhbG9GY2NLTkxRY1pOUzlMOGMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zeTRBYWxvRmNjS05MUWNaTlM5TDhjIiwiaWQiOiIzeTRBYWxvRmNjS05MUWNaTlM5TDhjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzAzYmY2MzRmZTk1MjZkZmNjNzlmODUyNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwM2JmNjM0ZmU5NTI2ZGZjYzc5Zjg1MjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAzYmY2MzRmZTk1MjZkZmNjNzlmODUyNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZWF2eSBJcyBUaGUgSGVhZCIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMTItMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozeTRBYWxvRmNjS05MUWNaTlM5TDhjIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDUw==", + "TmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NjI2NiwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFMxOTAwNTcxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81RFhLdG9aTG0zMW1zVDd0TkdOSExHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNURYS3RvWkxtMzFtc1Q3dE5HTkhMRyIsImlkIjoiNURYS3RvWkxtMzFtc1Q3dE5HTkhMRyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWb3NzaSBCb3AiLCJ0cmFja19udW1iZXIiOjE2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVEWEt0b1pMbTMxbXNUN3ROR05ITEcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTclNkU3ZwbWlucW1TdEdFTENTTmQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsImlkIjoiMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsIm5hbWUiOiJTdG9ybXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTclNkU3ZwbWlucW1TdEdFTENTTmQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xZmVaN2RVZ0RxdW9RUmRkeGxJNUJIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWZlWjdkVWdEcXVvUVJkZHhsSTVCSCIsImlkIjoiMWZlWjdkVWdEcXVvUVJkZHhsSTVCSCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiMmUzNDcwYjVjOGY4Y2U4ZTM3Mjc2ZDgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjJlMzQ3MGI1YzhmOGNlOGUzNzI3NmQ4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiMmUzNDcwYjVjOGY4Y2U4ZTM3Mjc2ZDgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVm9zc2kgQm9wIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wNC0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOg==", + "ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxZmVaN2RVZ0RxdW9RUmRkeGxJNUJIIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTYyNjYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMTkwMDU3MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDRaSjRoTEQ1b25pa0tzVkxRYUlMciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQ0Wko0aExENW9uaWtLc1ZMUWFJTHIiLCJpZCI6IjQ0Wko0aExENW9uaWtLc1ZMUWFJTHIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVm9zc2kgQm9wIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjQ0Wko0aExENW9uaWtLc1ZMUWFJTHIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTclNkU3ZwbWlucW1TdEdFTENTTmQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsImlkIjoiMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsIm5hbWUiOiJTdG9ybXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTclNkU3ZwbWlucW1TdEdFTENTTmQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83dmRUc094djJnMVZGbEdYRGp6QUhpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3ZkVHNPeHYyZzFWRmxHWERqekFIaSIsImlkIjoiN3ZkVHNPeHYyZzFWRmxHWERqekFIaSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlZWMyYWIwYmRhZGZhYTQ0MTA2NTVmY2UifSx7ImhlaWdodCI6MzAwLCJ3aQ==", + "ZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlZWMyYWIwYmRhZGZhYTQ0MTA2NTVmY2UifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVlYzJhYjBiZGFkZmFhNDQxMDY1NWZjZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWb3NzaSBCb3AiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA0LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3dmRUc094djJnMVZGbEdYRGp6QUhpIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTYyMjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIUzE5MDA2NDUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNob0hYa3JZb0FTQndGOUxqbThNZHkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zaG9IWGtyWW9BU0J3RjlMam04TWR5IiwiaWQiOiIzaG9IWGtyWW9BU0J3RjlMam04TWR5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZvc3NpIEJvcCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozaG9IWGtyWW9BU0J3RjlMam04TWR5In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZCI6IjJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwcw==", + "Oi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMWVYMlFaR0t2NFJGeHBES1VHeGdtMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xZVgyUVpHS3Y0UkZ4cERLVUd4Z20wIiwiaWQiOiIxZVgyUVpHS3Y0UkZ4cERLVUd4Z20wIiwibmFtZSI6IkFkZW4geCBBc21lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFlWDJRWkdLdjRSRnhwREtVR3hnbTAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82dU9saFliSFRGb3hxRWRJcW1nVWpyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnVPbGhZYkhURm94cUVkSXFtZ1VqciIsImlkIjoiNnVPbGhZYkhURm94cUVkSXFtZ1VqciIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhZjE4ZTVkMmUyYTFjMGI4NTRmYTkwZTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWYxOGU1ZDJlMmExYzBiODU0ZmE5MGUzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhZjE4ZTVkMmUyYTFjMGI4NTRmYTkwZTMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVm9zc2kgQm9wIChSZW1peCkgW2ZlYXQuIEFkZW4geCBBc21lXSIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDctMTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZ1T2xoWWJIVEZveHFFZElxbWdVanIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZCI6IjJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFlWDJRWkdLdjRSRnhwREtVR3hnbTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMWVYMlFaR0t2NFJGeHBES1VHeGdtMCIsImlkIjoiMWVYMlFaR0t2NFJGeHBES1VHeA==", + "Z20wIiwibmFtZSI6IkFkZW4geCBBc21lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFlWDJRWkdLdjRSRnhwREtVR3hnbTAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTU1MjgwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIUzE5MDA5MjIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBCdG1Bdmx2OG1jNmxSOVp6eHJPRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wQnRtQXZsdjhtYzZsUjlaenhyT0ZEIiwiaWQiOiIwQnRtQXZsdjhtYzZsUjlaenhyT0ZEIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZvc3NpIEJvcCAoUmVtaXgpIFtmZWF0LiBBZGVuIHggQXNtZV0iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MEJ0bUF2bHY4bWM2bFI5Wnp4ck9GRCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVrV29lbnpSQjdVeWNZWGlScEgxZDUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81a1dvZW56UkI3VXljWVhpUnBIMWQ1IiwiaWQiOiI1a1dvZW56UkI3VXljWVhpUnBIMWQ1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQwYWUxNWFhOTQ1YzQ2YzFkMTMxOWNjMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0MGFlMTVhYTk0NWM0NmMxZDEzMTljYzIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQwYWUxNWFhOTQ1YzQ2YzFkMTMxOWNjMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDcm93biIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDYtMg==", + "MSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWtXb2VuelJCN1V5Y1lYaVJwSDFkNSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTclNkU3ZwbWlucW1TdEdFTENTTmQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsImlkIjoiMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsIm5hbWUiOiJTdG9ybXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTclNkU3ZwbWlucW1TdEdFTENTTmQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk2MjY2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIUzE5MDA1NzEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzM3ZEJJaW1KVWFyYlpXTTV2OFlZNnUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zN2RCSWltSlVhcmJaV001djhZWTZ1IiwiaWQiOiIzN2RCSWltSlVhcmJaV001djhZWTZ1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZvc3NpIEJvcCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozN2RCSWltSlVhcmJaV001djhZWTZ1In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZCI6IjJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNlZ1dTV3A3WTRGeUNLSXl2WGJ3N0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2VnV1NXcDdZNEZ5Q0tJeXZYYnc3TCIsImlkIjoiM2VnV1NXcDdZNEZ5Q0tJeXZYYnc3TCIsIm5hbWUiOiJHaGFsaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZWdXU1dwN1k0RnlDS0l5dlhidzdMIn1dLCJleHRlcm5hbF91cmxzIjp7Ig==", + "c3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wVFc5TkwwV0ZFWlI0cWRMNzRXMHRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMFRXOU5MMFdGRVpSNHFkTDc0VzB0UCIsImlkIjoiMFRXOU5MMFdGRVpSNHFkTDc0VzB0UCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyODBjMjViN2IxYTc4MWI3MTU2NjMxNTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMjgwYzI1YjdiMWE3ODFiNzE1NjYzMTU2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyODBjMjViN2IxYTc4MWI3MTU2NjMxNTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVm9zc2kgQm9wIChSZW1peCkgW2ZlYXQuIEdoYWxpXSIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDctMTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBUVzlOTDBXRkVaUjRxZEw3NFcwdFAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZCI6IjJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNlZ1dTV3A3WTRGeUNLSXl2WGJ3N0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2VnV1NXcDdZNEZ5Q0tJeXZYYnc3TCIsImlkIjoiM2VnV1NXcDdZNEZ5Q0tJeXZYYnc3TCIsIm5hbWUiOiJHaGFsaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZWdXU1dwN1k0RnlDS0l5dlhidzdMIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NTYzOCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFMxOTAwOTIzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81Z0lZcExKcVNMeUVVU0IxdGdtN3p0Ig==", + "fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81Z0lZcExKcVNMeUVVU0IxdGdtN3p0IiwiaWQiOiI1Z0lZcExKcVNMeUVVU0IxdGdtN3p0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZvc3NpIEJvcCAoUmVtaXgpIFtmZWF0LiBHaGFsaV0iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NWdJWXBMSnFTTHlFVVNCMXRnbTd6dCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZCI6IjJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMU5KM0RMQmVhM1JLMUFDSGRHdW0xZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFOSjNETEJlYTNSSzFBQ0hkR3VtMWUiLCJpZCI6IjFOSjNETEJlYTNSSzFBQ0hkR3VtMWUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWVjNDkyZTEzMDQwOGU3ODhhOGI3MmQzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjllYzQ5MmUxMzA0MDhlNzg4YThiNzJkMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWVjNDkyZTEzMDQwOGU3ODhhOGI3MmQzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhlYXZ5IElzIFRoZSBIZWFkIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0xMi0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFOSjNETEJlYTNSSzFBQ0hkR3VtMWUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkUw==", + "dnBtaW5xbVN0R0VMQ1NOZCIsImlkIjoiMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsIm5hbWUiOiJTdG9ybXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTclNkU3ZwbWlucW1TdEdFTENTTmQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk2MjI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFMxOTAwNjQ1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82RDFKNGNsS3ZsYWZVdGxkc0JQenNTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNkQxSjRjbEt2bGFmVXRsZHNCUHpzUyIsImlkIjoiNkQxSjRjbEt2bGFmVXRsZHNCUHpzUyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWb3NzaSBCb3AiLCJ0cmFja19udW1iZXIiOjE2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZEMUo0Y2xLdmxhZlV0bGRzQlB6c1MifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTclNkU3ZwbWlucW1TdEdFTENTTmQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsImlkIjoiMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsIm5hbWUiOiJTdG9ybXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTclNkU3ZwbWlucW1TdEdFTENTTmQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXpLNlk3WE9MREZGZzBzZFRoa1Z4ciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81eks2WTdYT0xERkZnMHNkVGhrVnhyIiwiaWQiOiI1eks2WTdYT0xERkZnMHNkVGhrVnhyIiwibmFtZSI6IkxBVVJFTiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1eks2WTdYT0xERkZnMHNkVGhrVnhyIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMnB3SGVHczNBYlFTd01FZ2E2Z0YyZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJwd0hlR3MzQWJRU3dNRWdhNmdGMmQiLCJpZCI6IjJwd0hlR3MzQWJRU3dNRWdhNmdGMmQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzEyY2UyNzExNg==", + "OWQyMzY3NTEyOWQyOWEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzEyY2UyNzExNjlkMjM2NzUxMjlkMjlhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzMTJjZTI3MTE2OWQyMzY3NTEyOWQyOWEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVm9zc2kgQm9wIChSZW1peCkgW2ZlYXQuIExBVVJFTl0iLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA3LTE5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToycHdIZUdzM0FiUVN3TUVnYTZnRjJkIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81eks2WTdYT0xERkZnMHNkVGhrVnhyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV6SzZZN1hPTERGRmcwc2RUaGtWeHIiLCJpZCI6IjV6SzZZN1hPTERGRmcwc2RUaGtWeHIiLCJuYW1lIjoiTEFVUkVOIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV6SzZZN1hPTERGRmcwc2RUaGtWeHIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk1MjUzLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIUzE5MDA5MjEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNkbDk4ZTRMZ1g2YkVIbjVCTkFPQzAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zZGw5OGU0TGdYNmJFSG41Qk5BT0MwIiwiaWQiOiIzZGw5OGU0TGdYNmJFSG41Qk5BT0MwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZvc3NpIEJvcCAoUmVtaXgpIFtmZWF0LiBMQVVSRU5dIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNkbDk4ZTRMZ1g2YkVIbjVCTkFPQzAifQ==", + "XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Vossi+Bop%22+artist%3A%22Stormzy%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Own%20It%22%20artist%3A%22Stormzy%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"external_urls":{"spotify":"https://open.spotify.com/album/3y4AaloFccKNLQcZNS9L8c"},"href":"https://api.spotify.com/v1/albums/3y4AaloFccKNLQcZNS9L8c","id":"3y4AaloFccKNLQcZNS9L8c","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27303bf634fe9526dfcc79f8526"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0203bf634fe9526dfcc79f8526"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485103bf634fe9526dfcc79f8526"}],"is_playable":true,"name":"Heavy Is The Head","release_date":"2019-12-13","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:3y4AaloFccKNLQcZNS9L8c"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6eUKZXaKkcviH0Ku9w2n3V"},"href":"https://api.spotify.com/v1/artists/6eUKZXaKkcviH0Ku9w2n3V","id":"6eUKZXaKkcviH0Ku9w2n3V","name":"Ed Sheeran","type":"artist","uri":"spotify:artist:6eUKZXaKkcviH0Ku9w2n3V"}],"disc_number":1,"duration_ms":216706,"explicit":false,"external_ids":{"isrc":"GBAHS1901369"},"external_urls":{"spotify":"https://open.spotify.com/track/4QPEwDdOMhY7rNS05mTyMR"},"href":"https://api.spotify.com/v1/tracks/4QPEwDdOMhY7rNS05mTyMR","id":"4QPEwDdOMhY7rNS05mTyMR","is_local":false,"is_playable":true,"name":"Own It (feat. Ed Sheeran & Burna Boy)","track_number":11,"type":"track","uri":"spotify:track:4QPEwDdOMhY7rNS05mTyMR"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7qPISKHhhKDLZTmYcX7bWd"},"href":"https://api.spotify.com/v1/artists/7qPISKHhhKDLZTmYcX7bWd","id":"7qPISKHhhKDLZTmYcX7bWd","name":"Stylo G","type":"artist","uri":"spotify:artist:7qPISKHhhKDLZTmYcX7bWd"}],"external_urls":{"spotify":"https://open.spotify.com/album/6gsCwsADsWYJT1v3bjzrYS"},"href":"https://api.spotify.com/v1/albums/6gsCwsADsWYJT1v3bjzrYS","id":"6gsCwsADsWYJT1v3bjzrYS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27352871a572dd8123eac9c7f85"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0252871a572dd8123eac9c7f85"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485152871a572dd8123eac9c7f85"}],"is_playable":true,"name":"Own It (feat. Burna Boy & Stylo G) [Toddla T Remix]","release_date":"2020-01-31","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6gsCwsADsWYJT1v3bjzrYS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7qPISKHhhKDLZTmYcX7bWd"},"href":"https://api.spotify.com/v1/artists/7qPISKHhhKDLZTmYcX7bWd","id":"7qPISKHhhKDLZTmYcX7bWd","name":"Stylo G","type":"artist","uri":"spotify:artist:7qPISKHhhKDLZTmYcX7bWd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3l1C23aRp4lfkBK3lLAp2m"},"href":"https://api.spotify.com/v1/artists/3l1C23aRp4lfkBK3lLAp2m","id":"3l1C23aRp4lfkBK3lLAp2m","name":"Toddla T","type":"artist","uri":"spotify:artist:3l1C23aRp4lfkBK3lLAp2m"}],"disc_number":1,"duration_ms":185000,"explicit":false,"external_ids":{"isrc":"GBAHS2000057"},"external_urls":{"spotify":"https://open.spotify.com/track/6DRQEQLRLEuf2e7tc7ARM8"},"href":"https://api.spotify.com/v1/tracks/6DRQEQLRLEuf2e7tc7ARM8","id":"6DRQEQLRLEuf2e7tc7ARM8","is_local":false,"is_playable":true,"name":"Own It (feat. Burna Boy & Stylo G) [Toddla T Remix]","track_number":1,"type":"track","uri":"spotify:track:6DRQEQLRLEuf2e7tc7ARM8"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DgP9otnZw5z6daOntINxp"},"href":"https://api.spotify.com/v1/artists/6DgP9otnZw5z6daOntINxp","id":"6DgP9otnZw5z6daOntINxp","name":"Joel Corry","type":"artist","uri":"spotify:artist:6DgP9otnZw5z6daOntINxp"}],"external_urls":{"spotify":"https://open.spotify.com/album/6DPW0kboAgmGklsyUzZVba"},"href":"https://api.spotify.com/v1/albums/6DPW0kboAgmGklsyUzZVba","id":"6DPW0kboAgmGklsyUzZVba","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273de14f5c1edcf172937d216bd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02de14f5c1edcf172937d216bd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851de14f5c1edcf172937d216bd"}],"is_playable":true,"name":"Own It (feat. Ed Sheeran & Burna Boy) [Joel Corry Remix]","release_date":"2019-12-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6DPW0kboAgmGklsyUzZVba"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6eUKZXaKkcviH0Ku9w2n3V"},"href":"https://api.spotify.com/v1/artists/6eUKZXaKkcviH0Ku9w2n3V","id":"6eUKZXaKkcviH0Ku9w2n3V","name":"Ed Sheeran","type":"artist","uri":"spotify:artist:6eUKZXaKkcviH0Ku9w2n3V"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DgP9otnZw5z6daOntINxp"},"href":"https://api.spotify.com/v1/artists/6DgP9otnZw5z6daOntINxp","id":"6DgP9otnZw5z6daOntINxp","name":"Joel Corry","type":"artist","uri":"spotify:artist:6DgP9otnZw5z6daOntINxp"}],"disc_number":1,"duration_ms":176265,"explicit":false,"external_ids":{"isrc":"GBAHS2000238"},"external_urls":{"spotify":"https://open.spotify.com/track/49i5Qn3zXsMBPsSOmYAFut"},"href":"https://api.spotify.com/v1/tracks/49i5Qn3zXsMBPsSOmYAFut","id":"49i5Qn3zXsMBPsSOmYAFut","is_local":false,"is_playable":true,"name":"Own It (feat. Ed Sheeran & Burna Boy) - Joel Corry Remix","track_number":1,"type":"track","uri":"spotify:track:49i5Qn3zXsMBPsSOmYAFut"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3hvinNZRzTLoREmqFiKr1b"},"href":"https://api.spotify.com/v1/artists/3hvinNZRzTLoREmqFiKr1b","id":"3hvinNZRzTLoREmqFiKr1b","name":"CHANGMO","type":"artist","uri":"spotify:artist:3hvinNZRzTLoREmqFiKr1b"}],"external_urls":{"spotify":"https://open.spotify.com/album/0x6h3VCb7RY7Z1RRSgXiy5"},"href":"https://api.spotify.com/v1/albums/0x6h3VCb7RY7Z1RRSgXiy5","id":"0x6h3VCb7RY7Z1RRSgXiy5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273202b58dafee6d393527e2900"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02202b58dafee6d393527e2900"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851202b58dafee6d393527e2900"}],"is_playable":true,"name":"Own It (feat. Burna Boy & CHANGMO)","release_date":"2019-12-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0x6h3VCb7RY7Z1RRSgXiy5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3hvinNZRzTLoREmqFiKr1b"},"href":"https://api.spotify.com/v1/artists/3hvinNZRzTLoREmqFiKr1b","id":"3hvinNZRzTLoREmqFiKr1b","name":"CHANGMO","type":"artist","uri":"spotify:artist:3hvinNZRzTLoREmqFiKr1b"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"}],"disc_number":1,"duration_ms":216506,"explicit":false,"external_ids":{"isrc":"GBAHS2000239"},"external_urls":{"spotify":"https://open.spotify.com/track/5ueWxKKCChyglQrJO5IzqA"},"href":"https://api.spotify.com/v1/tracks/5ueWxKKCChyglQrJO5IzqA","id":"5ueWxKKCChyglQrJO5IzqA","is_local":false,"is_playable":true,"name":"Own It (feat. Burna Boy & CHANGMO)","track_number":1,"type":"track","uri":"spotify:track:5ueWxKKCChyglQrJO5IzqA"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DgP9otnZw5z6daOntINxp"},"href":"https://api.spotify.com/v1/artists/6DgP9otnZw5z6daOntINxp","id":"6DgP9otnZw5z6daOntINxp","name":"Joel Corry","type":"artist","uri":"spotify:artist:6DgP9otnZw5z6daOntINxp"}],"external_urls":{"spotify":"https://open.spotify.com/album/7sES7GFSgz7oHR3QBHHhC5"},"href":"https://api.spotify.com/v1/albums/7sES7GFSgz7oHR3QBHHhC5","id":"7sES7GFSgz7oHR3QBHHhC5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27392975c06f1c9ddda6d5a5049"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0292975c06f1c9ddda6d5a5049"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485192975c06f1c9ddda6d5a5049"}],"is_playable":true,"name":"Own It (feat. Ed Sheeran & Burna Boy) [Joel Corry Remix] [Extended Mix]","release_date":"2019-12-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7sES7GFSgz7oHR3QBHHhC5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6eUKZXaKkcviH0Ku9w2n3V"},"href":"https://api.spotify.com/v1/artists/6eUKZXaKkcviH0Ku9w2n3V","id":"6eUKZXaKkcviH0Ku9w2n3V","name":"Ed Sheeran","type":"artist","uri":"spotify:artist:6eUKZXaKkcviH0Ku9w2n3V"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DgP9otnZw5z6daOntINxp"},"href":"https://api.spotify.com/v1/artists/6DgP9otnZw5z6daOntINxp","id":"6DgP9otnZw5z6daOntINxp","name":"Joel Corry","type":"artist","uri":"spotify:artist:6DgP9otnZw5z6daOntINxp"}],"disc_number":1,"duration_ms":249894,"explicit":false,"external_ids":{"isrc":"GBAHS2000334"},"external_urls":{"spotify":"https://open.spotify.com/track/0UfHuoT3RgQYOl2o6L6mVa"},"href":"https://api.spotify.com/v1/tracks/0UfHuoT3RgQYOl2o6L6mVa","id":"0UfHuoT3RgQYOl2o6L6mVa","is_local":false,"is_playable":true,"name":"Own It (feat. Ed Sheeran & Burna Boy) [Joel Corry Remix] - Extended Mix","track_number":1,"type":"track","uri":"spotify:track:0UfHuoT3RgQYOl2o6L6mVa"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"external_urls":{"spotify":"https://open.spotify.com/album/1NJ3DLBea3RK1ACHdGum1e"},"href":"https://api.spotify.com/v1/albums/1NJ3DLBea3RK1ACHdGum1e","id":"1NJ3DLBea3RK1ACHdGum1e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739ec492e130408e788a8b72d3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029ec492e130408e788a8b72d3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519ec492e130408e788a8b72d3"}],"is_playable":true,"name":"Heavy Is The Head","release_date":"2019-12-13","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:1NJ3DLBea3RK1ACHdGum1e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6eUKZXaKkcviH0Ku9w2n3V"},"href":"https://api.spotify.com/v1/artists/6eUKZXaKkcviH0Ku9w2n3V","id":"6eUKZXaKkcviH0Ku9w2n3V","name":"Ed Sheeran","type":"artist","uri":"spotify:artist:6eUKZXaKkcviH0Ku9w2n3V"}],"disc_number":1,"duration_ms":216706,"explicit":false,"external_ids":{"isrc":"GBAHS1901369"},"external_urls":{"spotify":"https://open.spotify.com/track/1ht4Jol7LhNC38gOTQkwa2"},"href":"https://api.spotify.com/v1/tracks/1ht4Jol7LhNC38gOTQkwa2","id":"1ht4Jol7LhNC38gOTQkwa2","is_local":false,"is_playable":true,"name":"Own It (feat. Ed Sheeran & Burna Boy)","track_number":11,"type":"track","uri":"spotify:track:1ht4Jol7LhNC38gOTQkwa2"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6NRxT4fRLUoS2J6zwL7wRj"},"href":"https://api.spotify.com/v1/albums/6NRxT4fRLUoS2J6zwL7wRj","id":"6NRxT4fRLUoS2J6zwL7wRj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e687e5da75c049fa83cfcd94"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e687e5da75c049fa83cfcd94"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e687e5da75c049fa83cfcd94"}],"is_playable":true,"name":"New Music 2020 Chart","release_date":"2020-05-29","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:6NRxT4fRLUoS2J6zwL7wRj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3wcj11K77LjEY1PkEazffa"},"href":"https://api.spotify.com/v1/artists/3wcj11K77LjEY1PkEazffa","id":"3wcj11K77LjEY1PkEazffa","name":"Burna Boy","type":"artist","uri":"spotify:artist:3wcj11K77LjEY1PkEazffa"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7qPISKHhhKDLZTmYcX7bWd"},"href":"https://api.spotify.com/v1/artists/7qPISKHhhKDLZTmYcX7bWd","id":"7qPISKHhhKDLZTmYcX7bWd","name":"Stylo G","type":"artist","uri":"spotify:artist:7qPISKHhhKDLZTmYcX7bWd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3l1C23aRp4lfkBK3lLAp2m"},"href":"https://api.spotify.com/v1/artists/3l1C23aRp4lfkBK3lLAp2m","id":"3l1C23aRp4lfkBK3lLAp2m","name":"Toddla T","type":"artist","uri":"spotify:artist:3l1C23aRp4lfkBK3lLAp2m"}],"disc_number":1,"duration_ms":185000,"explicit":false,"external_ids":{"isrc":"GBAHS2000057"},"external_urls":{"spotify":"https://open.spotify.com/track/5RrmVTsgrkBWoNQDcWNQj9"},"href":"https://api.spotify.com/v1/tracks/5RrmVTsgrkBWoNQDcWNQj9","id":"5RrmVTsgrkBWoNQDcWNQj9","is_local":false,"is_playable":true,"name":"Own It (feat. Burna Boy & Stylo G) [Toddla T Remix]","track_number":16,"type":"track","uri":"spotify:track:5RrmVTsgrkBWoNQDcWNQj9"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"external_urls":{"spotify":"https://open.spotify.com/album/2rXedNO1d5xJwdI7nRN96l"},"href":"https://api.spotify.com/v1/albums/2rXedNO1d5xJwdI7nRN96l","id":"2rXedNO1d5xJwdI7nRN96l","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273892217b16839e0fe8ee2d5e0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02892217b16839e0fe8ee2d5e0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851892217b16839e0fe8ee2d5e0"}],"is_playable":true,"name":"Don't Forget To Breathe / Do Better / Wiley Flow /Own It feat. Burna Boy /Anybody / Rainfall feat. Tiana Major9 (Live from the BRIT Awards London 2020)","release_date":"2020-02-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2rXedNO1d5xJwdI7nRN96l"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SrSdSvpminqmStGELCSNd"},"href":"https://api.spotify.com/v1/artists/2SrSdSvpminqmStGELCSNd","id":"2SrSdSvpminqmStGELCSNd","name":"Stormzy","type":"artist","uri":"spotify:artist:2SrSdSvpminqmStGELCSNd"}],"disc_number":1,"duration_ms":631918,"explicit":true,"external_ids":{"isrc":"GBAHS2000103"},"external_urls":{"spotify":"https://open.spotify.com/track/5cKdHbbJyEP2Dccluz2nbj"},"href":"https://api.spotify.com/v1/tracks/5cKdHbbJyEP2Dccluz2nbj","id":"5cKdHbbJyEP2Dccluz2nbj","is_local":false,"is_playable":true,"name":"Don't Forget To Breathe / Do Better / Wiley Flow /Own It feat. Burna Boy /Anybody / Rainfall feat. Tiana Major9 - Live from the BRIT Awards London 2020","track_number":1,"type":"track","uri":"spotify:track:5cKdHbbJyEP2Dccluz2nbj"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk93biUyMEl0JTIyJTIwYXJ0aXN0JTNBJTIyU3Rvcm16eSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzN5NEFhbG9GY2NLTkxRY1pOUzlMOGMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zeTRBYWxvRmNjS05MUWNaTlM5TDhjIiwiaWQiOiIzeTRBYWxvRmNjS05MUWNaTlM5TDhjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzAzYmY2MzRmZTk1MjZkZmNjNzlmODUyNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwM2JmNjM0ZmU5NTI2ZGZjYzc5Zjg1MjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAzYmY2MzRmZTk1MjZkZmNjNzlmODUyNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZWF2eSBJcyBUaGUgSGVhZCIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMTItMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozeTRBYWxvRmNjS05MUWNaTlM5TDhjIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIg==", + "LCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN3Y2oxMUs3N0xqRVkxUGtFYXpmZmEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3djajExSzc3TGpFWTFQa0VhemZmYSIsImlkIjoiM3djajExSzc3TGpFWTFQa0VhemZmYSIsIm5hbWUiOiJCdXJuYSBCb3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3djajExSzc3TGpFWTFQa0VhemZmYSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82ZVVLWlhhS2tjdmlIMEt1OXcybjNWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZlVUtaWGFLa2N2aUgwS3U5dzJuM1YiLCJpZCI6IjZlVUtaWGFLa2N2aUgwS3U5dzJuM1YiLCJuYW1lIjoiRWQgU2hlZXJhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2ZVVLWlhhS2tjdmlIMEt1OXcybjNWIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxNjcwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMTkwMTM2OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFFQRXdEZE9NaFk3ck5TMDVtVHlNUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRRUEV3RGRPTWhZN3JOUzA1bVR5TVIiLCJpZCI6IjRRUEV3RGRPTWhZN3JOUzA1bVR5TVIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT3duIEl0IChmZWF0LiBFZCBTaGVlcmFuICYgQnVybmEgQm95KSIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFFQRXdEZE9NaFk3ck5TMDVtVHlNUiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aQ==", + "ZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN3Y2oxMUs3N0xqRVkxUGtFYXpmZmEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3djajExSzc3TGpFWTFQa0VhemZmYSIsImlkIjoiM3djajExSzc3TGpFWTFQa0VhemZmYSIsIm5hbWUiOiJCdXJuYSBCb3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3djajExSzc3TGpFWTFQa0VhemZmYSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83cVBJU0tIaGhLRExaVG1ZY1g3YldkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdxUElTS0hoaEtETFpUbVljWDdiV2QiLCJpZCI6IjdxUElTS0hoaEtETFpUbVljWDdiV2QiLCJuYW1lIjoiU3R5bG8gRyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3cVBJU0tIaGhLRExaVG1ZY1g3YldkIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNmdzQ3dzQURzV1lKVDF2M2JqenJZUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZnc0N3c0FEc1dZSlQxdjNianpyWVMiLCJpZCI6IjZnc0N3c0FEc1dZSlQxdjNianpyWVMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTI4NzFhNTcyZGQ4MTIzZWFjOWM3Zjg1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUyODcxYTU3MmRkODEyM2VhYzljN2Y4NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTI4NzFhNTcyZGQ4MTIzZWFjOWM3Zjg1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik93biBJdCAoZmVhdC4gQnVybmEgQm95ICYgU3R5bG8gRykgW1RvZGRsYSBUIFJlbWl4XSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDEtMzEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZnc0N3c0FEc1dZSlQxdjNianpyWVMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZA==", + "IjoiMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsIm5hbWUiOiJTdG9ybXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTclNkU3ZwbWlucW1TdEdFTENTTmQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3djajExSzc3TGpFWTFQa0VhemZmYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zd2NqMTFLNzdMakVZMVBrRWF6ZmZhIiwiaWQiOiIzd2NqMTFLNzdMakVZMVBrRWF6ZmZhIiwibmFtZSI6IkJ1cm5hIEJveSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozd2NqMTFLNzdMakVZMVBrRWF6ZmZhIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdxUElTS0hoaEtETFpUbVljWDdiV2QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3FQSVNLSGhoS0RMWlRtWWNYN2JXZCIsImlkIjoiN3FQSVNLSGhoS0RMWlRtWWNYN2JXZCIsIm5hbWUiOiJTdHlsbyBHIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdxUElTS0hoaEtETFpUbVljWDdiV2QifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2wxQzIzYVJwNGxma0JLM2xMQXAybSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zbDFDMjNhUnA0bGZrQkszbExBcDJtIiwiaWQiOiIzbDFDMjNhUnA0bGZrQkszbExBcDJtIiwibmFtZSI6IlRvZGRsYSBUIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNsMUMyM2FScDRsZmtCSzNsTEFwMm0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg1MDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFMyMDAwMDU3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82RFJRRVFMUkxFdWYyZTd0YzdBUk04In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNkRSUUVRTFJMRXVmMmU3dGM3QVJNOCIsImlkIjoiNkRSUUVRTFJMRXVmMmU3dGM3QVJNOCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPd24gSXQgKGZlYXQuIEJ1cm5hIEJveSAmIFN0eWxvIEcpIFtUb2RkbGEgVCBSZW1peF0iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NkRSUUVRTFJMRXVmMmU3dGM3QVJNOCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZQ==", + "IiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZCI6IjJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZEZ1A5b3RuWnc1ejZkYU9udElOeHAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkRnUDlvdG5adzV6NmRhT250SU54cCIsImlkIjoiNkRnUDlvdG5adzV6NmRhT250SU54cCIsIm5hbWUiOiJKb2VsIENvcnJ5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZEZ1A5b3RuWnc1ejZkYU9udElOeHAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82RFBXMGtib0FnbUdrbHN5VXpaVmJhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNkRQVzBrYm9BZ21Ha2xzeVV6WlZiYSIsImlkIjoiNkRQVzBrYm9BZ21Ha2xzeVV6WlZiYSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkZTE0ZjVjMWVkY2YxNzI5MzdkMjE2YmQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZGUxNGY1YzFlZGNmMTcyOTM3ZDIxNmJkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkZTE0ZjVjMWVkY2YxNzI5MzdkMjE2YmQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT3duIEl0IChmZWF0LiBFZCBTaGVlcmFuICYgQnVybmEgQm95KSBbSm9lbCBDb3JyeSBSZW1peF0iLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTEyLTExIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2RFBXMGtib0FnbUdrbHN5VXpaVmJhIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeQ==", + "LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZCI6IjJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZlVUtaWGFLa2N2aUgwS3U5dzJuM1YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmVVS1pYYUtrY3ZpSDBLdTl3Mm4zViIsImlkIjoiNmVVS1pYYUtrY3ZpSDBLdTl3Mm4zViIsIm5hbWUiOiJFZCBTaGVlcmFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZlVUtaWGFLa2N2aUgwS3U5dzJuM1YifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3djajExSzc3TGpFWTFQa0VhemZmYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zd2NqMTFLNzdMakVZMVBrRWF6ZmZhIiwiaWQiOiIzd2NqMTFLNzdMakVZMVBrRWF6ZmZhIiwibmFtZSI6IkJ1cm5hIEJveSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozd2NqMTFLNzdMakVZMVBrRWF6ZmZhIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZEZ1A5b3RuWnc1ejZkYU9udElOeHAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkRnUDlvdG5adzV6NmRhT250SU54cCIsImlkIjoiNkRnUDlvdG5adzV6NmRhT250SU54cCIsIm5hbWUiOiJKb2VsIENvcnJ5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZEZ1A5b3RuWnc1ejZkYU9udElOeHAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc2MjY1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFMyMDAwMjM4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80OWk1UW4zelhzTUJQc1NPbVlBRnV0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDlpNVFuM3pYc01CUHNTT21ZQUZ1dCIsImlkIjoiNDlpNVFuM3pYc01CUHNTT21ZQUZ1dCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPd24gSXQgKGZlYXQuIEVkIFNoZWVyYW4gJiBCdXJuYSBCb3kpIC0gSm9lbCBDb3JyeSBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0OQ==", + "aTVRbjN6WHNNQlBzU09tWUFGdXQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTclNkU3ZwbWlucW1TdEdFTENTTmQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsImlkIjoiMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsIm5hbWUiOiJTdG9ybXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTclNkU3ZwbWlucW1TdEdFTENTTmQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2h2aW5OWlJ6VExvUkVtcUZpS3IxYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zaHZpbk5aUnpUTG9SRW1xRmlLcjFiIiwiaWQiOiIzaHZpbk5aUnpUTG9SRW1xRmlLcjFiIiwibmFtZSI6IkNIQU5HTU8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2h2aW5OWlJ6VExvUkVtcUZpS3IxYiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzB4NmgzVkNiN1JZN1oxUlJTZ1hpeTUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8weDZoM1ZDYjdSWTdaMVJSU2dYaXk1IiwiaWQiOiIweDZoM1ZDYjdSWTdaMVJSU2dYaXk1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzIwMmI1OGRhZmVlNmQzOTM1MjdlMjkwMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyMDJiNThkYWZlZTZkMzkzNTI3ZTI5MDAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTIwMmI1OGRhZmVlNmQzOTM1MjdlMjkwMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPd24gSXQgKGZlYXQuIEJ1cm5hIEJveSAmIENIQU5HTU8pIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0xMi0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MHg2aDNWQ2I3Ulk3WjFSUlNnWGl5NSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTclNkU3ZwbWlucW1TdEdFTENTTmQifQ==", + "LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zaHZpbk5aUnpUTG9SRW1xRmlLcjFiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNodmluTlpSelRMb1JFbXFGaUtyMWIiLCJpZCI6IjNodmluTlpSelRMb1JFbXFGaUtyMWIiLCJuYW1lIjoiQ0hBTkdNTyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozaHZpbk5aUnpUTG9SRW1xRmlLcjFiIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN3Y2oxMUs3N0xqRVkxUGtFYXpmZmEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3djajExSzc3TGpFWTFQa0VhemZmYSIsImlkIjoiM3djajExSzc3TGpFWTFQa0VhemZmYSIsIm5hbWUiOiJCdXJuYSBCb3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3djajExSzc3TGpFWTFQa0VhemZmYSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTY1MDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIUzIwMDAyMzkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzV1ZVd4S0tDQ2h5Z2xRckpPNUl6cUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81dWVXeEtLQ0NoeWdsUXJKTzVJenFBIiwiaWQiOiI1dWVXeEtLQ0NoeWdsUXJKTzVJenFBIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik93biBJdCAoZmVhdC4gQnVybmEgQm95ICYgQ0hBTkdNTykiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXVlV3hLS0NDaHlnbFFySk81SXpxQSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3Jteg==", + "eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZEZ1A5b3RuWnc1ejZkYU9udElOeHAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkRnUDlvdG5adzV6NmRhT250SU54cCIsImlkIjoiNkRnUDlvdG5adzV6NmRhT250SU54cCIsIm5hbWUiOiJKb2VsIENvcnJ5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZEZ1A5b3RuWnc1ejZkYU9udElOeHAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83c0VTN0dGU2d6N29IUjNRQkhIaEM1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3NFUzdHRlNnejdvSFIzUUJISGhDNSIsImlkIjoiN3NFUzdHRlNnejdvSFIzUUJISGhDNSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5Mjk3NWMwNmYxYzlkZGRhNmQ1YTUwNDkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTI5NzVjMDZmMWM5ZGRkYTZkNWE1MDQ5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5Mjk3NWMwNmYxYzlkZGRhNmQ1YTUwNDkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT3duIEl0IChmZWF0LiBFZCBTaGVlcmFuICYgQnVybmEgQm95KSBbSm9lbCBDb3JyeSBSZW1peF0gW0V4dGVuZGVkIE1peF0iLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTEyLTExIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3c0VTN0dGU2d6N29IUjNRQkhIaEM1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwbw==", + "dGlmeS5jb20vYXJ0aXN0LzZlVUtaWGFLa2N2aUgwS3U5dzJuM1YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmVVS1pYYUtrY3ZpSDBLdTl3Mm4zViIsImlkIjoiNmVVS1pYYUtrY3ZpSDBLdTl3Mm4zViIsIm5hbWUiOiJFZCBTaGVlcmFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZlVUtaWGFLa2N2aUgwS3U5dzJuM1YifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3djajExSzc3TGpFWTFQa0VhemZmYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zd2NqMTFLNzdMakVZMVBrRWF6ZmZhIiwiaWQiOiIzd2NqMTFLNzdMakVZMVBrRWF6ZmZhIiwibmFtZSI6IkJ1cm5hIEJveSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozd2NqMTFLNzdMakVZMVBrRWF6ZmZhIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZEZ1A5b3RuWnc1ejZkYU9udElOeHAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkRnUDlvdG5adzV6NmRhT250SU54cCIsImlkIjoiNkRnUDlvdG5adzV6NmRhT250SU54cCIsIm5hbWUiOiJKb2VsIENvcnJ5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZEZ1A5b3RuWnc1ejZkYU9udElOeHAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ5ODk0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFMyMDAwMzM0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wVWZIdW9UM1JnUVlPbDJvNkw2bVZhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMFVmSHVvVDNSZ1FZT2wybzZMNm1WYSIsImlkIjoiMFVmSHVvVDNSZ1FZT2wybzZMNm1WYSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPd24gSXQgKGZlYXQuIEVkIFNoZWVyYW4gJiBCdXJuYSBCb3kpIFtKb2VsIENvcnJ5IFJlbWl4XSAtIEV4dGVuZGVkIE1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowVWZIdW9UM1JnUVlPbDJvNkw2bVZhIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTclNkU3ZwbWlucW1TdEdFTENTTmQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuYw==", + "b20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFOSjNETEJlYTNSSzFBQ0hkR3VtMWUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xTkozRExCZWEzUksxQUNIZEd1bTFlIiwiaWQiOiIxTkozRExCZWEzUksxQUNIZEd1bTFlIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzllYzQ5MmUxMzA0MDhlNzg4YThiNzJkMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5ZWM0OTJlMTMwNDA4ZTc4OGE4YjcyZDMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTllYzQ5MmUxMzA0MDhlNzg4YThiNzJkMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZWF2eSBJcyBUaGUgSGVhZCIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMTItMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxTkozRExCZWEzUksxQUNIZEd1bTFlIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zd2NqMTFLNzdMakVZMVBrRWF6ZmZhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN3Y2oxMUs3N0xqRVkxUGtFYXpmZmEiLCJpZCI6IjN3Y2oxMUs3N0xqRVkxUGtFYXpmZmEiLCJuYW1lIjoiQnVybmEgQm95IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN3Y2oxMUs3N0xqRVkxUGtFYXpmZmEifSx7ImV4dGVybmFsX3VybHMiOg==", + "eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82ZVVLWlhhS2tjdmlIMEt1OXcybjNWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZlVUtaWGFLa2N2aUgwS3U5dzJuM1YiLCJpZCI6IjZlVUtaWGFLa2N2aUgwS3U5dzJuM1YiLCJuYW1lIjoiRWQgU2hlZXJhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2ZVVLWlhhS2tjdmlIMEt1OXcybjNWIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxNjcwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMTkwMTM2OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMWh0NEpvbDdMaE5DMzhnT1RRa3dhMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFodDRKb2w3TGhOQzM4Z09UUWt3YTIiLCJpZCI6IjFodDRKb2w3TGhOQzM4Z09UUWt3YTIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT3duIEl0IChmZWF0LiBFZCBTaGVlcmFuICYgQnVybmEgQm95KSIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MWh0NEpvbDdMaE5DMzhnT1RRa3dhMiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82TlJ4VDRmUkxVb1MySjZ6d0w3d1JqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNk5SeFQ0ZlJMVW9TMko2endMN3dSaiIsImlkIjoiNk5SeFQ0ZlJMVW9TMko2endMN3dSaiIsImltYWdlcyI6W3si", + "aGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlNjg3ZTVkYTc1YzA0OWZhODNjZmNkOTQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTY4N2U1ZGE3NWMwNDlmYTgzY2ZjZDk0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlNjg3ZTVkYTc1YzA0OWZhODNjZmNkOTQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmV3IE11c2ljIDIwMjAgQ2hhcnQiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTA1LTI5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nk5SeFQ0ZlJMVW9TMko2endMN3dSaiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTclNkU3ZwbWlucW1TdEdFTENTTmQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsImlkIjoiMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCIsIm5hbWUiOiJTdG9ybXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTclNkU3ZwbWlucW1TdEdFTENTTmQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3djajExSzc3TGpFWTFQa0VhemZmYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zd2NqMTFLNzdMakVZMVBrRWF6ZmZhIiwiaWQiOiIzd2NqMTFLNzdMakVZMVBrRWF6ZmZhIiwibmFtZSI6IkJ1cm5hIEJveSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozd2NqMTFLNzdMakVZMVBrRWF6ZmZhIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdxUElTS0hoaEtETFpUbVljWDdiV2QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3FQSVNLSGhoS0RMWlRtWWNYN2JXZCIsImlkIjoiN3FQSVNLSGhoS0RMWlRtWWNYN2JXZCIsIm5hbWUiOiJTdHlsbyBHIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdxUElTS0hoaEtETFpUbVljWDdiV2QifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2wxQzIzYVJwNGxma0JLM2xMQXAybSJ9LCJocmVmIg==", + "OiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNsMUMyM2FScDRsZmtCSzNsTEFwMm0iLCJpZCI6IjNsMUMyM2FScDRsZmtCSzNsTEFwMm0iLCJuYW1lIjoiVG9kZGxhIFQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2wxQzIzYVJwNGxma0JLM2xMQXAybSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODUwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIUzIwMDAwNTcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVScm1WVHNncmtCV29OUURjV05RajkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81UnJtVlRzZ3JrQldvTlFEY1dOUWo5IiwiaWQiOiI1UnJtVlRzZ3JrQldvTlFEY1dOUWo5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik93biBJdCAoZmVhdC4gQnVybmEgQm95ICYgU3R5bG8gRykgW1RvZGRsYSBUIFJlbWl4XSIsInRyYWNrX251bWJlciI6MTYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NVJybVZUc2dya0JXb05RRGNXTlFqOSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJyWGVkTk8xZDV4SndkSTduUk45NmwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yclhlZE5PMWQ1eEp3ZEk3blJOOTZsIiwiaWQiOiIyclhlZE5PMWQ1eEp3ZEk3blJOOTZsIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzg5MjIxN2IxNjgzOWUwZmU4ZWUyZDVlMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4OTIyMTdiMTY4MzllMGZlOGVlMmQ1ZTAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2Nw==", + "NjE2ZDAwMDA0ODUxODkyMjE3YjE2ODM5ZTBmZThlZTJkNWUwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRvbid0IEZvcmdldCBUbyBCcmVhdGhlIC8gRG8gQmV0dGVyIC8gV2lsZXkgRmxvdyAvT3duIEl0IGZlYXQuIEJ1cm5hIEJveSAvQW55Ym9keSAvIFJhaW5mYWxsIGZlYXQuIFRpYW5hIE1ham9yOSAoTGl2ZSBmcm9tIHRoZSBCUklUIEF3YXJkcyBMb25kb24gMjAyMCkiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTAyLTE4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyclhlZE5PMWQ1eEp3ZEk3blJOOTZsIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo2MzE5MTgsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMjAwMDEwMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWNLZEhiYkp5RVAyRGNjbHV6Mm5iaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVjS2RIYmJKeUVQMkRjY2x1ejJuYmoiLCJpZCI6IjVjS2RIYmJKeUVQMkRjY2x1ejJuYmoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRG9uJ3QgRm9yZ2V0IFRvIEJyZWF0aGUgLyBEbyBCZXR0ZXIgLyBXaWxleSBGbG93IC9Pd24gSXQgZmVhdC4gQnVybmEgQm95IC9Bbnlib2R5IC8gUmFpbmZhbGwgZmVhdC4gVGlhbmEgTWFqb3I5IC0gTGl2ZSBmcm9tIHRoZSBCUklUIEF3YXJkcyBMb25kb24gMjAyMCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1Y0tkSGJiSnlFUDJEY2NsdXoybmJqIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Own+It%22+artist%3A%22Stormzy%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Watching%20Windows%20J%20Dilla&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":10,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IVcLMMbm05VIjnzPkGCyp"},"href":"https://api.spotify.com/v1/artists/0IVcLMMbm05VIjnzPkGCyp","id":"0IVcLMMbm05VIjnzPkGCyp","name":"J Dilla","type":"artist","uri":"spotify:artist:0IVcLMMbm05VIjnzPkGCyp"}],"external_urls":{"spotify":"https://open.spotify.com/album/5rTGQkvZqXiNxtPCLKbytQ"},"href":"https://api.spotify.com/v1/albums/5rTGQkvZqXiNxtPCLKbytQ","id":"5rTGQkvZqXiNxtPCLKbytQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732c6b9259351cfd761f61fc39"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022c6b9259351cfd761f61fc39"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512c6b9259351cfd761f61fc39"}],"is_playable":true,"name":"Jay Stay Paid","release_date":"2009-06-02","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:5rTGQkvZqXiNxtPCLKbytQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IVcLMMbm05VIjnzPkGCyp"},"href":"https://api.spotify.com/v1/artists/0IVcLMMbm05VIjnzPkGCyp","id":"0IVcLMMbm05VIjnzPkGCyp","name":"J Dilla","type":"artist","uri":"spotify:artist:0IVcLMMbm05VIjnzPkGCyp"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DJEUXZm0e2rAohdoZ5Voo"},"href":"https://api.spotify.com/v1/artists/6DJEUXZm0e2rAohdoZ5Voo","id":"6DJEUXZm0e2rAohdoZ5Voo","name":"Black Thought","type":"artist","uri":"spotify:artist:6DJEUXZm0e2rAohdoZ5Voo"}],"disc_number":1,"duration_ms":160066,"explicit":true,"external_ids":{"isrc":"USHKR0914215"},"external_urls":{"spotify":"https://open.spotify.com/track/2aERIFMBgj8BQcvBwVzi5b"},"href":"https://api.spotify.com/v1/tracks/2aERIFMBgj8BQcvBwVzi5b","id":"2aERIFMBgj8BQcvBwVzi5b","is_local":false,"is_playable":true,"name":"Reality TV","track_number":15,"type":"track","uri":"spotify:track:2aERIFMBgj8BQcvBwVzi5b"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IVcLMMbm05VIjnzPkGCyp"},"href":"https://api.spotify.com/v1/artists/0IVcLMMbm05VIjnzPkGCyp","id":"0IVcLMMbm05VIjnzPkGCyp","name":"J Dilla","type":"artist","uri":"spotify:artist:0IVcLMMbm05VIjnzPkGCyp"}],"external_urls":{"spotify":"https://open.spotify.com/album/12aqY1VSvY5G0jHg5JMASc"},"href":"https://api.spotify.com/v1/albums/12aqY1VSvY5G0jHg5JMASc","id":"12aqY1VSvY5G0jHg5JMASc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731a495aeaf23a8f63bc619679"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021a495aeaf23a8f63bc619679"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511a495aeaf23a8f63bc619679"}],"is_playable":true,"name":"Reality Check","release_date":"2009-05-12","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:12aqY1VSvY5G0jHg5JMASc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IVcLMMbm05VIjnzPkGCyp"},"href":"https://api.spotify.com/v1/artists/0IVcLMMbm05VIjnzPkGCyp","id":"0IVcLMMbm05VIjnzPkGCyp","name":"J Dilla","type":"artist","uri":"spotify:artist:0IVcLMMbm05VIjnzPkGCyp"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DJEUXZm0e2rAohdoZ5Voo"},"href":"https://api.spotify.com/v1/artists/6DJEUXZm0e2rAohdoZ5Voo","id":"6DJEUXZm0e2rAohdoZ5Voo","name":"Black Thought","type":"artist","uri":"spotify:artist:6DJEUXZm0e2rAohdoZ5Voo"}],"disc_number":1,"duration_ms":160559,"explicit":true,"external_ids":{"isrc":"USQY50923075"},"external_urls":{"spotify":"https://open.spotify.com/track/7guCQP3MroYRQ3TrdhVvxf"},"href":"https://api.spotify.com/v1/tracks/7guCQP3MroYRQ3TrdhVvxf","id":"7guCQP3MroYRQ3TrdhVvxf","is_local":false,"is_playable":true,"name":"Reality Check","track_number":1,"type":"track","uri":"spotify:track:7guCQP3MroYRQ3TrdhVvxf"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"}],"external_urls":{"spotify":"https://open.spotify.com/album/4OoNqHBpbgDoqtN3u1IdiC"},"href":"https://api.spotify.com/v1/albums/4OoNqHBpbgDoqtN3u1IdiC","id":"4OoNqHBpbgDoqtN3u1IdiC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27316f96f33365e0ae909f75698"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0216f96f33365e0ae909f75698"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485116f96f33365e0ae909f75698"}],"is_playable":true,"name":"King Push \u2013 Darkest Before Dawn: The Prelude","release_date":"2015-12-18","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4OoNqHBpbgDoqtN3u1IdiC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"}],"disc_number":1,"duration_ms":153440,"explicit":true,"external_ids":{"isrc":"USUM71518562"},"external_urls":{"spotify":"https://open.spotify.com/track/6iLgI1bt8nZ8JAls44sxDp"},"href":"https://api.spotify.com/v1/tracks/6iLgI1bt8nZ8JAls44sxDp","id":"6iLgI1bt8nZ8JAls44sxDp","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:6iLgI1bt8nZ8JAls44sxDp"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7dGJo4pcD2V6oG8kP0tJRR"},"href":"https://api.spotify.com/v1/artists/7dGJo4pcD2V6oG8kP0tJRR","id":"7dGJo4pcD2V6oG8kP0tJRR","name":"Eminem","type":"artist","uri":"spotify:artist:7dGJo4pcD2V6oG8kP0tJRR"}],"external_urls":{"spotify":"https://open.spotify.com/album/5DV2liMHX5AqtiLqy3Qu1b"},"href":"https://api.spotify.com/v1/albums/5DV2liMHX5AqtiLqy3Qu1b","id":"5DV2liMHX5AqtiLqy3Qu1b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273837a5c94e095f7f06bf6de38"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02837a5c94e095f7f06bf6de38"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851837a5c94e095f7f06bf6de38"}],"is_playable":true,"name":"STANS (The Official Soundtrack)","release_date":"2025-08-26","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5DV2liMHX5AqtiLqy3Qu1b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7dGJo4pcD2V6oG8kP0tJRR"},"href":"https://api.spotify.com/v1/artists/7dGJo4pcD2V6oG8kP0tJRR","id":"7dGJo4pcD2V6oG8kP0tJRR","name":"Eminem","type":"artist","uri":"spotify:artist:7dGJo4pcD2V6oG8kP0tJRR"}],"disc_number":1,"duration_ms":294357,"explicit":true,"external_ids":{"isrc":"USUG12406490"},"external_urls":{"spotify":"https://open.spotify.com/track/4yYI0Cly9B2p8XbNxfNCRy"},"href":"https://api.spotify.com/v1/tracks/4yYI0Cly9B2p8XbNxfNCRy","id":"4yYI0Cly9B2p8XbNxfNCRy","is_local":false,"is_playable":true,"name":"Everybody\u2019s Looking At Me","track_number":10,"type":"track","uri":"spotify:track:4yYI0Cly9B2p8XbNxfNCRy"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6diDsPkeLxmF1r5vKnfOli"},"href":"https://api.spotify.com/v1/artists/6diDsPkeLxmF1r5vKnfOli","id":"6diDsPkeLxmF1r5vKnfOli","name":"Jay Ham","type":"artist","uri":"spotify:artist:6diDsPkeLxmF1r5vKnfOli"}],"external_urls":{"spotify":"https://open.spotify.com/album/6F4P9FUm9bOuuXXll2XWXy"},"href":"https://api.spotify.com/v1/albums/6F4P9FUm9bOuuXXll2XWXy","id":"6F4P9FUm9bOuuXXll2XWXy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfa8df7ef000b92c6f0ee8b0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfa8df7ef000b92c6f0ee8b0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfa8df7ef000b92c6f0ee8b0"}],"is_playable":true,"name":"Sunset Potions","release_date":"2020-10-16","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6F4P9FUm9bOuuXXll2XWXy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6diDsPkeLxmF1r5vKnfOli"},"href":"https://api.spotify.com/v1/artists/6diDsPkeLxmF1r5vKnfOli","id":"6diDsPkeLxmF1r5vKnfOli","name":"Jay Ham","type":"artist","uri":"spotify:artist:6diDsPkeLxmF1r5vKnfOli"}],"disc_number":1,"duration_ms":156855,"explicit":true,"external_ids":{"isrc":"QZMHP2082683"},"external_urls":{"spotify":"https://open.spotify.com/track/5jO5ivkqrMgp3Q4NzeMjA8"},"href":"https://api.spotify.com/v1/tracks/5jO5ivkqrMgp3Q4NzeMjA8","id":"5jO5ivkqrMgp3Q4NzeMjA8","is_local":false,"is_playable":true,"name":"Road Trip","track_number":1,"type":"track","uri":"spotify:track:5jO5ivkqrMgp3Q4NzeMjA8"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6JnOfiXu2aMGvPnBY7k7kg"},"href":"https://api.spotify.com/v1/artists/6JnOfiXu2aMGvPnBY7k7kg","id":"6JnOfiXu2aMGvPnBY7k7kg","name":"Eezy","type":"artist","uri":"spotify:artist:6JnOfiXu2aMGvPnBY7k7kg"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Jlb1XVQiH8p8P9ch0Kt5z"},"href":"https://api.spotify.com/v1/albums/6Jlb1XVQiH8p8P9ch0Kt5z","id":"6Jlb1XVQiH8p8P9ch0Kt5z","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735ebc45092a42c22171ca36c4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025ebc45092a42c22171ca36c4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515ebc45092a42c22171ca36c4"}],"is_playable":true,"name":"Dutchie","release_date":"2023-09-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6Jlb1XVQiH8p8P9ch0Kt5z"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6JnOfiXu2aMGvPnBY7k7kg"},"href":"https://api.spotify.com/v1/artists/6JnOfiXu2aMGvPnBY7k7kg","id":"6JnOfiXu2aMGvPnBY7k7kg","name":"Eezy","type":"artist","uri":"spotify:artist:6JnOfiXu2aMGvPnBY7k7kg"}],"disc_number":1,"duration_ms":101996,"explicit":true,"external_ids":{"isrc":"GX5MX2379355"},"external_urls":{"spotify":"https://open.spotify.com/track/5IvfR1qeedmK2gzWM3aafD"},"href":"https://api.spotify.com/v1/tracks/5IvfR1qeedmK2gzWM3aafD","id":"5IvfR1qeedmK2gzWM3aafD","is_local":false,"is_playable":true,"name":"Dutchie","track_number":1,"type":"track","uri":"spotify:track:5IvfR1qeedmK2gzWM3aafD"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1WIHbvNZTybCVHFMbzuGJo"},"href":"https://api.spotify.com/v1/artists/1WIHbvNZTybCVHFMbzuGJo","id":"1WIHbvNZTybCVHFMbzuGJo","name":"Crypt","type":"artist","uri":"spotify:artist:1WIHbvNZTybCVHFMbzuGJo"}],"external_urls":{"spotify":"https://open.spotify.com/album/3AXnB7ctyfpwqz7rq5k1pA"},"href":"https://api.spotify.com/v1/albums/3AXnB7ctyfpwqz7rq5k1pA","id":"3AXnB7ctyfpwqz7rq5k1pA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f3c731e1a03ab52b4ed2f01"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f3c731e1a03ab52b4ed2f01"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f3c731e1a03ab52b4ed2f01"}],"is_playable":true,"name":"YouTube Cypher, Vol. 3","release_date":"2020-05-09","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3AXnB7ctyfpwqz7rq5k1pA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1WIHbvNZTybCVHFMbzuGJo"},"href":"https://api.spotify.com/v1/artists/1WIHbvNZTybCVHFMbzuGJo","id":"1WIHbvNZTybCVHFMbzuGJo","name":"Crypt","type":"artist","uri":"spotify:artist:1WIHbvNZTybCVHFMbzuGJo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5icKdCmMhNMYoAzVBAWt39"},"href":"https://api.spotify.com/v1/artists/5icKdCmMhNMYoAzVBAWt39","id":"5icKdCmMhNMYoAzVBAWt39","name":"Dax","type":"artist","uri":"spotify:artist:5icKdCmMhNMYoAzVBAWt39"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4oYZcPoj3q3DneXomtQBzg"},"href":"https://api.spotify.com/v1/artists/4oYZcPoj3q3DneXomtQBzg","id":"4oYZcPoj3q3DneXomtQBzg","name":"Merkules","type":"artist","uri":"spotify:artist:4oYZcPoj3q3DneXomtQBzg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5Z5jUyiNvFaqp0EVyLNf0p"},"href":"https://api.spotify.com/v1/artists/5Z5jUyiNvFaqp0EVyLNf0p","id":"5Z5jUyiNvFaqp0EVyLNf0p","name":"Futuristic","type":"artist","uri":"spotify:artist:5Z5jUyiNvFaqp0EVyLNf0p"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5lC7N2Mm9i92KSfW4opawO"},"href":"https://api.spotify.com/v1/artists/5lC7N2Mm9i92KSfW4opawO","id":"5lC7N2Mm9i92KSfW4opawO","name":"Ekoh","type":"artist","uri":"spotify:artist:5lC7N2Mm9i92KSfW4opawO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2QgIoMnyOZZA0GCpoXhBWF"},"href":"https://api.spotify.com/v1/artists/2QgIoMnyOZZA0GCpoXhBWF","id":"2QgIoMnyOZZA0GCpoXhBWF","name":"NoLifeShaq","type":"artist","uri":"spotify:artist:2QgIoMnyOZZA0GCpoXhBWF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3aCW3D92sHEREMaOUjw5gd"},"href":"https://api.spotify.com/v1/artists/3aCW3D92sHEREMaOUjw5gd","id":"3aCW3D92sHEREMaOUjw5gd","name":"100kufis","type":"artist","uri":"spotify:artist:3aCW3D92sHEREMaOUjw5gd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6J18Ox8UlTuFKcBn8Dx6hK"},"href":"https://api.spotify.com/v1/artists/6J18Ox8UlTuFKcBn8Dx6hK","id":"6J18Ox8UlTuFKcBn8Dx6hK","name":"Samad Savage","type":"artist","uri":"spotify:artist:6J18Ox8UlTuFKcBn8Dx6hK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/37ZwUTUMfDJQUuxclvwuuc"},"href":"https://api.spotify.com/v1/artists/37ZwUTUMfDJQUuxclvwuuc","id":"37ZwUTUMfDJQUuxclvwuuc","name":"Carly X","type":"artist","uri":"spotify:artist:37ZwUTUMfDJQUuxclvwuuc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5IEv10kDPVFB23d7kXUZbn"},"href":"https://api.spotify.com/v1/artists/5IEv10kDPVFB23d7kXUZbn","id":"5IEv10kDPVFB23d7kXUZbn","name":"Ashtin Larold","type":"artist","uri":"spotify:artist:5IEv10kDPVFB23d7kXUZbn"}],"disc_number":1,"duration_ms":761080,"explicit":true,"external_ids":{"isrc":"QZES82025082"},"external_urls":{"spotify":"https://open.spotify.com/track/5XwPzXNg0Qex6mLkoOCetf"},"href":"https://api.spotify.com/v1/tracks/5XwPzXNg0Qex6mLkoOCetf","id":"5XwPzXNg0Qex6mLkoOCetf","is_local":false,"is_playable":true,"name":"YouTube Cypher, Vol. 3","track_number":1,"type":"track","uri":"spotify:track:5XwPzXNg0Qex6mLkoOCetf"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5sr1So7Md5RMxFnMRZNZeR"},"href":"https://api.spotify.com/v1/albums/5sr1So7Md5RMxFnMRZNZeR","id":"5sr1So7Md5RMxFnMRZNZeR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cc2e80af406baf3e9ced0d8a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cc2e80af406baf3e9ced0d8a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cc2e80af406baf3e9ced0d8a"}],"is_playable":true,"name":"1800 Seconds: Curated by Pusha-T","release_date":"2018-12-07","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5sr1So7Md5RMxFnMRZNZeR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"}],"disc_number":1,"duration_ms":29271,"explicit":false,"external_ids":{"isrc":"QM8RL1800712"},"external_urls":{"spotify":"https://open.spotify.com/track/3280YIIXDZpIhqSt9OwtWQ"},"href":"https://api.spotify.com/v1/tracks/3280YIIXDZpIhqSt9OwtWQ","id":"3280YIIXDZpIhqSt9OwtWQ","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:3280YIIXDZpIhqSt9OwtWQ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02uOKPzjqd4N9DVo4lsiU4"},"href":"https://api.spotify.com/v1/artists/02uOKPzjqd4N9DVo4lsiU4","id":"02uOKPzjqd4N9DVo4lsiU4","name":"Bobby Hustle","type":"artist","uri":"spotify:artist:02uOKPzjqd4N9DVo4lsiU4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0owDqBxiGeQCj9WVzE3rtP"},"href":"https://api.spotify.com/v1/artists/0owDqBxiGeQCj9WVzE3rtP","id":"0owDqBxiGeQCj9WVzE3rtP","name":"Dread Kennedy","type":"artist","uri":"spotify:artist:0owDqBxiGeQCj9WVzE3rtP"}],"external_urls":{"spotify":"https://open.spotify.com/album/1ka8bCd8XYU5oZgAP9PxID"},"href":"https://api.spotify.com/v1/albums/1ka8bCd8XYU5oZgAP9PxID","id":"1ka8bCd8XYU5oZgAP9PxID","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a82f63d3097cde476804bdad"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a82f63d3097cde476804bdad"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a82f63d3097cde476804bdad"}],"is_playable":true,"name":"Cali 101","release_date":"2021-05-21","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1ka8bCd8XYU5oZgAP9PxID"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02uOKPzjqd4N9DVo4lsiU4"},"href":"https://api.spotify.com/v1/artists/02uOKPzjqd4N9DVo4lsiU4","id":"02uOKPzjqd4N9DVo4lsiU4","name":"Bobby Hustle","type":"artist","uri":"spotify:artist:02uOKPzjqd4N9DVo4lsiU4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0owDqBxiGeQCj9WVzE3rtP"},"href":"https://api.spotify.com/v1/artists/0owDqBxiGeQCj9WVzE3rtP","id":"0owDqBxiGeQCj9WVzE3rtP","name":"Dread Kennedy","type":"artist","uri":"spotify:artist:0owDqBxiGeQCj9WVzE3rtP"}],"disc_number":1,"duration_ms":206499,"explicit":false,"external_ids":{"isrc":"USUYG1367788"},"external_urls":{"spotify":"https://open.spotify.com/track/5AW4TeNCcVXdpEhYln0Fad"},"href":"https://api.spotify.com/v1/tracks/5AW4TeNCcVXdpEhYln0Fad","id":"5AW4TeNCcVXdpEhYln0Fad","is_local":false,"is_playable":true,"name":"Cali 101","track_number":1,"type":"track","uri":"spotify:track:5AW4TeNCcVXdpEhYln0Fad"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5KBFHKgn6RgblzTtBdie4Z"},"href":"https://api.spotify.com/v1/artists/5KBFHKgn6RgblzTtBdie4Z","id":"5KBFHKgn6RgblzTtBdie4Z","name":"KiAN","type":"artist","uri":"spotify:artist:5KBFHKgn6RgblzTtBdie4Z"}],"external_urls":{"spotify":"https://open.spotify.com/album/7ydmtoJ7flinRQoBBg2DlD"},"href":"https://api.spotify.com/v1/albums/7ydmtoJ7flinRQoBBg2DlD","id":"7ydmtoJ7flinRQoBBg2DlD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273de21401682411b649606a592"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02de21401682411b649606a592"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851de21401682411b649606a592"}],"is_playable":true,"name":"Candyman","release_date":"2020-10-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7ydmtoJ7flinRQoBBg2DlD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5KBFHKgn6RgblzTtBdie4Z"},"href":"https://api.spotify.com/v1/artists/5KBFHKgn6RgblzTtBdie4Z","id":"5KBFHKgn6RgblzTtBdie4Z","name":"KiAN","type":"artist","uri":"spotify:artist:5KBFHKgn6RgblzTtBdie4Z"}],"disc_number":1,"duration_ms":155520,"explicit":false,"external_ids":{"isrc":"QZMEQ2035071"},"external_urls":{"spotify":"https://open.spotify.com/track/2N6EkUo2Q8655q0htG2Qgf"},"href":"https://api.spotify.com/v1/tracks/2N6EkUo2Q8655q0htG2Qgf","id":"2N6EkUo2Q8655q0htG2Qgf","is_local":false,"is_playable":true,"name":"Candyman","track_number":1,"type":"track","uri":"spotify:track:2N6EkUo2Q8655q0htG2Qgf"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Watching%20Windows%20J%20Dilla&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":10,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IVcLMMbm05VIjnzPkGCyp"},"href":"https://api.spotify.com/v1/artists/0IVcLMMbm05VIjnzPkGCyp","id":"0IVcLMMbm05VIjnzPkGCyp","name":"J Dilla","type":"artist","uri":"spotify:artist:0IVcLMMbm05VIjnzPkGCyp"}],"external_urls":{"spotify":"https://open.spotify.com/album/5rTGQkvZqXiNxtPCLKbytQ"},"href":"https://api.spotify.com/v1/albums/5rTGQkvZqXiNxtPCLKbytQ","id":"5rTGQkvZqXiNxtPCLKbytQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732c6b9259351cfd761f61fc39"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022c6b9259351cfd761f61fc39"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512c6b9259351cfd761f61fc39"}],"is_playable":true,"name":"Jay Stay Paid","release_date":"2009-06-02","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:5rTGQkvZqXiNxtPCLKbytQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IVcLMMbm05VIjnzPkGCyp"},"href":"https://api.spotify.com/v1/artists/0IVcLMMbm05VIjnzPkGCyp","id":"0IVcLMMbm05VIjnzPkGCyp","name":"J Dilla","type":"artist","uri":"spotify:artist:0IVcLMMbm05VIjnzPkGCyp"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DJEUXZm0e2rAohdoZ5Voo"},"href":"https://api.spotify.com/v1/artists/6DJEUXZm0e2rAohdoZ5Voo","id":"6DJEUXZm0e2rAohdoZ5Voo","name":"Black Thought","type":"artist","uri":"spotify:artist:6DJEUXZm0e2rAohdoZ5Voo"}],"disc_number":1,"duration_ms":160066,"explicit":true,"external_ids":{"isrc":"USHKR0914215"},"external_urls":{"spotify":"https://open.spotify.com/track/2aERIFMBgj8BQcvBwVzi5b"},"href":"https://api.spotify.com/v1/tracks/2aERIFMBgj8BQcvBwVzi5b","id":"2aERIFMBgj8BQcvBwVzi5b","is_local":false,"is_playable":true,"name":"Reality TV","track_number":15,"type":"track","uri":"spotify:track:2aERIFMBgj8BQcvBwVzi5b"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IVcLMMbm05VIjnzPkGCyp"},"href":"https://api.spotify.com/v1/artists/0IVcLMMbm05VIjnzPkGCyp","id":"0IVcLMMbm05VIjnzPkGCyp","name":"J Dilla","type":"artist","uri":"spotify:artist:0IVcLMMbm05VIjnzPkGCyp"}],"external_urls":{"spotify":"https://open.spotify.com/album/12aqY1VSvY5G0jHg5JMASc"},"href":"https://api.spotify.com/v1/albums/12aqY1VSvY5G0jHg5JMASc","id":"12aqY1VSvY5G0jHg5JMASc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731a495aeaf23a8f63bc619679"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021a495aeaf23a8f63bc619679"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511a495aeaf23a8f63bc619679"}],"is_playable":true,"name":"Reality Check","release_date":"2009-05-12","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:12aqY1VSvY5G0jHg5JMASc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IVcLMMbm05VIjnzPkGCyp"},"href":"https://api.spotify.com/v1/artists/0IVcLMMbm05VIjnzPkGCyp","id":"0IVcLMMbm05VIjnzPkGCyp","name":"J Dilla","type":"artist","uri":"spotify:artist:0IVcLMMbm05VIjnzPkGCyp"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DJEUXZm0e2rAohdoZ5Voo"},"href":"https://api.spotify.com/v1/artists/6DJEUXZm0e2rAohdoZ5Voo","id":"6DJEUXZm0e2rAohdoZ5Voo","name":"Black Thought","type":"artist","uri":"spotify:artist:6DJEUXZm0e2rAohdoZ5Voo"}],"disc_number":1,"duration_ms":160559,"explicit":true,"external_ids":{"isrc":"USQY50923075"},"external_urls":{"spotify":"https://open.spotify.com/track/7guCQP3MroYRQ3TrdhVvxf"},"href":"https://api.spotify.com/v1/tracks/7guCQP3MroYRQ3TrdhVvxf","id":"7guCQP3MroYRQ3TrdhVvxf","is_local":false,"is_playable":true,"name":"Reality Check","track_number":1,"type":"track","uri":"spotify:track:7guCQP3MroYRQ3TrdhVvxf"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"}],"external_urls":{"spotify":"https://open.spotify.com/album/4OoNqHBpbgDoqtN3u1IdiC"},"href":"https://api.spotify.com/v1/albums/4OoNqHBpbgDoqtN3u1IdiC","id":"4OoNqHBpbgDoqtN3u1IdiC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27316f96f33365e0ae909f75698"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0216f96f33365e0ae909f75698"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485116f96f33365e0ae909f75698"}],"is_playable":true,"name":"King Push \u2013 Darkest Before Dawn: The Prelude","release_date":"2015-12-18","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4OoNqHBpbgDoqtN3u1IdiC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"}],"disc_number":1,"duration_ms":153440,"explicit":true,"external_ids":{"isrc":"USUM71518562"},"external_urls":{"spotify":"https://open.spotify.com/track/6iLgI1bt8nZ8JAls44sxDp"},"href":"https://api.spotify.com/v1/tracks/6iLgI1bt8nZ8JAls44sxDp","id":"6iLgI1bt8nZ8JAls44sxDp","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:6iLgI1bt8nZ8JAls44sxDp"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7dGJo4pcD2V6oG8kP0tJRR"},"href":"https://api.spotify.com/v1/artists/7dGJo4pcD2V6oG8kP0tJRR","id":"7dGJo4pcD2V6oG8kP0tJRR","name":"Eminem","type":"artist","uri":"spotify:artist:7dGJo4pcD2V6oG8kP0tJRR"}],"external_urls":{"spotify":"https://open.spotify.com/album/5DV2liMHX5AqtiLqy3Qu1b"},"href":"https://api.spotify.com/v1/albums/5DV2liMHX5AqtiLqy3Qu1b","id":"5DV2liMHX5AqtiLqy3Qu1b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273837a5c94e095f7f06bf6de38"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02837a5c94e095f7f06bf6de38"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851837a5c94e095f7f06bf6de38"}],"is_playable":true,"name":"STANS (The Official Soundtrack)","release_date":"2025-08-26","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5DV2liMHX5AqtiLqy3Qu1b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7dGJo4pcD2V6oG8kP0tJRR"},"href":"https://api.spotify.com/v1/artists/7dGJo4pcD2V6oG8kP0tJRR","id":"7dGJo4pcD2V6oG8kP0tJRR","name":"Eminem","type":"artist","uri":"spotify:artist:7dGJo4pcD2V6oG8kP0tJRR"}],"disc_number":1,"duration_ms":294357,"explicit":true,"external_ids":{"isrc":"USUG12406490"},"external_urls":{"spotify":"https://open.spotify.com/track/4yYI0Cly9B2p8XbNxfNCRy"},"href":"https://api.spotify.com/v1/tracks/4yYI0Cly9B2p8XbNxfNCRy","id":"4yYI0Cly9B2p8XbNxfNCRy","is_local":false,"is_playable":true,"name":"Everybody\u2019s Looking At Me","track_number":10,"type":"track","uri":"spotify:track:4yYI0Cly9B2p8XbNxfNCRy"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6diDsPkeLxmF1r5vKnfOli"},"href":"https://api.spotify.com/v1/artists/6diDsPkeLxmF1r5vKnfOli","id":"6diDsPkeLxmF1r5vKnfOli","name":"Jay Ham","type":"artist","uri":"spotify:artist:6diDsPkeLxmF1r5vKnfOli"}],"external_urls":{"spotify":"https://open.spotify.com/album/6F4P9FUm9bOuuXXll2XWXy"},"href":"https://api.spotify.com/v1/albums/6F4P9FUm9bOuuXXll2XWXy","id":"6F4P9FUm9bOuuXXll2XWXy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfa8df7ef000b92c6f0ee8b0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfa8df7ef000b92c6f0ee8b0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfa8df7ef000b92c6f0ee8b0"}],"is_playable":true,"name":"Sunset Potions","release_date":"2020-10-16","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6F4P9FUm9bOuuXXll2XWXy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6diDsPkeLxmF1r5vKnfOli"},"href":"https://api.spotify.com/v1/artists/6diDsPkeLxmF1r5vKnfOli","id":"6diDsPkeLxmF1r5vKnfOli","name":"Jay Ham","type":"artist","uri":"spotify:artist:6diDsPkeLxmF1r5vKnfOli"}],"disc_number":1,"duration_ms":156855,"explicit":true,"external_ids":{"isrc":"QZMHP2082683"},"external_urls":{"spotify":"https://open.spotify.com/track/5jO5ivkqrMgp3Q4NzeMjA8"},"href":"https://api.spotify.com/v1/tracks/5jO5ivkqrMgp3Q4NzeMjA8","id":"5jO5ivkqrMgp3Q4NzeMjA8","is_local":false,"is_playable":true,"name":"Road Trip","track_number":1,"type":"track","uri":"spotify:track:5jO5ivkqrMgp3Q4NzeMjA8"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6JnOfiXu2aMGvPnBY7k7kg"},"href":"https://api.spotify.com/v1/artists/6JnOfiXu2aMGvPnBY7k7kg","id":"6JnOfiXu2aMGvPnBY7k7kg","name":"Eezy","type":"artist","uri":"spotify:artist:6JnOfiXu2aMGvPnBY7k7kg"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Jlb1XVQiH8p8P9ch0Kt5z"},"href":"https://api.spotify.com/v1/albums/6Jlb1XVQiH8p8P9ch0Kt5z","id":"6Jlb1XVQiH8p8P9ch0Kt5z","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735ebc45092a42c22171ca36c4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025ebc45092a42c22171ca36c4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515ebc45092a42c22171ca36c4"}],"is_playable":true,"name":"Dutchie","release_date":"2023-09-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6Jlb1XVQiH8p8P9ch0Kt5z"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6JnOfiXu2aMGvPnBY7k7kg"},"href":"https://api.spotify.com/v1/artists/6JnOfiXu2aMGvPnBY7k7kg","id":"6JnOfiXu2aMGvPnBY7k7kg","name":"Eezy","type":"artist","uri":"spotify:artist:6JnOfiXu2aMGvPnBY7k7kg"}],"disc_number":1,"duration_ms":101996,"explicit":true,"external_ids":{"isrc":"GX5MX2379355"},"external_urls":{"spotify":"https://open.spotify.com/track/5IvfR1qeedmK2gzWM3aafD"},"href":"https://api.spotify.com/v1/tracks/5IvfR1qeedmK2gzWM3aafD","id":"5IvfR1qeedmK2gzWM3aafD","is_local":false,"is_playable":true,"name":"Dutchie","track_number":1,"type":"track","uri":"spotify:track:5IvfR1qeedmK2gzWM3aafD"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1WIHbvNZTybCVHFMbzuGJo"},"href":"https://api.spotify.com/v1/artists/1WIHbvNZTybCVHFMbzuGJo","id":"1WIHbvNZTybCVHFMbzuGJo","name":"Crypt","type":"artist","uri":"spotify:artist:1WIHbvNZTybCVHFMbzuGJo"}],"external_urls":{"spotify":"https://open.spotify.com/album/3AXnB7ctyfpwqz7rq5k1pA"},"href":"https://api.spotify.com/v1/albums/3AXnB7ctyfpwqz7rq5k1pA","id":"3AXnB7ctyfpwqz7rq5k1pA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f3c731e1a03ab52b4ed2f01"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f3c731e1a03ab52b4ed2f01"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f3c731e1a03ab52b4ed2f01"}],"is_playable":true,"name":"YouTube Cypher, Vol. 3","release_date":"2020-05-09","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3AXnB7ctyfpwqz7rq5k1pA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1WIHbvNZTybCVHFMbzuGJo"},"href":"https://api.spotify.com/v1/artists/1WIHbvNZTybCVHFMbzuGJo","id":"1WIHbvNZTybCVHFMbzuGJo","name":"Crypt","type":"artist","uri":"spotify:artist:1WIHbvNZTybCVHFMbzuGJo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5icKdCmMhNMYoAzVBAWt39"},"href":"https://api.spotify.com/v1/artists/5icKdCmMhNMYoAzVBAWt39","id":"5icKdCmMhNMYoAzVBAWt39","name":"Dax","type":"artist","uri":"spotify:artist:5icKdCmMhNMYoAzVBAWt39"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4oYZcPoj3q3DneXomtQBzg"},"href":"https://api.spotify.com/v1/artists/4oYZcPoj3q3DneXomtQBzg","id":"4oYZcPoj3q3DneXomtQBzg","name":"Merkules","type":"artist","uri":"spotify:artist:4oYZcPoj3q3DneXomtQBzg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5Z5jUyiNvFaqp0EVyLNf0p"},"href":"https://api.spotify.com/v1/artists/5Z5jUyiNvFaqp0EVyLNf0p","id":"5Z5jUyiNvFaqp0EVyLNf0p","name":"Futuristic","type":"artist","uri":"spotify:artist:5Z5jUyiNvFaqp0EVyLNf0p"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5lC7N2Mm9i92KSfW4opawO"},"href":"https://api.spotify.com/v1/artists/5lC7N2Mm9i92KSfW4opawO","id":"5lC7N2Mm9i92KSfW4opawO","name":"Ekoh","type":"artist","uri":"spotify:artist:5lC7N2Mm9i92KSfW4opawO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2QgIoMnyOZZA0GCpoXhBWF"},"href":"https://api.spotify.com/v1/artists/2QgIoMnyOZZA0GCpoXhBWF","id":"2QgIoMnyOZZA0GCpoXhBWF","name":"NoLifeShaq","type":"artist","uri":"spotify:artist:2QgIoMnyOZZA0GCpoXhBWF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3aCW3D92sHEREMaOUjw5gd"},"href":"https://api.spotify.com/v1/artists/3aCW3D92sHEREMaOUjw5gd","id":"3aCW3D92sHEREMaOUjw5gd","name":"100kufis","type":"artist","uri":"spotify:artist:3aCW3D92sHEREMaOUjw5gd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6J18Ox8UlTuFKcBn8Dx6hK"},"href":"https://api.spotify.com/v1/artists/6J18Ox8UlTuFKcBn8Dx6hK","id":"6J18Ox8UlTuFKcBn8Dx6hK","name":"Samad Savage","type":"artist","uri":"spotify:artist:6J18Ox8UlTuFKcBn8Dx6hK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/37ZwUTUMfDJQUuxclvwuuc"},"href":"https://api.spotify.com/v1/artists/37ZwUTUMfDJQUuxclvwuuc","id":"37ZwUTUMfDJQUuxclvwuuc","name":"Carly X","type":"artist","uri":"spotify:artist:37ZwUTUMfDJQUuxclvwuuc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5IEv10kDPVFB23d7kXUZbn"},"href":"https://api.spotify.com/v1/artists/5IEv10kDPVFB23d7kXUZbn","id":"5IEv10kDPVFB23d7kXUZbn","name":"Ashtin Larold","type":"artist","uri":"spotify:artist:5IEv10kDPVFB23d7kXUZbn"}],"disc_number":1,"duration_ms":761080,"explicit":true,"external_ids":{"isrc":"QZES82025082"},"external_urls":{"spotify":"https://open.spotify.com/track/5XwPzXNg0Qex6mLkoOCetf"},"href":"https://api.spotify.com/v1/tracks/5XwPzXNg0Qex6mLkoOCetf","id":"5XwPzXNg0Qex6mLkoOCetf","is_local":false,"is_playable":true,"name":"YouTube Cypher, Vol. 3","track_number":1,"type":"track","uri":"spotify:track:5XwPzXNg0Qex6mLkoOCetf"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5sr1So7Md5RMxFnMRZNZeR"},"href":"https://api.spotify.com/v1/albums/5sr1So7Md5RMxFnMRZNZeR","id":"5sr1So7Md5RMxFnMRZNZeR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cc2e80af406baf3e9ced0d8a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cc2e80af406baf3e9ced0d8a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cc2e80af406baf3e9ced0d8a"}],"is_playable":true,"name":"1800 Seconds: Curated by Pusha-T","release_date":"2018-12-07","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5sr1So7Md5RMxFnMRZNZeR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ONHkAv9pCAFxb0zJwDNTy"},"href":"https://api.spotify.com/v1/artists/0ONHkAv9pCAFxb0zJwDNTy","id":"0ONHkAv9pCAFxb0zJwDNTy","name":"Pusha T","type":"artist","uri":"spotify:artist:0ONHkAv9pCAFxb0zJwDNTy"}],"disc_number":1,"duration_ms":29271,"explicit":false,"external_ids":{"isrc":"QM8RL1800712"},"external_urls":{"spotify":"https://open.spotify.com/track/3280YIIXDZpIhqSt9OwtWQ"},"href":"https://api.spotify.com/v1/tracks/3280YIIXDZpIhqSt9OwtWQ","id":"3280YIIXDZpIhqSt9OwtWQ","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:3280YIIXDZpIhqSt9OwtWQ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02uOKPzjqd4N9DVo4lsiU4"},"href":"https://api.spotify.com/v1/artists/02uOKPzjqd4N9DVo4lsiU4","id":"02uOKPzjqd4N9DVo4lsiU4","name":"Bobby Hustle","type":"artist","uri":"spotify:artist:02uOKPzjqd4N9DVo4lsiU4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0owDqBxiGeQCj9WVzE3rtP"},"href":"https://api.spotify.com/v1/artists/0owDqBxiGeQCj9WVzE3rtP","id":"0owDqBxiGeQCj9WVzE3rtP","name":"Dread Kennedy","type":"artist","uri":"spotify:artist:0owDqBxiGeQCj9WVzE3rtP"}],"external_urls":{"spotify":"https://open.spotify.com/album/1ka8bCd8XYU5oZgAP9PxID"},"href":"https://api.spotify.com/v1/albums/1ka8bCd8XYU5oZgAP9PxID","id":"1ka8bCd8XYU5oZgAP9PxID","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a82f63d3097cde476804bdad"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a82f63d3097cde476804bdad"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a82f63d3097cde476804bdad"}],"is_playable":true,"name":"Cali 101","release_date":"2021-05-21","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1ka8bCd8XYU5oZgAP9PxID"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02uOKPzjqd4N9DVo4lsiU4"},"href":"https://api.spotify.com/v1/artists/02uOKPzjqd4N9DVo4lsiU4","id":"02uOKPzjqd4N9DVo4lsiU4","name":"Bobby Hustle","type":"artist","uri":"spotify:artist:02uOKPzjqd4N9DVo4lsiU4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0owDqBxiGeQCj9WVzE3rtP"},"href":"https://api.spotify.com/v1/artists/0owDqBxiGeQCj9WVzE3rtP","id":"0owDqBxiGeQCj9WVzE3rtP","name":"Dread Kennedy","type":"artist","uri":"spotify:artist:0owDqBxiGeQCj9WVzE3rtP"}],"disc_number":1,"duration_ms":206499,"explicit":false,"external_ids":{"isrc":"USUYG1367788"},"external_urls":{"spotify":"https://open.spotify.com/track/5AW4TeNCcVXdpEhYln0Fad"},"href":"https://api.spotify.com/v1/tracks/5AW4TeNCcVXdpEhYln0Fad","id":"5AW4TeNCcVXdpEhYln0Fad","is_local":false,"is_playable":true,"name":"Cali 101","track_number":1,"type":"track","uri":"spotify:track:5AW4TeNCcVXdpEhYln0Fad"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5KBFHKgn6RgblzTtBdie4Z"},"href":"https://api.spotify.com/v1/artists/5KBFHKgn6RgblzTtBdie4Z","id":"5KBFHKgn6RgblzTtBdie4Z","name":"KiAN","type":"artist","uri":"spotify:artist:5KBFHKgn6RgblzTtBdie4Z"}],"external_urls":{"spotify":"https://open.spotify.com/album/7ydmtoJ7flinRQoBBg2DlD"},"href":"https://api.spotify.com/v1/albums/7ydmtoJ7flinRQoBBg2DlD","id":"7ydmtoJ7flinRQoBBg2DlD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273de21401682411b649606a592"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02de21401682411b649606a592"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851de21401682411b649606a592"}],"is_playable":true,"name":"Candyman","release_date":"2020-10-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7ydmtoJ7flinRQoBBg2DlD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5KBFHKgn6RgblzTtBdie4Z"},"href":"https://api.spotify.com/v1/artists/5KBFHKgn6RgblzTtBdie4Z","id":"5KBFHKgn6RgblzTtBdie4Z","name":"KiAN","type":"artist","uri":"spotify:artist:5KBFHKgn6RgblzTtBdie4Z"}],"disc_number":1,"duration_ms":155520,"explicit":false,"external_ids":{"isrc":"QZMEQ2035071"},"external_urls":{"spotify":"https://open.spotify.com/track/2N6EkUo2Q8655q0htG2Qgf"},"href":"https://api.spotify.com/v1/tracks/2N6EkUo2Q8655q0htG2Qgf","id":"2N6EkUo2Q8655q0htG2Qgf","is_local":false,"is_playable":true,"name":"Candyman","track_number":1,"type":"track","uri":"spotify:track:2N6EkUo2Q8655q0htG2Qgf"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Watching+Windows+J+Dilla&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJlc3QlMjBQYXJ0JTIyJTIwYXJ0aXN0JTNBJTIyRGFuaWVsJTIwQ2Flc2FyJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yMHdrVkx1dHFWT1lyYzBreEZzN3JBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzIwd2tWTHV0cVZPWXJjMGt4RnM3ckEiLCJpZCI6IjIwd2tWTHV0cVZPWXJjMGt4RnM3ckEiLCJuYW1lIjoiRGFuaWVsIENhZXNhciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyMHdrVkx1dHFWT1lyYzBreEZzN3JBIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNEUxWFVCTVRwTE83R3BCelVvNjVKcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRFMVhVQk1UcExPN0dwQnpVbzY1SnAiLCJpZCI6IjRFMVhVQk1UcExPN0dwQnpVbzY1SnAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbg==", + "LmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3YWE4NzgzYWQ4ZGVmMzdjYzU0OGE5Y2YifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyN2FhODc4M2FkOGRlZjM3Y2M1NDhhOWNmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3YWE4NzgzYWQ4ZGVmMzdjYzU0OGE5Y2YifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRnJldWRpYW4iLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA4LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEUxWFVCTVRwTE83R3BCelVvNjVKcCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzIwd2tWTHV0cVZPWXJjMGt4RnM3ckEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjB3a1ZMdXRxVk9ZcmMwa3hGczdyQSIsImlkIjoiMjB3a1ZMdXRxVk9ZcmMwa3hGczdyQSIsIm5hbWUiOiJEYW5pZWwgQ2Flc2FyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjIwd2tWTHV0cVZPWXJjMGt4RnM3ckEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1k3UlozMVRSUFZhZFNGVnkxbzhvcyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zWTdSWjMxVFJQVmFkU0ZWeTFvOG9zIiwiaWQiOiIzWTdSWjMxVFJQVmFkU0ZWeTFvOG9zIiwibmFtZSI6IkguRS5SLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozWTdSWjMxVFJQVmFkU0ZWeTFvOG9zIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwOTgzMSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkNBRERTMTcwMDAyMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVE3RWdpTU91d0RjQjBQSkM2QXpPTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFRN0VnaU1PdXdEY0IwUEpDNkF6T04iLCJpZCI6IjFRN0VnaU1PdXdEY0IwUEpDNkF6T04iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmVzdCBQYXJ0IChmZWF0LiBILkUuUi4pIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFRN0VnaU1PdXdEYw==", + "QjBQSkM2QXpPTiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zWTdSWjMxVFJQVmFkU0ZWeTFvOG9zIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNZN1JaMzFUUlBWYWRTRlZ5MW84b3MiLCJpZCI6IjNZN1JaMzFUUlBWYWRTRlZ5MW84b3MiLCJuYW1lIjoiSC5FLlIuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNZN1JaMzFUUlBWYWRTRlZ5MW84b3MifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wcFYwTXgwN2FNQXBJcEYxOW9TUWdZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMHBWME14MDdhTUFwSXBGMTlvU1FnWSIsImlkIjoiMHBWME14MDdhTUFwSXBGMTlvU1FnWSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwOTI3MDE3NTcxOTFiMzAwYjdiMjEwZTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDkyNzAxNzU3MTkxYjMwMGI3YjIxMGU4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwOTI3MDE3NTcxOTFiMzAwYjdiMjEwZTgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSC5FLlIuIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0xMC0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBwVjBNeDA3YU1BcElwRjE5b1NRZ1kifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yMHdrVkx1dHFWT1lyYzBreEZzN3JBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzIwd2tWTHV0cVZPWXJjMGt4RnM3ckEiLCJpZCI6IjIwd2tWTHV0cVZPWXJjMGt4RnM3ckEiLCJuYW1lIjoiRGFuaWVsIENhZXNhciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyMHdrVkx1dHFWT1lyYzBreEZzN3JBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNZN1JaMzFUUlBWYWRTRlZ5MW84b3MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tLw==", + "djEvYXJ0aXN0cy8zWTdSWjMxVFJQVmFkU0ZWeTFvOG9zIiwiaWQiOiIzWTdSWjMxVFJQVmFkU0ZWeTFvOG9zIiwibmFtZSI6IkguRS5SLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozWTdSWjMxVFJQVmFkU0ZWeTFvOG9zIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwOTM4OCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkNBRERTMTcwMDAyMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNE9CWlQ5RW5oWUlWMTd0NHBHdzdpZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRPQlpUOUVuaFlJVjE3dDRwR3c3aWciLCJpZCI6IjRPQlpUOUVuaFlJVjE3dDRwR3c3aWciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmVzdCBQYXJ0IChmZWF0LiBILkUuUi4pIiwidHJhY2tfbnVtYmVyIjoxMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0T0JaVDlFbmhZSVYxN3Q0cEd3N2lnIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yMHdrVkx1dHFWT1lyYzBreEZzN3JBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzIwd2tWTHV0cVZPWXJjMGt4RnM3ckEiLCJpZCI6IjIwd2tWTHV0cVZPWXJjMGt4RnM3ckEiLCJuYW1lIjoiRGFuaWVsIENhZXNhciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyMHdrVkx1dHFWT1lyYzBreEZzN3JBIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkI4NDcxdXJvOTRrRFZ2OUQzZTFGRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZCODQ3MXVybzk0a0RWdjlEM2UxRkUiLCJpZCI6IjZCODQ3MXVybzk0a0RWdjlEM2UxRkUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTM0OGRhODIwYTU2MTU0YjNkY2M5Mjk0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEzNDhkYTgyMGE1NjE1NGIzZGNjOTI5NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTM0OGRhODIwYTU2MTU0YjNkY2M5Mjk0In1dLCJpc19wbGF5YQ==", + "YmxlIjp0cnVlLCJuYW1lIjoiVXAgTmV4dCBMaXZlIEZyb20gQXBwbGUgQ292ZW50IEdhcmRlbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDgtMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZCODQ3MXVybzk0a0RWdjlEM2UxRkUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yMHdrVkx1dHFWT1lyYzBreEZzN3JBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzIwd2tWTHV0cVZPWXJjMGt4RnM3ckEiLCJpZCI6IjIwd2tWTHV0cVZPWXJjMGt4RnM3ckEiLCJuYW1lIjoiRGFuaWVsIENhZXNhciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyMHdrVkx1dHFWT1lyYzBreEZzN3JBIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI4Mjg4MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTMzhZMjUxODE4MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMnUxWmNETWFPOHBiRFFhUXh2eDVOeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJ1MVpjRE1hTzhwYkRRYVF4dng1TnkiLCJpZCI6IjJ1MVpjRE1hTzhwYkRRYVF4dng1TnkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmVzdCBQYXJ0IC0gTGl2ZSIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoydTFaY0RNYU84cGJEUWFReHZ4NU55In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Best+Part%22+artist%3A%22Daniel+Caesar%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Peaches%22%20artist%3A%22Synthetic Listener%20Bieber%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/5dGWwsZ9iB2Xc3UKR0gif2"},"href":"https://api.spotify.com/v1/albums/5dGWwsZ9iB2Xc3UKR0gif2","id":"5dGWwsZ9iB2Xc3UKR0gif2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e6f407c7f3a0ec98845e4431"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e6f407c7f3a0ec98845e4431"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e6f407c7f3a0ec98845e4431"}],"is_playable":true,"name":"Justice","release_date":"2021-03-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5dGWwsZ9iB2Xc3UKR0gif2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":true,"external_ids":{"isrc":"USUM72102636"},"external_urls":{"spotify":"https://open.spotify.com/track/4iJyoBOLtHqaGxP12qzhQI"},"href":"https://api.spotify.com/v1/tracks/4iJyoBOLtHqaGxP12qzhQI","id":"4iJyoBOLtHqaGxP12qzhQI","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:4iJyoBOLtHqaGxP12qzhQI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ePtIWy2cIBbxpg36TG2NS"},"href":"https://api.spotify.com/v1/albums/4ePtIWy2cIBbxpg36TG2NS","id":"4ePtIWy2cIBbxpg36TG2NS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374a3ea7069e65f36a851b725"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274a3ea7069e65f36a851b725"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174a3ea7069e65f36a851b725"}],"is_playable":true,"name":"Peaches (Remix)","release_date":"2021-06-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4ePtIWy2cIBbxpg36TG2NS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3ipn9JLAPI5GUEo4y4jcoi"},"href":"https://api.spotify.com/v1/artists/3ipn9JLAPI5GUEo4y4jcoi","id":"3ipn9JLAPI5GUEo4y4jcoi","name":"Ludacris","type":"artist","uri":"spotify:artist:3ipn9JLAPI5GUEo4y4jcoi"}],"disc_number":1,"duration_ms":229472,"explicit":true,"external_ids":{"isrc":"USUM72109687"},"external_urls":{"spotify":"https://open.spotify.com/track/5E75Cr0oqxGoX0YYwdC3nZ"},"href":"https://api.spotify.com/v1/tracks/5E75Cr0oqxGoX0YYwdC3nZ","id":"5E75Cr0oqxGoX0YYwdC3nZ","is_local":false,"is_playable":true,"name":"Peaches (Remix) feat. Ludacris, Usher & Snoop Dogg","track_number":1,"type":"track","uri":"spotify:track:5E75Cr0oqxGoX0YYwdC3nZ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3dUPwMGYAsymFv80wkqEKl"},"href":"https://api.spotify.com/v1/artists/3dUPwMGYAsymFv80wkqEKl","id":"3dUPwMGYAsymFv80wkqEKl","name":"Alpha P","type":"artist","uri":"spotify:artist:3dUPwMGYAsymFv80wkqEKl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yOvAmpIR7hVxiS6Ls5DPO"},"href":"https://api.spotify.com/v1/artists/5yOvAmpIR7hVxiS6Ls5DPO","id":"5yOvAmpIR7hVxiS6Ls5DPO","name":"OMAH LAY","type":"artist","uri":"spotify:artist:5yOvAmpIR7hVxiS6Ls5DPO"}],"external_urls":{"spotify":"https://open.spotify.com/album/6gjoP9QAJ8QYDjBoVV8p0o"},"href":"https://api.spotify.com/v1/albums/6gjoP9QAJ8QYDjBoVV8p0o","id":"6gjoP9QAJ8QYDjBoVV8p0o","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a1850c473b9654f6e14434a1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a1850c473b9654f6e14434a1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a1850c473b9654f6e14434a1"}],"is_playable":true,"name":"Peaches (Masterkraft Remix)","release_date":"2021-06-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6gjoP9QAJ8QYDjBoVV8p0o"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3dUPwMGYAsymFv80wkqEKl"},"href":"https://api.spotify.com/v1/artists/3dUPwMGYAsymFv80wkqEKl","id":"3dUPwMGYAsymFv80wkqEKl","name":"Alpha P","type":"artist","uri":"spotify:artist:3dUPwMGYAsymFv80wkqEKl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yOvAmpIR7hVxiS6Ls5DPO"},"href":"https://api.spotify.com/v1/artists/5yOvAmpIR7hVxiS6Ls5DPO","id":"5yOvAmpIR7hVxiS6Ls5DPO","name":"OMAH LAY","type":"artist","uri":"spotify:artist:5yOvAmpIR7hVxiS6Ls5DPO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0lEUtJddtvvDlxtEmF9j0m"},"href":"https://api.spotify.com/v1/artists/0lEUtJddtvvDlxtEmF9j0m","id":"0lEUtJddtvvDlxtEmF9j0m","name":"Masterkraft","type":"artist","uri":"spotify:artist:0lEUtJddtvvDlxtEmF9j0m"}],"disc_number":1,"duration_ms":194896,"explicit":true,"external_ids":{"isrc":"USUM72110702"},"external_urls":{"spotify":"https://open.spotify.com/track/6lUpRCvUGvAymNGJzVywN8"},"href":"https://api.spotify.com/v1/tracks/6lUpRCvUGvAymNGJzVywN8","id":"6lUpRCvUGvAymNGJzVywN8","is_local":false,"is_playable":true,"name":"Peaches (Masterkraft Remix) feat. Alpha P & Omah Lay","track_number":1,"type":"track","uri":"spotify:track:6lUpRCvUGvAymNGJzVywN8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/6mzpIm84OXCBxw6Tuhp1OA"},"href":"https://api.spotify.com/v1/albums/6mzpIm84OXCBxw6Tuhp1OA","id":"6mzpIm84OXCBxw6Tuhp1OA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a01fed49fe3a84a9919cef29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a01fed49fe3a84a9919cef29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a01fed49fe3a84a9919cef29"}],"is_playable":true,"name":"Justice (Triple Chucks Deluxe)","release_date":"2021-03-26","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6mzpIm84OXCBxw6Tuhp1OA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":true,"external_ids":{"isrc":"USUM72102636"},"external_urls":{"spotify":"https://open.spotify.com/track/3wKpoOfaQaxdnalXMqSPpO"},"href":"https://api.spotify.com/v1/tracks/3wKpoOfaQaxdnalXMqSPpO","id":"3wKpoOfaQaxdnalXMqSPpO","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:3wKpoOfaQaxdnalXMqSPpO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/0w1dwXfG5z6Xjjgj524JkD"},"href":"https://api.spotify.com/v1/albums/0w1dwXfG5z6Xjjgj524JkD","id":"0w1dwXfG5z6Xjjgj524JkD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736036cfd2a718036fc523855f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026036cfd2a718036fc523855f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516036cfd2a718036fc523855f"}],"is_playable":true,"name":"Justice","release_date":"2021-03-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0w1dwXfG5z6Xjjgj524JkD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":false,"external_ids":{"isrc":"USUM72102647"},"external_urls":{"spotify":"https://open.spotify.com/track/1ZrpvgLUBHozH2PLbc4SrO"},"href":"https://api.spotify.com/v1/tracks/1ZrpvgLUBHozH2PLbc4SrO","id":"1ZrpvgLUBHozH2PLbc4SrO","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:1ZrpvgLUBHozH2PLbc4SrO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/3uPnO1aZBwMgWK1DI5zve9"},"href":"https://api.spotify.com/v1/albums/3uPnO1aZBwMgWK1DI5zve9","id":"3uPnO1aZBwMgWK1DI5zve9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730cad1d28e91209690bdfb907"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020cad1d28e91209690bdfb907"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510cad1d28e91209690bdfb907"}],"is_playable":true,"name":"Justice (The Complete Edition)","release_date":"2021-10-08","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:3uPnO1aZBwMgWK1DI5zve9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":true,"external_ids":{"isrc":"USUM72102636"},"external_urls":{"spotify":"https://open.spotify.com/track/2vxifWbsK3QiAy1vriVbNE"},"href":"https://api.spotify.com/v1/tracks/2vxifWbsK3QiAy1vriVbNE","id":"2vxifWbsK3QiAy1vriVbNE","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:2vxifWbsK3QiAy1vriVbNE"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3dUPwMGYAsymFv80wkqEKl"},"href":"https://api.spotify.com/v1/artists/3dUPwMGYAsymFv80wkqEKl","id":"3dUPwMGYAsymFv80wkqEKl","name":"Alpha P","type":"artist","uri":"spotify:artist:3dUPwMGYAsymFv80wkqEKl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yOvAmpIR7hVxiS6Ls5DPO"},"href":"https://api.spotify.com/v1/artists/5yOvAmpIR7hVxiS6Ls5DPO","id":"5yOvAmpIR7hVxiS6Ls5DPO","name":"OMAH LAY","type":"artist","uri":"spotify:artist:5yOvAmpIR7hVxiS6Ls5DPO"}],"external_urls":{"spotify":"https://open.spotify.com/album/4UnKR52w1M0HZ1SGO1Xsf4"},"href":"https://api.spotify.com/v1/albums/4UnKR52w1M0HZ1SGO1Xsf4","id":"4UnKR52w1M0HZ1SGO1Xsf4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27310e9d87f93e6b151a4bbf7d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0210e9d87f93e6b151a4bbf7d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485110e9d87f93e6b151a4bbf7d7"}],"is_playable":true,"name":"Peaches (Masterkraft Remix)","release_date":"2021-06-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4UnKR52w1M0HZ1SGO1Xsf4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3dUPwMGYAsymFv80wkqEKl"},"href":"https://api.spotify.com/v1/artists/3dUPwMGYAsymFv80wkqEKl","id":"3dUPwMGYAsymFv80wkqEKl","name":"Alpha P","type":"artist","uri":"spotify:artist:3dUPwMGYAsymFv80wkqEKl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yOvAmpIR7hVxiS6Ls5DPO"},"href":"https://api.spotify.com/v1/artists/5yOvAmpIR7hVxiS6Ls5DPO","id":"5yOvAmpIR7hVxiS6Ls5DPO","name":"OMAH LAY","type":"artist","uri":"spotify:artist:5yOvAmpIR7hVxiS6Ls5DPO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0lEUtJddtvvDlxtEmF9j0m"},"href":"https://api.spotify.com/v1/artists/0lEUtJddtvvDlxtEmF9j0m","id":"0lEUtJddtvvDlxtEmF9j0m","name":"Masterkraft","type":"artist","uri":"spotify:artist:0lEUtJddtvvDlxtEmF9j0m"}],"disc_number":1,"duration_ms":194896,"explicit":false,"external_ids":{"isrc":"USUM72110812"},"external_urls":{"spotify":"https://open.spotify.com/track/304xi8j68U97LF12ozAURN"},"href":"https://api.spotify.com/v1/tracks/304xi8j68U97LF12ozAURN","id":"304xi8j68U97LF12ozAURN","is_local":false,"is_playable":true,"name":"Peaches (Masterkraft Remix) feat. Alpha P & Omah Lay","track_number":1,"type":"track","uri":"spotify:track:304xi8j68U97LF12ozAURN"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"}],"external_urls":{"spotify":"https://open.spotify.com/album/4DGQbJYpjHiLBvwHKdXSHJ"},"href":"https://api.spotify.com/v1/albums/4DGQbJYpjHiLBvwHKdXSHJ","id":"4DGQbJYpjHiLBvwHKdXSHJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27324a3110dd52890ce1ffabd9a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0224a3110dd52890ce1ffabd9a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485124a3110dd52890ce1ffabd9a"}],"is_playable":true,"name":"Peaches (Remix)","release_date":"2021-06-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4DGQbJYpjHiLBvwHKdXSHJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3ipn9JLAPI5GUEo4y4jcoi"},"href":"https://api.spotify.com/v1/artists/3ipn9JLAPI5GUEo4y4jcoi","id":"3ipn9JLAPI5GUEo4y4jcoi","name":"Ludacris","type":"artist","uri":"spotify:artist:3ipn9JLAPI5GUEo4y4jcoi"}],"disc_number":1,"duration_ms":229472,"explicit":false,"external_ids":{"isrc":"USUM72109688"},"external_urls":{"spotify":"https://open.spotify.com/track/010basloOyV7QxUPzYx7IC"},"href":"https://api.spotify.com/v1/tracks/010basloOyV7QxUPzYx7IC","id":"010basloOyV7QxUPzYx7IC","is_local":false,"is_playable":true,"name":"Peaches (Remix) feat. Ludacris, Usher & Snoop Dogg","track_number":1,"type":"track","uri":"spotify:track:010basloOyV7QxUPzYx7IC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/7DjqzdD8MYtzgiJDGHltsp"},"href":"https://api.spotify.com/v1/albums/7DjqzdD8MYtzgiJDGHltsp","id":"7DjqzdD8MYtzgiJDGHltsp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739f05db24a0ce9b5d02b87408"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029f05db24a0ce9b5d02b87408"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519f05db24a0ce9b5d02b87408"}],"is_playable":true,"name":"Justice (Triple Chucks Deluxe)","release_date":"2021-03-26","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:7DjqzdD8MYtzgiJDGHltsp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":false,"external_ids":{"isrc":"USUM72102647"},"external_urls":{"spotify":"https://open.spotify.com/track/5SgOFwlzue4P3s2dLj6BJE"},"href":"https://api.spotify.com/v1/tracks/5SgOFwlzue4P3s2dLj6BJE","id":"5SgOFwlzue4P3s2dLj6BJE","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:5SgOFwlzue4P3s2dLj6BJE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/5v2lj0w9VJIbjcUUKYLvlo"},"href":"https://api.spotify.com/v1/albums/5v2lj0w9VJIbjcUUKYLvlo","id":"5v2lj0w9VJIbjcUUKYLvlo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732dd4230bdcdfbc87c1ebc8b7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022dd4230bdcdfbc87c1ebc8b7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512dd4230bdcdfbc87c1ebc8b7"}],"is_playable":true,"name":"Justice (The Complete Edition)","release_date":"2021-10-08","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:5v2lj0w9VJIbjcUUKYLvlo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":false,"external_ids":{"isrc":"USUM72102647"},"external_urls":{"spotify":"https://open.spotify.com/track/1G1txd10Y8F0diS2WKBagu"},"href":"https://api.spotify.com/v1/tracks/1G1txd10Y8F0diS2WKBagu","id":"1G1txd10Y8F0diS2WKBagu","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:1G1txd10Y8F0diS2WKBagu"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Peaches%22%20artist%3A%22Synthetic Listener%20Bieber%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/5dGWwsZ9iB2Xc3UKR0gif2"},"href":"https://api.spotify.com/v1/albums/5dGWwsZ9iB2Xc3UKR0gif2","id":"5dGWwsZ9iB2Xc3UKR0gif2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e6f407c7f3a0ec98845e4431"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e6f407c7f3a0ec98845e4431"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e6f407c7f3a0ec98845e4431"}],"is_playable":true,"name":"Justice","release_date":"2021-03-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5dGWwsZ9iB2Xc3UKR0gif2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":true,"external_ids":{"isrc":"USUM72102636"},"external_urls":{"spotify":"https://open.spotify.com/track/4iJyoBOLtHqaGxP12qzhQI"},"href":"https://api.spotify.com/v1/tracks/4iJyoBOLtHqaGxP12qzhQI","id":"4iJyoBOLtHqaGxP12qzhQI","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:4iJyoBOLtHqaGxP12qzhQI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ePtIWy2cIBbxpg36TG2NS"},"href":"https://api.spotify.com/v1/albums/4ePtIWy2cIBbxpg36TG2NS","id":"4ePtIWy2cIBbxpg36TG2NS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374a3ea7069e65f36a851b725"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274a3ea7069e65f36a851b725"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174a3ea7069e65f36a851b725"}],"is_playable":true,"name":"Peaches (Remix)","release_date":"2021-06-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4ePtIWy2cIBbxpg36TG2NS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3ipn9JLAPI5GUEo4y4jcoi"},"href":"https://api.spotify.com/v1/artists/3ipn9JLAPI5GUEo4y4jcoi","id":"3ipn9JLAPI5GUEo4y4jcoi","name":"Ludacris","type":"artist","uri":"spotify:artist:3ipn9JLAPI5GUEo4y4jcoi"}],"disc_number":1,"duration_ms":229472,"explicit":true,"external_ids":{"isrc":"USUM72109687"},"external_urls":{"spotify":"https://open.spotify.com/track/5E75Cr0oqxGoX0YYwdC3nZ"},"href":"https://api.spotify.com/v1/tracks/5E75Cr0oqxGoX0YYwdC3nZ","id":"5E75Cr0oqxGoX0YYwdC3nZ","is_local":false,"is_playable":true,"name":"Peaches (Remix) feat. Ludacris, Usher & Snoop Dogg","track_number":1,"type":"track","uri":"spotify:track:5E75Cr0oqxGoX0YYwdC3nZ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3dUPwMGYAsymFv80wkqEKl"},"href":"https://api.spotify.com/v1/artists/3dUPwMGYAsymFv80wkqEKl","id":"3dUPwMGYAsymFv80wkqEKl","name":"Alpha P","type":"artist","uri":"spotify:artist:3dUPwMGYAsymFv80wkqEKl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yOvAmpIR7hVxiS6Ls5DPO"},"href":"https://api.spotify.com/v1/artists/5yOvAmpIR7hVxiS6Ls5DPO","id":"5yOvAmpIR7hVxiS6Ls5DPO","name":"OMAH LAY","type":"artist","uri":"spotify:artist:5yOvAmpIR7hVxiS6Ls5DPO"}],"external_urls":{"spotify":"https://open.spotify.com/album/6gjoP9QAJ8QYDjBoVV8p0o"},"href":"https://api.spotify.com/v1/albums/6gjoP9QAJ8QYDjBoVV8p0o","id":"6gjoP9QAJ8QYDjBoVV8p0o","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a1850c473b9654f6e14434a1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a1850c473b9654f6e14434a1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a1850c473b9654f6e14434a1"}],"is_playable":true,"name":"Peaches (Masterkraft Remix)","release_date":"2021-06-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6gjoP9QAJ8QYDjBoVV8p0o"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3dUPwMGYAsymFv80wkqEKl"},"href":"https://api.spotify.com/v1/artists/3dUPwMGYAsymFv80wkqEKl","id":"3dUPwMGYAsymFv80wkqEKl","name":"Alpha P","type":"artist","uri":"spotify:artist:3dUPwMGYAsymFv80wkqEKl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yOvAmpIR7hVxiS6Ls5DPO"},"href":"https://api.spotify.com/v1/artists/5yOvAmpIR7hVxiS6Ls5DPO","id":"5yOvAmpIR7hVxiS6Ls5DPO","name":"OMAH LAY","type":"artist","uri":"spotify:artist:5yOvAmpIR7hVxiS6Ls5DPO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0lEUtJddtvvDlxtEmF9j0m"},"href":"https://api.spotify.com/v1/artists/0lEUtJddtvvDlxtEmF9j0m","id":"0lEUtJddtvvDlxtEmF9j0m","name":"Masterkraft","type":"artist","uri":"spotify:artist:0lEUtJddtvvDlxtEmF9j0m"}],"disc_number":1,"duration_ms":194896,"explicit":true,"external_ids":{"isrc":"USUM72110702"},"external_urls":{"spotify":"https://open.spotify.com/track/6lUpRCvUGvAymNGJzVywN8"},"href":"https://api.spotify.com/v1/tracks/6lUpRCvUGvAymNGJzVywN8","id":"6lUpRCvUGvAymNGJzVywN8","is_local":false,"is_playable":true,"name":"Peaches (Masterkraft Remix) feat. Alpha P & Omah Lay","track_number":1,"type":"track","uri":"spotify:track:6lUpRCvUGvAymNGJzVywN8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/6mzpIm84OXCBxw6Tuhp1OA"},"href":"https://api.spotify.com/v1/albums/6mzpIm84OXCBxw6Tuhp1OA","id":"6mzpIm84OXCBxw6Tuhp1OA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a01fed49fe3a84a9919cef29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a01fed49fe3a84a9919cef29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a01fed49fe3a84a9919cef29"}],"is_playable":true,"name":"Justice (Triple Chucks Deluxe)","release_date":"2021-03-26","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6mzpIm84OXCBxw6Tuhp1OA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":true,"external_ids":{"isrc":"USUM72102636"},"external_urls":{"spotify":"https://open.spotify.com/track/3wKpoOfaQaxdnalXMqSPpO"},"href":"https://api.spotify.com/v1/tracks/3wKpoOfaQaxdnalXMqSPpO","id":"3wKpoOfaQaxdnalXMqSPpO","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:3wKpoOfaQaxdnalXMqSPpO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/0w1dwXfG5z6Xjjgj524JkD"},"href":"https://api.spotify.com/v1/albums/0w1dwXfG5z6Xjjgj524JkD","id":"0w1dwXfG5z6Xjjgj524JkD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736036cfd2a718036fc523855f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026036cfd2a718036fc523855f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516036cfd2a718036fc523855f"}],"is_playable":true,"name":"Justice","release_date":"2021-03-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0w1dwXfG5z6Xjjgj524JkD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":false,"external_ids":{"isrc":"USUM72102647"},"external_urls":{"spotify":"https://open.spotify.com/track/1ZrpvgLUBHozH2PLbc4SrO"},"href":"https://api.spotify.com/v1/tracks/1ZrpvgLUBHozH2PLbc4SrO","id":"1ZrpvgLUBHozH2PLbc4SrO","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:1ZrpvgLUBHozH2PLbc4SrO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/3uPnO1aZBwMgWK1DI5zve9"},"href":"https://api.spotify.com/v1/albums/3uPnO1aZBwMgWK1DI5zve9","id":"3uPnO1aZBwMgWK1DI5zve9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730cad1d28e91209690bdfb907"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020cad1d28e91209690bdfb907"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510cad1d28e91209690bdfb907"}],"is_playable":true,"name":"Justice (The Complete Edition)","release_date":"2021-10-08","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:3uPnO1aZBwMgWK1DI5zve9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":true,"external_ids":{"isrc":"USUM72102636"},"external_urls":{"spotify":"https://open.spotify.com/track/2vxifWbsK3QiAy1vriVbNE"},"href":"https://api.spotify.com/v1/tracks/2vxifWbsK3QiAy1vriVbNE","id":"2vxifWbsK3QiAy1vriVbNE","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:2vxifWbsK3QiAy1vriVbNE"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3dUPwMGYAsymFv80wkqEKl"},"href":"https://api.spotify.com/v1/artists/3dUPwMGYAsymFv80wkqEKl","id":"3dUPwMGYAsymFv80wkqEKl","name":"Alpha P","type":"artist","uri":"spotify:artist:3dUPwMGYAsymFv80wkqEKl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yOvAmpIR7hVxiS6Ls5DPO"},"href":"https://api.spotify.com/v1/artists/5yOvAmpIR7hVxiS6Ls5DPO","id":"5yOvAmpIR7hVxiS6Ls5DPO","name":"OMAH LAY","type":"artist","uri":"spotify:artist:5yOvAmpIR7hVxiS6Ls5DPO"}],"external_urls":{"spotify":"https://open.spotify.com/album/4UnKR52w1M0HZ1SGO1Xsf4"},"href":"https://api.spotify.com/v1/albums/4UnKR52w1M0HZ1SGO1Xsf4","id":"4UnKR52w1M0HZ1SGO1Xsf4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27310e9d87f93e6b151a4bbf7d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0210e9d87f93e6b151a4bbf7d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485110e9d87f93e6b151a4bbf7d7"}],"is_playable":true,"name":"Peaches (Masterkraft Remix)","release_date":"2021-06-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4UnKR52w1M0HZ1SGO1Xsf4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3dUPwMGYAsymFv80wkqEKl"},"href":"https://api.spotify.com/v1/artists/3dUPwMGYAsymFv80wkqEKl","id":"3dUPwMGYAsymFv80wkqEKl","name":"Alpha P","type":"artist","uri":"spotify:artist:3dUPwMGYAsymFv80wkqEKl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yOvAmpIR7hVxiS6Ls5DPO"},"href":"https://api.spotify.com/v1/artists/5yOvAmpIR7hVxiS6Ls5DPO","id":"5yOvAmpIR7hVxiS6Ls5DPO","name":"OMAH LAY","type":"artist","uri":"spotify:artist:5yOvAmpIR7hVxiS6Ls5DPO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0lEUtJddtvvDlxtEmF9j0m"},"href":"https://api.spotify.com/v1/artists/0lEUtJddtvvDlxtEmF9j0m","id":"0lEUtJddtvvDlxtEmF9j0m","name":"Masterkraft","type":"artist","uri":"spotify:artist:0lEUtJddtvvDlxtEmF9j0m"}],"disc_number":1,"duration_ms":194896,"explicit":false,"external_ids":{"isrc":"USUM72110812"},"external_urls":{"spotify":"https://open.spotify.com/track/304xi8j68U97LF12ozAURN"},"href":"https://api.spotify.com/v1/tracks/304xi8j68U97LF12ozAURN","id":"304xi8j68U97LF12ozAURN","is_local":false,"is_playable":true,"name":"Peaches (Masterkraft Remix) feat. Alpha P & Omah Lay","track_number":1,"type":"track","uri":"spotify:track:304xi8j68U97LF12ozAURN"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"}],"external_urls":{"spotify":"https://open.spotify.com/album/4DGQbJYpjHiLBvwHKdXSHJ"},"href":"https://api.spotify.com/v1/albums/4DGQbJYpjHiLBvwHKdXSHJ","id":"4DGQbJYpjHiLBvwHKdXSHJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27324a3110dd52890ce1ffabd9a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0224a3110dd52890ce1ffabd9a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485124a3110dd52890ce1ffabd9a"}],"is_playable":true,"name":"Peaches (Remix)","release_date":"2021-06-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4DGQbJYpjHiLBvwHKdXSHJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7hJcb9fa4alzcOq3EaNPoG"},"href":"https://api.spotify.com/v1/artists/7hJcb9fa4alzcOq3EaNPoG","id":"7hJcb9fa4alzcOq3EaNPoG","name":"Snoop Dogg","type":"artist","uri":"spotify:artist:7hJcb9fa4alzcOq3EaNPoG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3ipn9JLAPI5GUEo4y4jcoi"},"href":"https://api.spotify.com/v1/artists/3ipn9JLAPI5GUEo4y4jcoi","id":"3ipn9JLAPI5GUEo4y4jcoi","name":"Ludacris","type":"artist","uri":"spotify:artist:3ipn9JLAPI5GUEo4y4jcoi"}],"disc_number":1,"duration_ms":229472,"explicit":false,"external_ids":{"isrc":"USUM72109688"},"external_urls":{"spotify":"https://open.spotify.com/track/010basloOyV7QxUPzYx7IC"},"href":"https://api.spotify.com/v1/tracks/010basloOyV7QxUPzYx7IC","id":"010basloOyV7QxUPzYx7IC","is_local":false,"is_playable":true,"name":"Peaches (Remix) feat. Ludacris, Usher & Snoop Dogg","track_number":1,"type":"track","uri":"spotify:track:010basloOyV7QxUPzYx7IC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/7DjqzdD8MYtzgiJDGHltsp"},"href":"https://api.spotify.com/v1/albums/7DjqzdD8MYtzgiJDGHltsp","id":"7DjqzdD8MYtzgiJDGHltsp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739f05db24a0ce9b5d02b87408"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029f05db24a0ce9b5d02b87408"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519f05db24a0ce9b5d02b87408"}],"is_playable":true,"name":"Justice (Triple Chucks Deluxe)","release_date":"2021-03-26","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:7DjqzdD8MYtzgiJDGHltsp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":false,"external_ids":{"isrc":"USUM72102647"},"external_urls":{"spotify":"https://open.spotify.com/track/5SgOFwlzue4P3s2dLj6BJE"},"href":"https://api.spotify.com/v1/tracks/5SgOFwlzue4P3s2dLj6BJE","id":"5SgOFwlzue4P3s2dLj6BJE","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:5SgOFwlzue4P3s2dLj6BJE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"}],"external_urls":{"spotify":"https://open.spotify.com/album/5v2lj0w9VJIbjcUUKYLvlo"},"href":"https://api.spotify.com/v1/albums/5v2lj0w9VJIbjcUUKYLvlo","id":"5v2lj0w9VJIbjcUUKYLvlo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732dd4230bdcdfbc87c1ebc8b7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022dd4230bdcdfbc87c1ebc8b7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512dd4230bdcdfbc87c1ebc8b7"}],"is_playable":true,"name":"Justice (The Complete Edition)","release_date":"2021-10-08","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:5v2lj0w9VJIbjcUUKYLvlo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1uNFoZAHBGtllmzznpCI3s"},"href":"https://api.spotify.com/v1/artists/1uNFoZAHBGtllmzznpCI3s","id":"1uNFoZAHBGtllmzznpCI3s","name":"Synthetic Listener Bieber","type":"artist","uri":"spotify:artist:1uNFoZAHBGtllmzznpCI3s"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fxd5Ee7UefO4CUXgwJ7IP"},"href":"https://api.spotify.com/v1/artists/4fxd5Ee7UefO4CUXgwJ7IP","id":"4fxd5Ee7UefO4CUXgwJ7IP","name":"GIV\u0112ON","type":"artist","uri":"spotify:artist:4fxd5Ee7UefO4CUXgwJ7IP"}],"disc_number":1,"duration_ms":198081,"explicit":false,"external_ids":{"isrc":"USUM72102647"},"external_urls":{"spotify":"https://open.spotify.com/track/1G1txd10Y8F0diS2WKBagu"},"href":"https://api.spotify.com/v1/tracks/1G1txd10Y8F0diS2WKBagu","id":"1G1txd10Y8F0diS2WKBagu","is_local":false,"is_playable":true,"name":"Peaches (feat. Daniel Caesar & Giveon)","track_number":12,"type":"track","uri":"spotify:track:1G1txd10Y8F0diS2WKBagu"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Peaches%22+artist%3A%22Synthetic Listener+Bieber%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Freaks%22%20artist%3A%22French%20Montana%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vXTefBL93Dj5IqAWq6OTv"},"href":"https://api.spotify.com/v1/artists/6vXTefBL93Dj5IqAWq6OTv","id":"6vXTefBL93Dj5IqAWq6OTv","name":"French Montana","type":"artist","uri":"spotify:artist:6vXTefBL93Dj5IqAWq6OTv"}],"external_urls":{"spotify":"https://open.spotify.com/album/2Af2xpOLk0VzzJqmqtAW8T"},"href":"https://api.spotify.com/v1/albums/2Af2xpOLk0VzzJqmqtAW8T","id":"2Af2xpOLk0VzzJqmqtAW8T","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273646f83d175ae79b3747b6828"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02646f83d175ae79b3747b6828"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851646f83d175ae79b3747b6828"}],"is_playable":true,"name":"Excuse My French (Deluxe)","release_date":"2013-01-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2Af2xpOLk0VzzJqmqtAW8T"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vXTefBL93Dj5IqAWq6OTv"},"href":"https://api.spotify.com/v1/artists/6vXTefBL93Dj5IqAWq6OTv","id":"6vXTefBL93Dj5IqAWq6OTv","name":"French Montana","type":"artist","uri":"spotify:artist:6vXTefBL93Dj5IqAWq6OTv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0hCNtLu0JehylgoiP8L4Gh"},"href":"https://api.spotify.com/v1/artists/0hCNtLu0JehylgoiP8L4Gh","id":"0hCNtLu0JehylgoiP8L4Gh","name":"Nicki Minaj","type":"artist","uri":"spotify:artist:0hCNtLu0JehylgoiP8L4Gh"}],"disc_number":1,"duration_ms":181920,"explicit":true,"external_ids":{"isrc":"USUM71301190"},"external_urls":{"spotify":"https://open.spotify.com/track/0wpYoahTjbbM3gFwQWRBfL"},"href":"https://api.spotify.com/v1/tracks/0wpYoahTjbbM3gFwQWRBfL","id":"0wpYoahTjbbM3gFwQWRBfL","is_local":false,"is_playable":true,"name":"Freaks","track_number":11,"type":"track","uri":"spotify:track:0wpYoahTjbbM3gFwQWRBfL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vXTefBL93Dj5IqAWq6OTv"},"href":"https://api.spotify.com/v1/artists/6vXTefBL93Dj5IqAWq6OTv","id":"6vXTefBL93Dj5IqAWq6OTv","name":"French Montana","type":"artist","uri":"spotify:artist:6vXTefBL93Dj5IqAWq6OTv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Mg0YgcE9AYYuvid82Ppub"},"href":"https://api.spotify.com/v1/albums/4Mg0YgcE9AYYuvid82Ppub","id":"4Mg0YgcE9AYYuvid82Ppub","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aec00eba9e42dc2a451cb5a1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aec00eba9e42dc2a451cb5a1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aec00eba9e42dc2a451cb5a1"}],"is_playable":true,"name":"Excuse My French","release_date":"2013-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4Mg0YgcE9AYYuvid82Ppub"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vXTefBL93Dj5IqAWq6OTv"},"href":"https://api.spotify.com/v1/artists/6vXTefBL93Dj5IqAWq6OTv","id":"6vXTefBL93Dj5IqAWq6OTv","name":"French Montana","type":"artist","uri":"spotify:artist:6vXTefBL93Dj5IqAWq6OTv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0hCNtLu0JehylgoiP8L4Gh"},"href":"https://api.spotify.com/v1/artists/0hCNtLu0JehylgoiP8L4Gh","id":"0hCNtLu0JehylgoiP8L4Gh","name":"Nicki Minaj","type":"artist","uri":"spotify:artist:0hCNtLu0JehylgoiP8L4Gh"}],"disc_number":1,"duration_ms":181920,"explicit":true,"external_ids":{"isrc":"USUM71301190"},"external_urls":{"spotify":"https://open.spotify.com/track/5ssSOCKLR9HRTLFbBfAXJj"},"href":"https://api.spotify.com/v1/tracks/5ssSOCKLR9HRTLFbBfAXJj","id":"5ssSOCKLR9HRTLFbBfAXJj","is_local":false,"is_playable":true,"name":"Freaks","track_number":11,"type":"track","uri":"spotify:track:5ssSOCKLR9HRTLFbBfAXJj"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vXTefBL93Dj5IqAWq6OTv"},"href":"https://api.spotify.com/v1/artists/6vXTefBL93Dj5IqAWq6OTv","id":"6vXTefBL93Dj5IqAWq6OTv","name":"French Montana","type":"artist","uri":"spotify:artist:6vXTefBL93Dj5IqAWq6OTv"}],"external_urls":{"spotify":"https://open.spotify.com/album/1l3H0aPipDIi5XAbthkciZ"},"href":"https://api.spotify.com/v1/albums/1l3H0aPipDIi5XAbthkciZ","id":"1l3H0aPipDIi5XAbthkciZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734ae10236c438be23473974e5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024ae10236c438be23473974e5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514ae10236c438be23473974e5"}],"is_playable":true,"name":"Excuse My French (Deluxe 2.0)","release_date":"2013-05-21","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:1l3H0aPipDIi5XAbthkciZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vXTefBL93Dj5IqAWq6OTv"},"href":"https://api.spotify.com/v1/artists/6vXTefBL93Dj5IqAWq6OTv","id":"6vXTefBL93Dj5IqAWq6OTv","name":"French Montana","type":"artist","uri":"spotify:artist:6vXTefBL93Dj5IqAWq6OTv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0hCNtLu0JehylgoiP8L4Gh"},"href":"https://api.spotify.com/v1/artists/0hCNtLu0JehylgoiP8L4Gh","id":"0hCNtLu0JehylgoiP8L4Gh","name":"Nicki Minaj","type":"artist","uri":"spotify:artist:0hCNtLu0JehylgoiP8L4Gh"}],"disc_number":1,"duration_ms":181920,"explicit":true,"external_ids":{"isrc":"USUM71301190"},"external_urls":{"spotify":"https://open.spotify.com/track/0kUnqHL5u7Y566OcG5RiZ3"},"href":"https://api.spotify.com/v1/tracks/0kUnqHL5u7Y566OcG5RiZ3","id":"0kUnqHL5u7Y566OcG5RiZ3","is_local":false,"is_playable":true,"name":"Freaks","track_number":11,"type":"track","uri":"spotify:track:0kUnqHL5u7Y566OcG5RiZ3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IYk6BQrE0HkCOkdITNEUi"},"href":"https://api.spotify.com/v1/artists/0IYk6BQrE0HkCOkdITNEUi","id":"0IYk6BQrE0HkCOkdITNEUi","name":"DJ LILMAN","type":"artist","uri":"spotify:artist:0IYk6BQrE0HkCOkdITNEUi"}],"external_urls":{"spotify":"https://open.spotify.com/album/6C6azYK5QKSCcsEvYzjoDb"},"href":"https://api.spotify.com/v1/albums/6C6azYK5QKSCcsEvYzjoDb","id":"6C6azYK5QKSCcsEvYzjoDb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a88a3a13b5d5ff1405f578c1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a88a3a13b5d5ff1405f578c1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a88a3a13b5d5ff1405f578c1"}],"is_playable":true,"name":"Freaks (feat. French Montana)","release_date":"2013-05-28","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6C6azYK5QKSCcsEvYzjoDb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IYk6BQrE0HkCOkdITNEUi"},"href":"https://api.spotify.com/v1/artists/0IYk6BQrE0HkCOkdITNEUi","id":"0IYk6BQrE0HkCOkdITNEUi","name":"DJ LILMAN","type":"artist","uri":"spotify:artist:0IYk6BQrE0HkCOkdITNEUi"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6vXTefBL93Dj5IqAWq6OTv"},"href":"https://api.spotify.com/v1/artists/6vXTefBL93Dj5IqAWq6OTv","id":"6vXTefBL93Dj5IqAWq6OTv","name":"French Montana","type":"artist","uri":"spotify:artist:6vXTefBL93Dj5IqAWq6OTv"}],"disc_number":1,"duration_ms":120936,"explicit":false,"external_ids":{"isrc":"TCABO1334516"},"external_urls":{"spotify":"https://open.spotify.com/track/7aG5vy9CVLJPAo8cU5Fso6"},"href":"https://api.spotify.com/v1/tracks/7aG5vy9CVLJPAo8cU5Fso6","id":"7aG5vy9CVLJPAo8cU5Fso6","is_local":false,"is_playable":true,"name":"Freaks (feat. French Montana)","track_number":1,"type":"track","uri":"spotify:track:7aG5vy9CVLJPAo8cU5Fso6"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZyZWFrcyUyMiUyMGFydGlzdCUzQSUyMkZyZW5jaCUyME1vbnRhbmElMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ2WFRlZkJMOTNEajVJcUFXcTZPVHYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnZYVGVmQkw5M0RqNUlxQVdxNk9UdiIsImlkIjoiNnZYVGVmQkw5M0RqNUlxQVdxNk9UdiIsIm5hbWUiOiJGcmVuY2ggTW9udGFuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2dlhUZWZCTDkzRGo1SXFBV3E2T1R2In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkFmMnhwT0xrMFZ6ekpxbXF0QVc4VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJBZjJ4cE9MazBWenpKcW1xdEFXOFQiLCJpZCI6IjJBZjJ4cE9MazBWenpKcW1xdEFXOFQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jbw==", + "L2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2NDZmODNkMTc1YWU3OWIzNzQ3YjY4MjgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNjQ2ZjgzZDE3NWFlNzliMzc0N2I2ODI4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2NDZmODNkMTc1YWU3OWIzNzQ3YjY4MjgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRXhjdXNlIE15IEZyZW5jaCAoRGVsdXhlKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyQWYyeHBPTGswVnp6SnFtcXRBVzhUIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnZYVGVmQkw5M0RqNUlxQVdxNk9UdiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82dlhUZWZCTDkzRGo1SXFBV3E2T1R2IiwiaWQiOiI2dlhUZWZCTDkzRGo1SXFBV3E2T1R2IiwibmFtZSI6IkZyZW5jaCBNb250YW5hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ2WFRlZkJMOTNEajVJcUFXcTZPVHYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGhDTnRMdTBKZWh5bGdvaVA4TDRHaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8waENOdEx1MEplaHlsZ29pUDhMNEdoIiwiaWQiOiIwaENOdEx1MEplaHlsZ29pUDhMNEdoIiwibmFtZSI6Ik5pY2tpIE1pbmFqIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBoQ050THUwSmVoeWxnb2lQOEw0R2gifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTgxOTIwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzEzMDExOTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzB3cFlvYWhUamJiTTNnRndRV1JCZkwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wd3BZb2FoVGpiYk0zZ0Z3UVdSQmZMIiwiaWQiOiIwd3BZb2FoVGpiYk0zZ0Z3UVdSQmZMIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZyZWFrcyIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHdwWW9haFRqYg==", + "Yk0zZ0Z3UVdSQmZMIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ2WFRlZkJMOTNEajVJcUFXcTZPVHYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnZYVGVmQkw5M0RqNUlxQVdxNk9UdiIsImlkIjoiNnZYVGVmQkw5M0RqNUlxQVdxNk9UdiIsIm5hbWUiOiJGcmVuY2ggTW9udGFuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2dlhUZWZCTDkzRGo1SXFBV3E2T1R2In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNE1nMFlnY0U5QVlZdXZpZDgyUHB1YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRNZzBZZ2NFOUFZWXV2aWQ4MlBwdWIiLCJpZCI6IjRNZzBZZ2NFOUFZWXV2aWQ4MlBwdWIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYWVjMDBlYmE5ZTQyZGMyYTQ1MWNiNWExIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmFlYzAwZWJhOWU0MmRjMmE0NTFjYjVhMSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYWVjMDBlYmE5ZTQyZGMyYTQ1MWNiNWExIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkV4Y3VzZSBNeSBGcmVuY2giLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NE1nMFlnY0U5QVlZdXZpZDgyUHB1YiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ2WFRlZkJMOTNEajVJcUFXcTZPVHYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnZYVGVmQkw5M0RqNUlxQVdxNk9UdiIsImlkIjoiNnZYVGVmQkw5M0RqNUlxQVdxNk9UdiIsIm5hbWUiOiJGcmVuY2ggTW9udGFuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2dlhUZWZCTDkzRGo1SXFBV3E2T1R2In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBoQ050THUwSmVoeWxnb2lQOEw0R2gifSwiaHJlZiI6Imh0dA==", + "cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8waENOdEx1MEplaHlsZ29pUDhMNEdoIiwiaWQiOiIwaENOdEx1MEplaHlsZ29pUDhMNEdoIiwibmFtZSI6Ik5pY2tpIE1pbmFqIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBoQ050THUwSmVoeWxnb2lQOEw0R2gifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTgxOTIwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzEzMDExOTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVzc1NPQ0tMUjlIUlRMRmJCZkFYSmoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81c3NTT0NLTFI5SFJUTEZiQmZBWEpqIiwiaWQiOiI1c3NTT0NLTFI5SFJUTEZiQmZBWEpqIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZyZWFrcyIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXNzU09DS0xSOUhSVExGYkJmQVhKaiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82dlhUZWZCTDkzRGo1SXFBV3E2T1R2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ2WFRlZkJMOTNEajVJcUFXcTZPVHYiLCJpZCI6IjZ2WFRlZkJMOTNEajVJcUFXcTZPVHYiLCJuYW1lIjoiRnJlbmNoIE1vbnRhbmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnZYVGVmQkw5M0RqNUlxQVdxNk9UdiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFsM0gwYVBpcERJaTVYQWJ0aGtjaVoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xbDNIMGFQaXBESWk1WEFidGhrY2laIiwiaWQiOiIxbDNIMGFQaXBESWk1WEFidGhrY2laIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRhZTEwMjM2YzQzOGJlMjM0NzM5NzRlNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0YWUxMDIzNmM0MzhiZTIzNDczOTc0ZTUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRhZTEwMjM2YzQzOGJlMjM0NzM5NzRlNSJ9XSwiaQ==", + "c19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkV4Y3VzZSBNeSBGcmVuY2ggKERlbHV4ZSAyLjApIiwicmVsZWFzZV9kYXRlIjoiMjAxMy0wNS0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFsM0gwYVBpcERJaTVYQWJ0aGtjaVoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82dlhUZWZCTDkzRGo1SXFBV3E2T1R2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ2WFRlZkJMOTNEajVJcUFXcTZPVHYiLCJpZCI6IjZ2WFRlZkJMOTNEajVJcUFXcTZPVHYiLCJuYW1lIjoiRnJlbmNoIE1vbnRhbmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnZYVGVmQkw5M0RqNUlxQVdxNk9UdiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8waENOdEx1MEplaHlsZ29pUDhMNEdoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBoQ050THUwSmVoeWxnb2lQOEw0R2giLCJpZCI6IjBoQ050THUwSmVoeWxnb2lQOEw0R2giLCJuYW1lIjoiTmlja2kgTWluYWoiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGhDTnRMdTBKZWh5bGdvaVA4TDRHaCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODE5MjAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTMwMTE5MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMGtVbnFITDV1N1k1NjZPY0c1UmlaMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBrVW5xSEw1dTdZNTY2T2NHNVJpWjMiLCJpZCI6IjBrVW5xSEw1dTdZNTY2T2NHNVJpWjMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRnJlYWtzIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowa1VucUhMNXU3WTU2Nk9jRzVSaVozIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wSVlrNkJRckUwSGtDT2tkSVRORVVpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBJWWs2QlFyRTBIa0NPa2RJVE5FVWkiLCJpZCI6IjBJWWs2QlFyRTBIa0NPa2RJVE5FVWkiLCJuYW1lIg==", + "OiJESiBMSUxNQU4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MElZazZCUXJFMEhrQ09rZElUTkVVaSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZDNmF6WUs1UUtTQ2NzRXZZempvRGIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82QzZhellLNVFLU0Njc0V2WXpqb0RiIiwiaWQiOiI2QzZhellLNVFLU0Njc0V2WXpqb0RiIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2E4OGEzYTEzYjVkNWZmMTQwNWY1NzhjMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhODhhM2ExM2I1ZDVmZjE0MDVmNTc4YzEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWE4OGEzYTEzYjVkNWZmMTQwNWY1NzhjMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGcmVha3MgKGZlYXQuIEZyZW5jaCBNb250YW5hKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDUtMjgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZDNmF6WUs1UUtTQ2NzRXZZempvRGIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wSVlrNkJRckUwSGtDT2tkSVRORVVpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBJWWs2QlFyRTBIa0NPa2RJVE5FVWkiLCJpZCI6IjBJWWs2QlFyRTBIa0NPa2RJVE5FVWkiLCJuYW1lIjoiREogTElMTUFOIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBJWWs2QlFyRTBIa0NPa2RJVE5FVWkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnZYVGVmQkw5M0RqNUlxQVdxNk9UdiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82dlhUZWZCTDkzRGo1SXFBV3E2T1R2IiwiaWQiOiI2dlhUZWZCTDkzRGo1SXFBV3E2T1R2IiwibmFtZSI6IkZyZW5jaCBNb250YW5hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ2WFRlZkJMOTNEajVJcUFXcTZPVHYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTIwOTM2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6ew==", + "ImlzcmMiOiJUQ0FCTzEzMzQ1MTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdhRzV2eTlDVkxKUEFvOGNVNUZzbzYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83YUc1dnk5Q1ZMSlBBbzhjVTVGc282IiwiaWQiOiI3YUc1dnk5Q1ZMSlBBbzhjVTVGc282IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZyZWFrcyAoZmVhdC4gRnJlbmNoIE1vbnRhbmEpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdhRzV2eTlDVkxKUEFvOGNVNUZzbzYifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Freaks%22+artist%3A%22French+Montana%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk5pZ2h0cyUyMiUyMGFydGlzdCUzQSUyMkZyYW5rJTIwT2NlYW4lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJoOTNwWnEwZTdrNXlmNGR5d2xrcE0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmg5M3BacTBlN2s1eWY0ZHl3bGtwTSIsImlkIjoiMmg5M3BacTBlN2s1eWY0ZHl3bGtwTSIsIm5hbWUiOiJGcmFuayBPY2VhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyaDkzcFpxMGU3azV5ZjRkeXdsa3BNIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM21INnF3SXk5Y3JxMEk5WVFiT3VEZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNtSDZxd0l5OWNycTBJOVlRYk91RGYiLCJpZCI6IjNtSDZxd0l5OWNycTBJOVlRYk91RGYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZQ==", + "L2FiNjc2MTZkMDAwMGIyNzNjNTY0OWFkZDA3ZWQzNzIwYmU5ZDU1MjYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzU2NDlhZGQwN2VkMzcyMGJlOWQ1NTI2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNTY0OWFkZDA3ZWQzNzIwYmU5ZDU1MjYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmxvbmRlIiwicmVsZWFzZV9kYXRlIjoiMjAxNi0wOC0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNtSDZxd0l5OWNycTBJOVlRYk91RGYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yaDkzcFpxMGU3azV5ZjRkeXdsa3BNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJoOTNwWnEwZTdrNXlmNGR5d2xrcE0iLCJpZCI6IjJoOTNwWnEwZTdrNXlmNGR5d2xrcE0iLCJuYW1lIjoiRnJhbmsgT2NlYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mmg5M3BacTBlN2s1eWY0ZHl3bGtwTSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDcxNTEsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaNUM4MTYwMDAwOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2Vxb3FHa0t3Z09hV05OSHg5MHVFWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdlcW9xR2tLd2dPYVdOTkh4OTB1RVoiLCJpZCI6IjdlcW9xR2tLd2dPYVdOTkh4OTB1RVoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmlnaHRzIiwidHJhY2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdlcW9xR2tLd2dPYVdOTkh4OTB1RVoifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Nights%22+artist%3A%22Frank+Ocean%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22HUMBLE.%22%20artist%3A%22Kendrick%20Lamar%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/4eLPsYPBmXABThSJ821sqY"},"href":"https://api.spotify.com/v1/albums/4eLPsYPBmXABThSJ821sqY","id":"4eLPsYPBmXABThSJ821sqY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738b52c6b9bc4e43d873869699"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028b52c6b9bc4e43d873869699"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518b52c6b9bc4e43d873869699"}],"is_playable":true,"name":"DAMN.","release_date":"2017-04-14","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4eLPsYPBmXABThSJ821sqY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":177000,"explicit":true,"external_ids":{"isrc":"USUM71703085"},"external_urls":{"spotify":"https://open.spotify.com/track/7KXjTSCq5nL1LoYtL7XAwS"},"href":"https://api.spotify.com/v1/tracks/7KXjTSCq5nL1LoYtL7XAwS","id":"7KXjTSCq5nL1LoYtL7XAwS","is_local":false,"is_playable":true,"name":"HUMBLE.","track_number":8,"type":"track","uri":"spotify:track:7KXjTSCq5nL1LoYtL7XAwS"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5he5w2lnU9x7JFhnwcekXX"},"href":"https://api.spotify.com/v1/artists/5he5w2lnU9x7JFhnwcekXX","id":"5he5w2lnU9x7JFhnwcekXX","name":"Skrillex","type":"artist","uri":"spotify:artist:5he5w2lnU9x7JFhnwcekXX"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/1X4aaOIXvs6gWtQZQpln4V"},"href":"https://api.spotify.com/v1/albums/1X4aaOIXvs6gWtQZQpln4V","id":"1X4aaOIXvs6gWtQZQpln4V","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bd01ceabd584855b2edd838d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bd01ceabd584855b2edd838d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bd01ceabd584855b2edd838d"}],"is_playable":true,"name":"HUMBLE. (SKRILLEX REMIX)","release_date":"2017-09-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1X4aaOIXvs6gWtQZQpln4V"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5he5w2lnU9x7JFhnwcekXX"},"href":"https://api.spotify.com/v1/artists/5he5w2lnU9x7JFhnwcekXX","id":"5he5w2lnU9x7JFhnwcekXX","name":"Skrillex","type":"artist","uri":"spotify:artist:5he5w2lnU9x7JFhnwcekXX"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":156800,"explicit":true,"external_ids":{"isrc":"USUM71710562"},"external_urls":{"spotify":"https://open.spotify.com/track/65ES1qwOB577ZnTkizMXJJ"},"href":"https://api.spotify.com/v1/tracks/65ES1qwOB577ZnTkizMXJJ","id":"65ES1qwOB577ZnTkizMXJJ","is_local":false,"is_playable":true,"name":"HUMBLE. - SKRILLEX REMIX","track_number":1,"type":"track","uri":"spotify:track:65ES1qwOB577ZnTkizMXJJ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/0bLXUfNT34mna9aXq8ex68"},"href":"https://api.spotify.com/v1/albums/0bLXUfNT34mna9aXq8ex68","id":"0bLXUfNT34mna9aXq8ex68","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732171b967bef683ab0eaf12e9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022171b967bef683ab0eaf12e9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512171b967bef683ab0eaf12e9"}],"is_playable":true,"name":"DAMN.","release_date":"2017-04-13","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:0bLXUfNT34mna9aXq8ex68"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":177000,"explicit":false,"external_ids":{"isrc":"USUM71703150"},"external_urls":{"spotify":"https://open.spotify.com/track/131OLY5J8XyfGuSjXRiTRM"},"href":"https://api.spotify.com/v1/tracks/131OLY5J8XyfGuSjXRiTRM","id":"131OLY5J8XyfGuSjXRiTRM","is_local":false,"is_playable":true,"name":"HUMBLE.","track_number":8,"type":"track","uri":"spotify:track:131OLY5J8XyfGuSjXRiTRM"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/4alcGHjstaALJHHiljfy3H"},"href":"https://api.spotify.com/v1/albums/4alcGHjstaALJHHiljfy3H","id":"4alcGHjstaALJHHiljfy3H","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273add9eb25744782c3717c9368"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02add9eb25744782c3717c9368"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851add9eb25744782c3717c9368"}],"is_playable":true,"name":"DAMN. COLLECTORS EDITION.","release_date":"2017-12-08","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4alcGHjstaALJHHiljfy3H"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":177000,"explicit":true,"external_ids":{"isrc":"USUM71703085"},"external_urls":{"spotify":"https://open.spotify.com/track/0gvQoTWRxsW5Rd7KgPp0u3"},"href":"https://api.spotify.com/v1/tracks/0gvQoTWRxsW5Rd7KgPp0u3","id":"0gvQoTWRxsW5Rd7KgPp0u3","is_local":false,"is_playable":true,"name":"HUMBLE.","track_number":7,"type":"track","uri":"spotify:track:0gvQoTWRxsW5Rd7KgPp0u3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/1LLOGSa5ehwSWrPg1Qc3Vg"},"href":"https://api.spotify.com/v1/albums/1LLOGSa5ehwSWrPg1Qc3Vg","id":"1LLOGSa5ehwSWrPg1Qc3Vg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732fad9364b7dfca0c2ede0da4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022fad9364b7dfca0c2ede0da4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512fad9364b7dfca0c2ede0da4"}],"is_playable":true,"name":"DAMN. COLLECTORS EDITION.","release_date":"2017-12-08","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1LLOGSa5ehwSWrPg1Qc3Vg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":177000,"explicit":false,"external_ids":{"isrc":"USUM71703150"},"external_urls":{"spotify":"https://open.spotify.com/track/3UHm2lhVeuywLXRAXEdUYW"},"href":"https://api.spotify.com/v1/tracks/3UHm2lhVeuywLXRAXEdUYW","id":"3UHm2lhVeuywLXRAXEdUYW","is_local":false,"is_playable":true,"name":"HUMBLE.","track_number":7,"type":"track","uri":"spotify:track:3UHm2lhVeuywLXRAXEdUYW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1BpfvEJYvNSqGs5fvZ7fTi"},"href":"https://api.spotify.com/v1/albums/1BpfvEJYvNSqGs5fvZ7fTi","id":"1BpfvEJYvNSqGs5fvZ7fTi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736fdf00d7a01a3357d915b059"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026fdf00d7a01a3357d915b059"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516fdf00d7a01a3357d915b059"}],"is_playable":true,"name":"Shut Up Lets Dance (Vol. II)","release_date":"2018-02-09","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:1BpfvEJYvNSqGs5fvZ7fTi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5he5w2lnU9x7JFhnwcekXX"},"href":"https://api.spotify.com/v1/artists/5he5w2lnU9x7JFhnwcekXX","id":"5he5w2lnU9x7JFhnwcekXX","name":"Skrillex","type":"artist","uri":"spotify:artist:5he5w2lnU9x7JFhnwcekXX"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":156800,"explicit":true,"external_ids":{"isrc":"USUM71710562"},"external_urls":{"spotify":"https://open.spotify.com/track/0WtRoUyfurFvbPBqijIuSD"},"href":"https://api.spotify.com/v1/tracks/0WtRoUyfurFvbPBqijIuSD","id":"0WtRoUyfurFvbPBqijIuSD","is_local":false,"is_playable":true,"name":"HUMBLE. - SKRILLEX REMIX","track_number":30,"type":"track","uri":"spotify:track:0WtRoUyfurFvbPBqijIuSD"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0LpITwRJ2IlzdPLGZL7W2a"},"href":"https://api.spotify.com/v1/albums/0LpITwRJ2IlzdPLGZL7W2a","id":"0LpITwRJ2IlzdPLGZL7W2a","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27309867cf5c05d177de7aaed5b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0209867cf5c05d177de7aaed5b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485109867cf5c05d177de7aaed5b"}],"is_playable":true,"name":"Best Of 2017 Hip Hop","release_date":"2017-12-15","release_date_precision":"day","total_tracks":44,"type":"album","uri":"spotify:album:0LpITwRJ2IlzdPLGZL7W2a"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":177640,"explicit":true,"external_ids":{"isrc":"USUM71703085"},"external_urls":{"spotify":"https://open.spotify.com/track/2DlQcKIzEdIKu3adk0xVLD"},"href":"https://api.spotify.com/v1/tracks/2DlQcKIzEdIKu3adk0xVLD","id":"2DlQcKIzEdIKu3adk0xVLD","is_local":false,"is_playable":true,"name":"HUMBLE.","track_number":1,"type":"track","uri":"spotify:track:2DlQcKIzEdIKu3adk0xVLD"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/197YY02cK93Yjrtpa1FrMY"},"href":"https://api.spotify.com/v1/albums/197YY02cK93Yjrtpa1FrMY","id":"197YY02cK93Yjrtpa1FrMY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b11ac9a6b727e6e367a4dcd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b11ac9a6b727e6e367a4dcd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b11ac9a6b727e6e367a4dcd"}],"is_playable":true,"name":"Best Of 2017","release_date":"2017-12-08","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:197YY02cK93Yjrtpa1FrMY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":177600,"explicit":true,"external_ids":{"isrc":"USUM71703085"},"external_urls":{"spotify":"https://open.spotify.com/track/1lhED7qvDKw5nMFEyJ2F4I"},"href":"https://api.spotify.com/v1/tracks/1lhED7qvDKw5nMFEyJ2F4I","id":"1lhED7qvDKw5nMFEyJ2F4I","is_local":false,"is_playable":true,"name":"HUMBLE.","track_number":2,"type":"track","uri":"spotify:track:1lhED7qvDKw5nMFEyJ2F4I"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1wBxZOPDaOGA8AWidjN0RE"},"href":"https://api.spotify.com/v1/albums/1wBxZOPDaOGA8AWidjN0RE","id":"1wBxZOPDaOGA8AWidjN0RE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27395ab038f5ac56e8e3ca9cc43"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0295ab038f5ac56e8e3ca9cc43"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485195ab038f5ac56e8e3ca9cc43"}],"is_playable":true,"name":"Hip Hop Hit List (Vol. 2)","release_date":"2017-06-09","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:1wBxZOPDaOGA8AWidjN0RE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":177700,"explicit":true,"external_ids":{"isrc":"USUM71703085"},"external_urls":{"spotify":"https://open.spotify.com/track/7p5BRzXQiad247H9FdRkqd"},"href":"https://api.spotify.com/v1/tracks/7p5BRzXQiad247H9FdRkqd","id":"7p5BRzXQiad247H9FdRkqd","is_local":false,"is_playable":true,"name":"HUMBLE.","track_number":1,"type":"track","uri":"spotify:track:7p5BRzXQiad247H9FdRkqd"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkhVTUJMRS4lMjIlMjBhcnRpc3QlM0ElMjJLZW5kcmljayUyMExhbWFyJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo5LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRlTFBzWVBCbVhBQlRoU0o4MjFzcVkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80ZUxQc1lQQm1YQUJUaFNKODIxc3FZIiwiaWQiOiI0ZUxQc1lQQm1YQUJUaFNKODIxc3FZIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzhiNTJjNmI5YmM0ZTQzZDg3Mzg2OTY5OSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4YjUyYzZiOWJjNGU0M2Q4NzM4Njk2OTkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MThiNTJjNmI5YmM0ZTQzZDg3Mzg2OTY5OSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEQU1OLiIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDQtMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0ZUxQc1lQQm1YQUJUaFNKODIxc3FZIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwiaWQiOiIyWVp5TG9MOE4wV2I5eEJ0MU5oWg==", + "V2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzcwMDAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTcwMzA4NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN0tYalRTQ3E1bkwxTG9ZdEw3WEF3UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdLWGpUU0NxNW5MMUxvWXRMN1hBd1MiLCJpZCI6IjdLWGpUU0NxNW5MMUxvWXRMN1hBd1MiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSFVNQkxFLiIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3S1hqVFNDcTVuTDFMb1l0TDdYQXdTIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81aGU1dzJsblU5eDdKRmhud2Nla1hYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVoZTV3MmxuVTl4N0pGaG53Y2VrWFgiLCJpZCI6IjVoZTV3MmxuVTl4N0pGaG53Y2VrWFgiLCJuYW1lIjoiU2tyaWxsZXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWhlNXcybG5VOXg3SkZobndjZWtYWCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFYNGFhT0lYdnM2Z1d0UVpRcGxuNFYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xWDRhYU9JWHZzNmdXdFFaUXBsbjRWIiwiaWQiOiIxWDRhYU9JWHZzNmdXdFFaUXBsbjRWIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2JkMDFjZWFiZDU4NDg1NWIyZWRkODM4ZCJ9LHsiaGVpZ2h0IjozMDAsIg==", + "d2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJkMDFjZWFiZDU4NDg1NWIyZWRkODM4ZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYmQwMWNlYWJkNTg0ODU1YjJlZGQ4MzhkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhVTUJMRS4gKFNLUklMTEVYIFJFTUlYKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDktMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFYNGFhT0lYdnM2Z1d0UVpRcGxuNFYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81aGU1dzJsblU5eDdKRmhud2Nla1hYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVoZTV3MmxuVTl4N0pGaG53Y2VrWFgiLCJpZCI6IjVoZTV3MmxuVTl4N0pGaG53Y2VrWFgiLCJuYW1lIjoiU2tyaWxsZXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWhlNXcybG5VOXg3SkZobndjZWtYWCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTY4MDAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTcxMDU2MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNjVFUzFxd09CNTc3Wm5Ua2l6TVhKSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzY1RVMxcXdPQjU3N1puVGtpek1YSkoiLCJpZCI6IjY1RVMxcXdPQjU3N1puVGtpek1YSkoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSFVNQkxFLiAtIFNLUklMTEVYIFJFTUlYIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjY1RVMxcXdPQjU3N1puVGtpek1YSkoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdA==", + "cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBiTFhVZk5UMzRtbmE5YVhxOGV4NjgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wYkxYVWZOVDM0bW5hOWFYcThleDY4IiwiaWQiOiIwYkxYVWZOVDM0bW5hOWFYcThleDY4IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzIxNzFiOTY3YmVmNjgzYWIwZWFmMTJlOSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyMTcxYjk2N2JlZjY4M2FiMGVhZjEyZTkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTIxNzFiOTY3YmVmNjgzYWIwZWFmMTJlOSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEQU1OLiIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDQtMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowYkxYVWZOVDM0bW5hOWFYcThleDY4In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwiaWQiOiIyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwibmFtZSI6IktlbmRyaWNrIExhbWFyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc3MDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxNzAzMTUwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xMzFPTFk1Sg==", + "OFh5Zkd1U2pYUmlUUk0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xMzFPTFk1SjhYeWZHdVNqWFJpVFJNIiwiaWQiOiIxMzFPTFk1SjhYeWZHdVNqWFJpVFJNIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhVTUJMRS4iLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MTMxT0xZNUo4WHlmR3VTalhSaVRSTSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRhbGNHSGpzdGFBTEpISGlsamZ5M0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80YWxjR0hqc3RhQUxKSEhpbGpmeTNIIiwiaWQiOiI0YWxjR0hqc3RhQUxKSEhpbGpmeTNIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FkZDllYjI1NzQ0NzgyYzM3MTdjOTM2OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhZGQ5ZWIyNTc0NDc4MmMzNzE3YzkzNjgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFkZDllYjI1NzQ0NzgyYzM3MTdjOTM2OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEQU1OLiBDT0xMRUNUT1JTIEVESVRJT04uIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0xMi0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRhbGNHSGpzdGFBTEpISGlsamZ5M0gifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLw==", + "MllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsImlkIjoiMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsIm5hbWUiOiJLZW5kcmljayBMYW1hciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3NzAwMCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxNzAzMDg1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wZ3ZRb1RXUnhzVzVSZDdLZ1BwMHUzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGd2UW9UV1J4c1c1UmQ3S2dQcDB1MyIsImlkIjoiMGd2UW9UV1J4c1c1UmQ3S2dQcDB1MyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIVU1CTEUuIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBndlFvVFdSeHNXNVJkN0tnUHAwdTMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwiaWQiOiIyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwibmFtZSI6IktlbmRyaWNrIExhbWFyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xTExPR1NhNWVod1NXclBnMVFjM1ZnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUxMT0dTYTVlaHdTV3JQZzFRYzNWZyIsImlkIjoiMUxMT0dTYTVlaHdTV3JQZzFRYzNWZyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyZmFkOTM2NGI3ZGZjYTBjMmVkZTBkYTQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmZhZDkzNjRiN2RmY2EwYzJlZGUwZGE0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyZmFkOTM2NGI3ZGZjYTBjMmVkZTBkYTQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiREFNTg==", + "LiBDT0xMRUNUT1JTIEVESVRJT04uIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0xMi0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFMTE9HU2E1ZWh3U1dyUGcxUWMzVmcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzcwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzE3MDMxNTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNVSG0ybGhWZXV5d0xYUkFYRWRVWVcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zVUhtMmxoVmV1eXdMWFJBWEVkVVlXIiwiaWQiOiIzVUhtMmxoVmV1eXdMWFJBWEVkVVlXIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhVTUJMRS4iLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M1VIbTJsaFZldXl3TFhSQVhFZFVZVyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xQnBmdkVKWXZOU3FHczVmdlo3ZlRpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUJwZnZFSll2TlNxR3M1ZnZaN2ZUaSIsImlkIjoiMUJwZnZFSll2TlNxR3M1ZnZaN2ZUaSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIg==", + "OjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZmZGYwMGQ3YTAxYTMzNTdkOTE1YjA1OSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2ZmRmMDBkN2EwMWEzMzU3ZDkxNWIwNTkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZmZGYwMGQ3YTAxYTMzNTdkOTE1YjA1OSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTaHV0IFVwIExldHMgRGFuY2UgKFZvbC4gSUkpIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0wMi0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFCcGZ2RUpZdk5TcUdzNWZ2WjdmVGkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81aGU1dzJsblU5eDdKRmhud2Nla1hYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVoZTV3MmxuVTl4N0pGaG53Y2VrWFgiLCJpZCI6IjVoZTV3MmxuVTl4N0pGaG53Y2VrWFgiLCJuYW1lIjoiU2tyaWxsZXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWhlNXcybG5VOXg3SkZobndjZWtYWCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTY4MDAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTcxMDU2MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMFd0Um9VeWZ1ckZ2YlBCcWlqSXVTRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBXdFJvVXlmdXJGdmJQQnFpakl1U0QiLCJpZCI6IjBXdFJvVXlmdXJGdmJQQnFpakl1U0QiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSFVNQkxFLiAtIFNLUklMTEVYIFJFTUlYIiwidHJhY2tfbnVtYmVyIjozMA==", + "LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBXdFJvVXlmdXJGdmJQQnFpakl1U0QifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMExwSVR3UkoySWx6ZFBMR1pMN1cyYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBMcElUd1JKMklsemRQTEdaTDdXMmEiLCJpZCI6IjBMcElUd1JKMklsemRQTEdaTDdXMmEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDk4NjdjZjVjMDVkMTc3ZGU3YWFlZDViIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA5ODY3Y2Y1YzA1ZDE3N2RlN2FhZWQ1YiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDk4NjdjZjVjMDVkMTc3ZGU3YWFlZDViIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlc3QgT2YgMjAxNyBIaXAgSG9wIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0xMi0xNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBMcElUd1JKMklsemRQTEdaTDdXMmEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzc2NDAsIg==", + "ZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxNzAzMDg1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yRGxRY0tJekVkSUt1M2FkazB4VkxEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMkRsUWNLSXpFZElLdTNhZGsweFZMRCIsImlkIjoiMkRsUWNLSXpFZElLdTNhZGsweFZMRCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIVU1CTEUuIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJEbFFjS0l6RWRJS3UzYWRrMHhWTEQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMTk3WVkwMmNLOTNZanJ0cGExRnJNWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzE5N1lZMDJjSzkzWWpydHBhMUZyTVkiLCJpZCI6IjE5N1lZMDJjSzkzWWpydHBhMUZyTVkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNWIxMWFjOWE2YjcyN2U2ZTM2N2E0ZGNkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjViMTFhYzlhNmI3MjdlNmUzNjdhNGRjZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNWIxMWFjOWE2YjcyN2U2ZTM2N2E0ZGNkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlc3QgT2YgMjAxNyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMTItMDgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1MCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxOTdZWTAyY0s5M1lqcnRwYTFGck1ZIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybA==", + "cyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzc2MDAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTcwMzA4NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMWxoRUQ3cXZES3c1bk1GRXlKMkY0SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFsaEVEN3F2REt3NW5NRkV5SjJGNEkiLCJpZCI6IjFsaEVEN3F2REt3NW5NRkV5SjJGNEkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSFVNQkxFLiIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxbGhFRDdxdkRLdzVuTUZFeUoyRjRJIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzF3QnhaT1BEYU9HQThBV2lkak4wUkUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xd0J4Wk9QRGFPR0E4QVdpZGpOMFJFIiwiaWQiOiIxd0J4Wk9QRGFPR0E4QVdpZGpOMFJFIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzk1YWIwMzhmNWFjNTZlOGUzY2E5Y2M0MyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5NWFiMDM4ZjVhYzU2ZThlM2NhOWNjNDMifSx7ImhlaWdodA==", + "Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOTVhYjAzOGY1YWM1NmU4ZTNjYTljYzQzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhpcCBIb3AgSGl0IExpc3QgKFZvbC4gMikiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA2LTA5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXdCeFpPUERhT0dBOEFXaWRqTjBSRSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsImlkIjoiMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsIm5hbWUiOiJLZW5kcmljayBMYW1hciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3NzcwMCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxNzAzMDg1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83cDVCUnpYUWlhZDI0N0g5RmRSa3FkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN3A1QlJ6WFFpYWQyNDdIOUZkUmtxZCIsImlkIjoiN3A1QlJ6WFFpYWQyNDdIOUZkUmtxZCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIVU1CTEUuIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdwNUJSelhRaWFkMjQ3SDlGZFJrcWQifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22HUMBLE.%22+artist%3A%22Kendrick+Lamar%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Money%20Trees%22%20artist%3A%22Kendrick%20Lamar%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Oq3mWfexhsjUh0aNNBB5u"},"href":"https://api.spotify.com/v1/albums/0Oq3mWfexhsjUh0aNNBB5u","id":"0Oq3mWfexhsjUh0aNNBB5u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732cd55246d935a8a77cb4859e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022cd55246d935a8a77cb4859e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512cd55246d935a8a77cb4859e"}],"is_playable":true,"name":"good kid, m.A.A.d city","release_date":"2012","release_date_precision":"year","total_tracks":14,"type":"album","uri":"spotify:album:0Oq3mWfexhsjUh0aNNBB5u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28ExwzUQsvgJooOI0X1mr3"},"href":"https://api.spotify.com/v1/artists/28ExwzUQsvgJooOI0X1mr3","id":"28ExwzUQsvgJooOI0X1mr3","name":"Jay Rock","type":"artist","uri":"spotify:artist:28ExwzUQsvgJooOI0X1mr3"}],"disc_number":1,"duration_ms":386906,"explicit":true,"external_ids":{"isrc":"USUM71210785"},"external_urls":{"spotify":"https://open.spotify.com/track/74tLlkN3rgVzRqQJgPfink"},"href":"https://api.spotify.com/v1/tracks/74tLlkN3rgVzRqQJgPfink","id":"74tLlkN3rgVzRqQJgPfink","is_local":false,"is_playable":true,"name":"Money Trees","track_number":5,"type":"track","uri":"spotify:track:74tLlkN3rgVzRqQJgPfink"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/748dZDqSZy6aPXKcI9H80u"},"href":"https://api.spotify.com/v1/albums/748dZDqSZy6aPXKcI9H80u","id":"748dZDqSZy6aPXKcI9H80u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27378de8b28de36a74afc0348b5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0278de8b28de36a74afc0348b5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485178de8b28de36a74afc0348b5"}],"is_playable":true,"name":"good kid, m.A.A.d city (Deluxe)","release_date":"2012-10-22","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:748dZDqSZy6aPXKcI9H80u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28ExwzUQsvgJooOI0X1mr3"},"href":"https://api.spotify.com/v1/artists/28ExwzUQsvgJooOI0X1mr3","id":"28ExwzUQsvgJooOI0X1mr3","name":"Jay Rock","type":"artist","uri":"spotify:artist:28ExwzUQsvgJooOI0X1mr3"}],"disc_number":1,"duration_ms":386906,"explicit":true,"external_ids":{"isrc":"USUM71210785"},"external_urls":{"spotify":"https://open.spotify.com/track/0UtnpKaReKUg2GquaSxCyD"},"href":"https://api.spotify.com/v1/tracks/0UtnpKaReKUg2GquaSxCyD","id":"0UtnpKaReKUg2GquaSxCyD","is_local":false,"is_playable":true,"name":"Money Trees","track_number":5,"type":"track","uri":"spotify:track:0UtnpKaReKUg2GquaSxCyD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7a9KRWdaSZktpGGnWndzbC"},"href":"https://api.spotify.com/v1/artists/7a9KRWdaSZktpGGnWndzbC","id":"7a9KRWdaSZktpGGnWndzbC","name":"Black Hippy","type":"artist","uri":"spotify:artist:7a9KRWdaSZktpGGnWndzbC"}],"external_urls":{"spotify":"https://open.spotify.com/album/7ql2A3kwa0MUy2vH2nMf6d"},"href":"https://api.spotify.com/v1/albums/7ql2A3kwa0MUy2vH2nMf6d","id":"7ql2A3kwa0MUy2vH2nMf6d","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dd1e5c4720d00722fa0cd3dc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dd1e5c4720d00722fa0cd3dc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dd1e5c4720d00722fa0cd3dc"}],"is_playable":true,"name":"Black Hippy 2","release_date":"2014-09-15","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:7ql2A3kwa0MUy2vH2nMf6d"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7a9KRWdaSZktpGGnWndzbC"},"href":"https://api.spotify.com/v1/artists/7a9KRWdaSZktpGGnWndzbC","id":"7a9KRWdaSZktpGGnWndzbC","name":"Black Hippy","type":"artist","uri":"spotify:artist:7a9KRWdaSZktpGGnWndzbC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0g9vAlRPK9Gt3FKCekk4TW"},"href":"https://api.spotify.com/v1/artists/0g9vAlRPK9Gt3FKCekk4TW","id":"0g9vAlRPK9Gt3FKCekk4TW","name":"Ab-Soul","type":"artist","uri":"spotify:artist:0g9vAlRPK9Gt3FKCekk4TW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28ExwzUQsvgJooOI0X1mr3"},"href":"https://api.spotify.com/v1/artists/28ExwzUQsvgJooOI0X1mr3","id":"28ExwzUQsvgJooOI0X1mr3","name":"Jay Rock","type":"artist","uri":"spotify:artist:28ExwzUQsvgJooOI0X1mr3"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5IcR3N7QB1j6KBL8eImZ8m"},"href":"https://api.spotify.com/v1/artists/5IcR3N7QB1j6KBL8eImZ8m","id":"5IcR3N7QB1j6KBL8eImZ8m","name":"ScHoolboy Q","type":"artist","uri":"spotify:artist:5IcR3N7QB1j6KBL8eImZ8m"}],"disc_number":1,"duration_ms":395613,"explicit":false,"external_ids":{"isrc":"FR5R00904289"},"external_urls":{"spotify":"https://open.spotify.com/track/2Y7gsy3svMkJb1iaSvAgyv"},"href":"https://api.spotify.com/v1/tracks/2Y7gsy3svMkJb1iaSvAgyv","id":"2Y7gsy3svMkJb1iaSvAgyv","is_local":false,"is_playable":true,"name":"Money Trees","track_number":6,"type":"track","uri":"spotify:track:2Y7gsy3svMkJb1iaSvAgyv"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/0E47vczx9XVds1Lr2Y8rze"},"href":"https://api.spotify.com/v1/albums/0E47vczx9XVds1Lr2Y8rze","id":"0E47vczx9XVds1Lr2Y8rze","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f6381af6ad695ef74de8ce7b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f6381af6ad695ef74de8ce7b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f6381af6ad695ef74de8ce7b"}],"is_playable":true,"name":"good kid, m.A.A.d city","release_date":"2012","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:0E47vczx9XVds1Lr2Y8rze"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28ExwzUQsvgJooOI0X1mr3"},"href":"https://api.spotify.com/v1/artists/28ExwzUQsvgJooOI0X1mr3","id":"28ExwzUQsvgJooOI0X1mr3","name":"Jay Rock","type":"artist","uri":"spotify:artist:28ExwzUQsvgJooOI0X1mr3"}],"disc_number":1,"duration_ms":386906,"explicit":false,"external_ids":{"isrc":"USUM71211179"},"external_urls":{"spotify":"https://open.spotify.com/track/16SIvLDCFALvBDTmepJMIA"},"href":"https://api.spotify.com/v1/tracks/16SIvLDCFALvBDTmepJMIA","id":"16SIvLDCFALvBDTmepJMIA","is_local":false,"is_playable":true,"name":"Money Trees","track_number":5,"type":"track","uri":"spotify:track:16SIvLDCFALvBDTmepJMIA"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0zr6rTmFdN2gRgaTnqdwF4"},"href":"https://api.spotify.com/v1/albums/0zr6rTmFdN2gRgaTnqdwF4","id":"0zr6rTmFdN2gRgaTnqdwF4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732f8f8fd3a353bd6b4d0ae732"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022f8f8fd3a353bd6b4d0ae732"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512f8f8fd3a353bd6b4d0ae732"}],"is_playable":true,"name":"Hip Hop Motivation","release_date":"2025-03-14","release_date_precision":"day","total_tracks":76,"type":"album","uri":"spotify:album:0zr6rTmFdN2gRgaTnqdwF4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28ExwzUQsvgJooOI0X1mr3"},"href":"https://api.spotify.com/v1/artists/28ExwzUQsvgJooOI0X1mr3","id":"28ExwzUQsvgJooOI0X1mr3","name":"Jay Rock","type":"artist","uri":"spotify:artist:28ExwzUQsvgJooOI0X1mr3"}],"disc_number":1,"duration_ms":386906,"explicit":true,"external_ids":{"isrc":"USUM71210785"},"external_urls":{"spotify":"https://open.spotify.com/track/5YYkY1m2W5vY79eFffmOnC"},"href":"https://api.spotify.com/v1/tracks/5YYkY1m2W5vY79eFffmOnC","id":"5YYkY1m2W5vY79eFffmOnC","is_local":false,"is_playable":true,"name":"Money Trees","track_number":2,"type":"track","uri":"spotify:track:5YYkY1m2W5vY79eFffmOnC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2K40eAlu5DdZeKmGvMIsvu"},"href":"https://api.spotify.com/v1/albums/2K40eAlu5DdZeKmGvMIsvu","id":"2K40eAlu5DdZeKmGvMIsvu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b905cf0e6aa501a350db19a0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b905cf0e6aa501a350db19a0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b905cf0e6aa501a350db19a0"}],"is_playable":true,"name":"Skateboard & Skating Vibes","release_date":"2025-05-09","release_date_precision":"day","total_tracks":56,"type":"album","uri":"spotify:album:2K40eAlu5DdZeKmGvMIsvu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28ExwzUQsvgJooOI0X1mr3"},"href":"https://api.spotify.com/v1/artists/28ExwzUQsvgJooOI0X1mr3","id":"28ExwzUQsvgJooOI0X1mr3","name":"Jay Rock","type":"artist","uri":"spotify:artist:28ExwzUQsvgJooOI0X1mr3"}],"disc_number":1,"duration_ms":386906,"explicit":true,"external_ids":{"isrc":"USUM71210785"},"external_urls":{"spotify":"https://open.spotify.com/track/4X6bkYU7kAENTxhSigwclw"},"href":"https://api.spotify.com/v1/tracks/4X6bkYU7kAENTxhSigwclw","id":"4X6bkYU7kAENTxhSigwclw","is_local":false,"is_playable":true,"name":"Money Trees","track_number":11,"type":"track","uri":"spotify:track:4X6bkYU7kAENTxhSigwclw"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/09xjag8k7DtxFstSPo7z3N"},"href":"https://api.spotify.com/v1/albums/09xjag8k7DtxFstSPo7z3N","id":"09xjag8k7DtxFstSPo7z3N","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eac2914b1fd0118f9f132078"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eac2914b1fd0118f9f132078"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eac2914b1fd0118f9f132078"}],"is_playable":true,"name":"pov: you're rich and famous","release_date":"2025-05-30","release_date_precision":"day","total_tracks":55,"type":"album","uri":"spotify:album:09xjag8k7DtxFstSPo7z3N"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28ExwzUQsvgJooOI0X1mr3"},"href":"https://api.spotify.com/v1/artists/28ExwzUQsvgJooOI0X1mr3","id":"28ExwzUQsvgJooOI0X1mr3","name":"Jay Rock","type":"artist","uri":"spotify:artist:28ExwzUQsvgJooOI0X1mr3"}],"disc_number":1,"duration_ms":386906,"explicit":true,"external_ids":{"isrc":"USUM71210785"},"external_urls":{"spotify":"https://open.spotify.com/track/2wnBybqnfI5pt2oIiMFnBC"},"href":"https://api.spotify.com/v1/tracks/2wnBybqnfI5pt2oIiMFnBC","id":"2wnBybqnfI5pt2oIiMFnBC","is_local":false,"is_playable":true,"name":"Money Trees","track_number":10,"type":"track","uri":"spotify:track:2wnBybqnfI5pt2oIiMFnBC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/62smibY6yvqrWamD95LJFC"},"href":"https://api.spotify.com/v1/albums/62smibY6yvqrWamD95LJFC","id":"62smibY6yvqrWamD95LJFC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2bc95edcc867b1b1bfbeb72"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2bc95edcc867b1b1bfbeb72"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2bc95edcc867b1b1bfbeb72"}],"is_playable":true,"name":"West Coast Party","release_date":"2025-04-25","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:62smibY6yvqrWamD95LJFC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28ExwzUQsvgJooOI0X1mr3"},"href":"https://api.spotify.com/v1/artists/28ExwzUQsvgJooOI0X1mr3","id":"28ExwzUQsvgJooOI0X1mr3","name":"Jay Rock","type":"artist","uri":"spotify:artist:28ExwzUQsvgJooOI0X1mr3"}],"disc_number":1,"duration_ms":386906,"explicit":true,"external_ids":{"isrc":"USUM71210785"},"external_urls":{"spotify":"https://open.spotify.com/track/2B9FZXll2wDQB1nCEgXPBK"},"href":"https://api.spotify.com/v1/tracks/2B9FZXll2wDQB1nCEgXPBK","id":"2B9FZXll2wDQB1nCEgXPBK","is_local":false,"is_playable":true,"name":"Money Trees","track_number":4,"type":"track","uri":"spotify:track:2B9FZXll2wDQB1nCEgXPBK"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3dSBCdYaODjsaBHceBiLyv"},"href":"https://api.spotify.com/v1/albums/3dSBCdYaODjsaBHceBiLyv","id":"3dSBCdYaODjsaBHceBiLyv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e45081495e3a5c7241b20854"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e45081495e3a5c7241b20854"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e45081495e3a5c7241b20854"}],"is_playable":true,"name":"Temazos Variados Pal Viaje En Carro","release_date":"2025-03-21","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:3dSBCdYaODjsaBHceBiLyv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28ExwzUQsvgJooOI0X1mr3"},"href":"https://api.spotify.com/v1/artists/28ExwzUQsvgJooOI0X1mr3","id":"28ExwzUQsvgJooOI0X1mr3","name":"Jay Rock","type":"artist","uri":"spotify:artist:28ExwzUQsvgJooOI0X1mr3"}],"disc_number":1,"duration_ms":386906,"explicit":true,"external_ids":{"isrc":"USUM71210785"},"external_urls":{"spotify":"https://open.spotify.com/track/5oINQY8Ys0bKcZa7ZBctEZ"},"href":"https://api.spotify.com/v1/tracks/5oINQY8Ys0bKcZa7ZBctEZ","id":"5oINQY8Ys0bKcZa7ZBctEZ","is_local":false,"is_playable":true,"name":"Money Trees","track_number":25,"type":"track","uri":"spotify:track:5oINQY8Ys0bKcZa7ZBctEZ"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1vbmV5JTIwVHJlZXMlMjIlMjBhcnRpc3QlM0ElMjJLZW5kcmljayUyMExhbWFyJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBPcTNtV2ZleGhzalVoMGFOTkJCNXUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wT3EzbVdmZXhoc2pVaDBhTk5CQjV1IiwiaWQiOiIwT3EzbVdmZXhoc2pVaDBhTk5CQjV1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzJjZDU1MjQ2ZDkzNWE4YTc3Y2I0ODU5ZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyY2Q1NTI0NmQ5MzVhOGE3N2NiNDg1OWUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJjZDU1MjQ2ZDkzNWE4YTc3Y2I0ODU5ZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJnb29kIGtpZCwgbS5BLkEuZCBjaXR5IiwicmVsZWFzZV9kYXRlIjoiMjAxMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowT3EzbVdmZXhoc2pVaDBhTk5CQjV1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwiaWQiOiIyWQ==", + "WnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI4RXh3elVRc3ZnSm9vT0kwWDFtcjMiLCJpZCI6IjI4RXh3elVRc3ZnSm9vT0kwWDFtcjMiLCJuYW1lIjoiSmF5IFJvY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjhFeHd6VVFzdmdKb29PSTBYMW1yMyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozODY5MDYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTIxMDc4NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNzR0TGxrTjNyZ1Z6UnFRSmdQZmluayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzc0dExsa04zcmdWelJxUUpnUGZpbmsiLCJpZCI6Ijc0dExsa04zcmdWelJxUUpnUGZpbmsiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9uZXkgVHJlZXMiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NzR0TGxrTjNyZ1Z6UnFRSmdQZmluayJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc0OGRaRHFTWnk2YVBYS2NJOUg4MHUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83NDhkWkRxU1p5NmFQWEtjSTlIODB1IiwiaWQiOiI3NDhkWkRxU1p5NmFQWEtjSTlIODB1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzc4ZGU4YjI4ZGUzNmE3NGFmYzAzNA==", + "OGI1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjc4ZGU4YjI4ZGUzNmE3NGFmYzAzNDhiNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzhkZThiMjhkZTM2YTc0YWZjMDM0OGI1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Imdvb2Qga2lkLCBtLkEuQS5kIGNpdHkgKERlbHV4ZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDEyLTEwLTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzQ4ZFpEcVNaeTZhUFhLY0k5SDgwdSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsImlkIjoiMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsIm5hbWUiOiJLZW5kcmljayBMYW1hciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI4RXh3elVRc3ZnSm9vT0kwWDFtcjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjhFeHd6VVFzdmdKb29PSTBYMW1yMyIsImlkIjoiMjhFeHd6VVFzdmdKb29PSTBYMW1yMyIsIm5hbWUiOiJKYXkgUm9jayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjM4NjkwNiwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxMjEwNzg1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wVXRucEthUmVLVWcyR3F1YVN4Q3lEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMFV0bnBLYVJlS1VnMkdxdWFTeEN5RCIsImlkIjoiMFV0bnBLYVJlS1VnMkdxdWFTeEN5RCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb25leSBUcmVlcyIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowVXRucEthUmVLVWcyR3F1YVN4Q3lEIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIg==", + "OiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN2E5S1JXZGFTWmt0cEdHblduZHpiQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83YTlLUldkYVNaa3RwR0duV25kemJDIiwiaWQiOiI3YTlLUldkYVNaa3RwR0duV25kemJDIiwibmFtZSI6IkJsYWNrIEhpcHB5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdhOUtSV2RhU1prdHBHR25XbmR6YkMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83cWwyQTNrd2EwTVV5MnZIMm5NZjZkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3FsMkEza3dhME1VeTJ2SDJuTWY2ZCIsImlkIjoiN3FsMkEza3dhME1VeTJ2SDJuTWY2ZCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkZDFlNWM0NzIwZDAwNzIyZmEwY2QzZGMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZGQxZTVjNDcyMGQwMDcyMmZhMGNkM2RjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkZDFlNWM0NzIwZDAwNzIyZmEwY2QzZGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmxhY2sgSGlwcHkgMiIsInJlbGVhc2VfZGF0ZSI6IjIwMTQtMDktMTUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3cWwyQTNrd2EwTVV5MnZIMm5NZjZkIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN2E5S1JXZGFTWmt0cEdHblduZHpiQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83YTlLUldkYVNaa3RwR0duV25kemJDIiwiaWQiOiI3YTlLUldkYVNaa3RwR0duV25kemJDIiwibmFtZSI6IkJsYWNrIEhpcHB5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdhOUtSV2RhU1prdHBHR25XbmR6YkMifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yWVp5TG9MOE4wV2I5eA==", + "QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZzl2QWxSUEs5R3QzRktDZWtrNFRXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBnOXZBbFJQSzlHdDNGS0Nla2s0VFciLCJpZCI6IjBnOXZBbFJQSzlHdDNGS0Nla2s0VFciLCJuYW1lIjoiQWItU291bCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZzl2QWxSUEs5R3QzRktDZWtrNFRXIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI4RXh3elVRc3ZnSm9vT0kwWDFtcjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjhFeHd6VVFzdmdKb29PSTBYMW1yMyIsImlkIjoiMjhFeHd6VVFzdmdKb29PSTBYMW1yMyIsIm5hbWUiOiJKYXkgUm9jayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJY1IzTjdRQjFqNktCTDhlSW1aOG0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUljUjNON1FCMWo2S0JMOGVJbVo4bSIsImlkIjoiNUljUjNON1FCMWo2S0JMOGVJbVo4bSIsIm5hbWUiOiJTY0hvb2xib3kgUSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1SWNSM043UUIxajZLQkw4ZUltWjhtIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjM5NTYxMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkZSNVIwMDkwNDI4OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMlk3Z3N5M3N2TWtKYjFpYVN2QWd5diJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJZN2dzeTNzdk1rSmIxaWFTdkFneXYiLCJpZCI6IjJZN2dzeTNzdk1rSmIxaWFTdkFneXYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9uZXkgVHJlZXMiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mlk3Z3N5M3N2TWtKYjFpYVN2QWd5diJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZQ==", + "cm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsImlkIjoiMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsIm5hbWUiOiJLZW5kcmljayBMYW1hciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMEU0N3Zjeng5WFZkczFMcjJZOHJ6ZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBFNDd2Y3p4OVhWZHMxTHIyWThyemUiLCJpZCI6IjBFNDd2Y3p4OVhWZHMxTHIyWThyemUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjYzODFhZjZhZDY5NWVmNzRkZThjZTdiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY2MzgxYWY2YWQ2OTVlZjc0ZGU4Y2U3YiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjYzODFhZjZhZDY5NWVmNzRkZThjZTdiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Imdvb2Qga2lkLCBtLkEuQS5kIGNpdHkiLCJyZWxlYXNlX2RhdGUiOiIyMDEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBFNDd2Y3p4OVhWZHMxTHIyWThyemUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI4RXh3elVRc3ZnSm9vT0kwWDFtcjMiLCJpZCI6Ig==", + "MjhFeHd6VVFzdmdKb29PSTBYMW1yMyIsIm5hbWUiOiJKYXkgUm9jayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjM4NjkwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTIxMTE3OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMTZTSXZMRENGQUx2QkRUbWVwSk1JQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzE2U0l2TERDRkFMdkJEVG1lcEpNSUEiLCJpZCI6IjE2U0l2TERDRkFMdkJEVG1lcEpNSUEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9uZXkgVHJlZXMiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MTZTSXZMRENGQUx2QkRUbWVwSk1JQSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wenI2clRtRmROMmdSZ2FUbnFkd0Y0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMHpyNnJUbUZkTjJnUmdhVG5xZHdGNCIsImlkIjoiMHpyNnJUbUZkTjJnUmdhVG5xZHdGNCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyZjhmOGZkM2EzNTNiZDZiNGQwYWU3MzIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmY4ZjhmZDNhMzUzYmQ2YjRkMGFlNzMyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyZjhmOGZkM2EzNTNiZDZiNGQwYWU3MzIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGlwIEhvcCBNb3RpdmF0aW9uIiwicmVsZWFzZQ==", + "X2RhdGUiOiIyMDI1LTAzLTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NzYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MHpyNnJUbUZkTjJnUmdhVG5xZHdGNCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsImlkIjoiMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsIm5hbWUiOiJLZW5kcmljayBMYW1hciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI4RXh3elVRc3ZnSm9vT0kwWDFtcjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjhFeHd6VVFzdmdKb29PSTBYMW1yMyIsImlkIjoiMjhFeHd6VVFzdmdKb29PSTBYMW1yMyIsIm5hbWUiOiJKYXkgUm9jayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjM4NjkwNiwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxMjEwNzg1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81WVlrWTFtMlc1dlk3OWVGZmZtT25DIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNVlZa1kxbTJXNXZZNzllRmZmbU9uQyIsImlkIjoiNVlZa1kxbTJXNXZZNzllRmZmbU9uQyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb25leSBUcmVlcyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1WVlrWTFtMlc1dlk3OWVGZmZtT25DIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MA==", + "THlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMks0MGVBbHU1RGRaZUttR3ZNSXN2dSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJLNDBlQWx1NURkWmVLbUd2TUlzdnUiLCJpZCI6IjJLNDBlQWx1NURkWmVLbUd2TUlzdnUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjkwNWNmMGU2YWE1MDFhMzUwZGIxOWEwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmI5MDVjZjBlNmFhNTAxYTM1MGRiMTlhMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjkwNWNmMGU2YWE1MDFhMzUwZGIxOWEwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNrYXRlYm9hcmQgJiBTa2F0aW5nIFZpYmVzIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wNS0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjU2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJLNDBlQWx1NURkWmVLbUd2TUlzdnUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI4RXh3elVRc3ZnSm9vT0kwWDFtcjMiLCJpZCI6IjI4RXh3elVRc3ZnSm9vT0kwWDFtcjMiLCJuYW1lIjoiSmF5IFJvY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjhFeHd6VVFzdmdKb29PSTBYMW1yMyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozODY5MDYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTIxMDc4NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwcw==", + "Oi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80WDZia1lVN2tBRU5UeGhTaWd3Y2x3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNFg2YmtZVTdrQUVOVHhoU2lnd2NsdyIsImlkIjoiNFg2YmtZVTdrQUVOVHhoU2lnd2NsdyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb25leSBUcmVlcyIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFg2YmtZVTdrQUVOVHhoU2lnd2NsdyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wOXhqYWc4azdEdHhGc3RTUG83ejNOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDl4amFnOGs3RHR4RnN0U1BvN3ozTiIsImlkIjoiMDl4amFnOGs3RHR4RnN0U1BvN3ozTiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlYWMyOTE0YjFmZDAxMThmOWYxMzIwNzgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZWFjMjkxNGIxZmQwMTE4ZjlmMTMyMDc4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlYWMyOTE0YjFmZDAxMThmOWYxMzIwNzgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoicG92OiB5b3UncmUgcmljaCBhbmQgZmFtb3VzIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wNS0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjU1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjA5eGphZzhrN0R0eEZzdFNQbzd6M04ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWg==", + "V2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsImlkIjoiMllaeUxvTDhOMFdiOXhCdDFOaFpXZyIsIm5hbWUiOiJLZW5kcmljayBMYW1hciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI4RXh3elVRc3ZnSm9vT0kwWDFtcjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjhFeHd6VVFzdmdKb29PSTBYMW1yMyIsImlkIjoiMjhFeHd6VVFzdmdKb29PSTBYMW1yMyIsIm5hbWUiOiJKYXkgUm9jayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjM4NjkwNiwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxMjEwNzg1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yd25CeWJxbmZJNXB0Mm9JaU1GbkJDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMnduQnlicW5mSTVwdDJvSWlNRm5CQyIsImlkIjoiMnduQnlicW5mSTVwdDJvSWlNRm5CQyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb25leSBUcmVlcyIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MnduQnlicW5mSTVwdDJvSWlNRm5CQyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82MnNtaWJZNnl2cXJXYW1EOTVMSkZDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjJzbWliWTZ5dnFyV2FtRDk1TEpGQyIsImlkIjoiNjJzbWliWTZ5dnFyV2FtRDk1TEpGQyIsImltYWdlcyI6W3siaGVpZw==", + "aHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2YyYmM5NWVkY2M4NjdiMWIxYmZiZWI3MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmMmJjOTVlZGNjODY3YjFiMWJmYmViNzIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWYyYmM5NWVkY2M4NjdiMWIxYmZiZWI3MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXZXN0IENvYXN0IFBhcnR5IiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wNC0yNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjYyc21pYlk2eXZxcldhbUQ5NUxKRkMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJpZCI6IjJZWnlMb0w4TjBXYjl4QnQxTmhaV2ciLCJuYW1lIjoiS2VuZHJpY2sgTGFtYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI4RXh3elVRc3ZnSm9vT0kwWDFtcjMiLCJpZCI6IjI4RXh3elVRc3ZnSm9vT0kwWDFtcjMiLCJuYW1lIjoiSmF5IFJvY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjhFeHd6VVFzdmdKb29PSTBYMW1yMyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozODY5MDYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTIxMDc4NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMkI5RlpYbGwyd0RRQjFuQ0VnWFBCSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJCOUZaWGxsMndEUUIxbkNFZ1hQQksiLCJpZCI6IjJCOUZaWGxsMndEUUIxbkNFZ1hQQksiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9uZXkgVHJlZXMiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cg==", + "YWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyQjlGWlhsbDJ3RFFCMW5DRWdYUEJLIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNkU0JDZFlhT0Rqc2FCSGNlQmlMeXYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zZFNCQ2RZYU9EanNhQkhjZUJpTHl2IiwiaWQiOiIzZFNCQ2RZYU9EanNhQkhjZUJpTHl2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2U0NTA4MTQ5NWUzYTVjNzI0MWIyMDg1NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlNDUwODE0OTVlM2E1YzcyNDFiMjA4NTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWU0NTA4MTQ5NWUzYTVjNzI0MWIyMDg1NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUZW1hem9zIFZhcmlhZG9zIFBhbCBWaWFqZSBFbiBDYXJybyIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDMtMjEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozZFNCQ2RZYU9EanNhQkhjZUJpTHl2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMllaeUxvTDhOMFdiOXhCdDFOaFpXZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwiaWQiOiIyWVp5TG9MOE4wV2I5eEJ0MU5oWldnIiwibmFtZSI6IktlbmRyaWNrIExhbWFyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJZWnlMb0w4TjBXYjl4QnQxTmhaV2cifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOg==", + "Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yOEV4d3pVUXN2Z0pvb09JMFgxbXIzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI4RXh3elVRc3ZnSm9vT0kwWDFtcjMiLCJpZCI6IjI4RXh3elVRc3ZnSm9vT0kwWDFtcjMiLCJuYW1lIjoiSmF5IFJvY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjhFeHd6VVFzdmdKb29PSTBYMW1yMyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozODY5MDYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTIxMDc4NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNW9JTlFZOFlzMGJLY1phN1pCY3RFWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVvSU5RWThZczBiS2NaYTdaQmN0RVoiLCJpZCI6IjVvSU5RWThZczBiS2NaYTdaQmN0RVoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9uZXkgVHJlZXMiLCJ0cmFja19udW1iZXIiOjI1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVvSU5RWThZczBiS2NaYTdaQmN0RVoifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Money+Trees%22+artist%3A%22Kendrick+Lamar%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%223005%22%20artist%3A%22Childish%20Gambino%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":5,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"external_urls":{"spotify":"https://open.spotify.com/album/5h0KYWMZIg8xT6eRGYkNMh"},"href":"https://api.spotify.com/v1/albums/5h0KYWMZIg8xT6eRGYkNMh","id":"5h0KYWMZIg8xT6eRGYkNMh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27321b2b485aef32bcc96c1875c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0221b2b485aef32bcc96c1875c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485121b2b485aef32bcc96c1875c"}],"is_playable":true,"name":"Because the Internet","release_date":"2013-12-10","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:5h0KYWMZIg8xT6eRGYkNMh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":234215,"explicit":true,"external_ids":{"isrc":"USYAH1300213"},"external_urls":{"spotify":"https://open.spotify.com/track/2X6b7zLdIxCejd6GqVcQ9M"},"href":"https://api.spotify.com/v1/tracks/2X6b7zLdIxCejd6GqVcQ9M","id":"2X6b7zLdIxCejd6GqVcQ9M","is_local":false,"is_playable":true,"name":"3005","track_number":9,"type":"track","uri":"spotify:track:2X6b7zLdIxCejd6GqVcQ9M"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5xdizdgbQQvGAgAolGhpXr"},"href":"https://api.spotify.com/v1/artists/5xdizdgbQQvGAgAolGhpXr","id":"5xdizdgbQQvGAgAolGhpXr","name":"Friction","type":"artist","uri":"spotify:artist:5xdizdgbQQvGAgAolGhpXr"}],"external_urls":{"spotify":"https://open.spotify.com/album/73KXoF8Zz1hYYfvLoUFUvJ"},"href":"https://api.spotify.com/v1/albums/73KXoF8Zz1hYYfvLoUFUvJ","id":"73KXoF8Zz1hYYfvLoUFUvJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a29e228ca3dc28ba3faaf6ec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a29e228ca3dc28ba3faaf6ec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a29e228ca3dc28ba3faaf6ec"}],"is_playable":true,"name":"3005 (Friction Remix)","release_date":"2014-01-01","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:73KXoF8Zz1hYYfvLoUFUvJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5xdizdgbQQvGAgAolGhpXr"},"href":"https://api.spotify.com/v1/artists/5xdizdgbQQvGAgAolGhpXr","id":"5xdizdgbQQvGAgAolGhpXr","name":"Friction","type":"artist","uri":"spotify:artist:5xdizdgbQQvGAgAolGhpXr"}],"disc_number":1,"duration_ms":268973,"explicit":true,"external_ids":{"isrc":"USYAH1400029"},"external_urls":{"spotify":"https://open.spotify.com/track/3Lx18MD6AZmD3eYwd2F0zR"},"href":"https://api.spotify.com/v1/tracks/3Lx18MD6AZmD3eYwd2F0zR","id":"3Lx18MD6AZmD3eYwd2F0zR","is_local":false,"is_playable":true,"name":"3005 (Friction Remix)","track_number":1,"type":"track","uri":"spotify:track:3Lx18MD6AZmD3eYwd2F0zR"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"external_urls":{"spotify":"https://open.spotify.com/album/0G3xqC6L3eKFNSIaF4MIyi"},"href":"https://api.spotify.com/v1/albums/0G3xqC6L3eKFNSIaF4MIyi","id":"0G3xqC6L3eKFNSIaF4MIyi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c17df392e8863c69361422c9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c17df392e8863c69361422c9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c17df392e8863c69361422c9"}],"is_playable":true,"name":"Kauai","release_date":"2014-10-03","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:0G3xqC6L3eKFNSIaF4MIyi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":225860,"explicit":false,"external_ids":{"isrc":"USYAH1400044"},"external_urls":{"spotify":"https://open.spotify.com/track/60dRJjSx9xmfXuK3HXysw0"},"href":"https://api.spotify.com/v1/tracks/60dRJjSx9xmfXuK3HXysw0","id":"60dRJjSx9xmfXuK3HXysw0","is_local":false,"is_playable":true,"name":"V. 3005 (Beach Picnic Version)","track_number":7,"type":"track","uri":"spotify:track:60dRJjSx9xmfXuK3HXysw0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"external_urls":{"spotify":"https://open.spotify.com/album/7DtpLngwHYD5j0lZlMFuwU"},"href":"https://api.spotify.com/v1/albums/7DtpLngwHYD5j0lZlMFuwU","id":"7DtpLngwHYD5j0lZlMFuwU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273811e18d061fb03580767a0f3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02811e18d061fb03580767a0f3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851811e18d061fb03580767a0f3"}],"is_playable":true,"name":"Kauai","release_date":"2014-10-03","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:7DtpLngwHYD5j0lZlMFuwU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":225866,"explicit":true,"external_ids":{"isrc":"USYAH1400037"},"external_urls":{"spotify":"https://open.spotify.com/track/6AalgYpkET99cWnGH3ATPq"},"href":"https://api.spotify.com/v1/tracks/6AalgYpkET99cWnGH3ATPq","id":"6AalgYpkET99cWnGH3ATPq","is_local":false,"is_playable":true,"name":"V. 3005 (Beach Picnic Version)","track_number":7,"type":"track","uri":"spotify:track:6AalgYpkET99cWnGH3ATPq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"external_urls":{"spotify":"https://open.spotify.com/album/5pC8b5mAkXOQTKgG3WVv8K"},"href":"https://api.spotify.com/v1/albums/5pC8b5mAkXOQTKgG3WVv8K","id":"5pC8b5mAkXOQTKgG3WVv8K","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27387d805990f30e7e5328e0b18"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0287d805990f30e7e5328e0b18"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485187d805990f30e7e5328e0b18"}],"is_playable":true,"name":"Because the Internet","release_date":"2013-12-10","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:5pC8b5mAkXOQTKgG3WVv8K"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":234215,"explicit":false,"external_ids":{"isrc":"USYAH1300243"},"external_urls":{"spotify":"https://open.spotify.com/track/6BSjJuMiIp22MLYriO9voq"},"href":"https://api.spotify.com/v1/tracks/6BSjJuMiIp22MLYriO9voq","id":"6BSjJuMiIp22MLYriO9voq","is_local":false,"is_playable":true,"name":"V. 3005","track_number":9,"type":"track","uri":"spotify:track:6BSjJuMiIp22MLYriO9voq"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMjMwMDUlMjIlMjBhcnRpc3QlM0ElMjJDaGlsZGlzaCUyMEdhbWJpbm8lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjUsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81aDBLWVdNWklnOHhUNmVSR1lrTk1oIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWgwS1lXTVpJZzh4VDZlUkdZa05NaCIsImlkIjoiNWgwS1lXTVpJZzh4VDZlUkdZa05NaCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLg==", + "Y28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzIxYjJiNDg1YWVmMzJiY2M5NmMxODc1YyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyMWIyYjQ4NWFlZjMyYmNjOTZjMTg3NWMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTIxYjJiNDg1YWVmMzJiY2M5NmMxODc1YyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCZWNhdXNlIHRoZSBJbnRlcm5ldCIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMTItMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1aDBLWVdNWklnOHhUNmVSR1lrTk1oIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzQyMTUsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTMwMDIxMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMlg2Yjd6TGRJeENlamQ2R3FWY1E5TSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJYNmI3ekxkSXhDZWpkNkdxVmNROU0iLCJpZCI6IjJYNmI3ekxkSXhDZWpkNkdxVmNROU0iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMzAwNSIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyWDZiN3pMZEl4Q2VqZDZHcVZjUTlNIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cA==", + "ZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXhkaXpkZ2JRUXZHQWdBb2xHaHBYciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81eGRpemRnYlFRdkdBZ0FvbEdocFhyIiwiaWQiOiI1eGRpemRnYlFRdkdBZ0FvbEdocFhyIiwibmFtZSI6IkZyaWN0aW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV4ZGl6ZGdiUVF2R0FnQW9sR2hwWHIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83M0tYb0Y4WnoxaFlZZnZMb1VGVXZKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzNLWG9GOFp6MWhZWWZ2TG9VRlV2SiIsImlkIjoiNzNLWG9GOFp6MWhZWWZ2TG9VRlV2SiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhMjllMjI4Y2EzZGMyOGJhM2ZhYWY2ZWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTI5ZTIyOGNhM2RjMjhiYTNmYWFmNmVjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhMjllMjI4Y2EzZGMyOGJhM2ZhYWY2ZWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMzAwNSAoRnJpY3Rpb24gUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAxNC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzNLWG9GOFp6MWhZWWZ2TG9VRlV2SiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXhkaXpkZ2JRUXZHQWdBb2xHaHBYciJ9LCJocmVmIjoiaA==", + "dHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV4ZGl6ZGdiUVF2R0FnQW9sR2hwWHIiLCJpZCI6IjV4ZGl6ZGdiUVF2R0FnQW9sR2hwWHIiLCJuYW1lIjoiRnJpY3Rpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXhkaXpkZ2JRUXZHQWdBb2xHaHBYciJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjg5NzMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTQwMDAyOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0x4MThNRDZBWm1EM2VZd2QyRjB6UiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNMeDE4TUQ2QVptRDNlWXdkMkYwelIiLCJpZCI6IjNMeDE4TUQ2QVptRDNlWXdkMkYwelIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMzAwNSAoRnJpY3Rpb24gUmVtaXgpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNMeDE4TUQ2QVptRDNlWXdkMkYwelIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBHM3hxQzZMM2VLRk5TSWFGNE1JeWkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wRzN4cUM2TDNlS0ZOU0lhRjRNSXlpIiwiaWQiOiIwRzN4cUM2TDNlS0ZOU0lhRjRNSXlpIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2MxN2RmMzkyZTg4NjNjNjkzNjE0MjJjOSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjMTdkZjM5MmU4ODYzYzY5MzYxNDIyYzkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWMxN2RmMzkyZTg4NjNjNg==", + "OTM2MTQyMmM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkthdWFpIiwicmVsZWFzZV9kYXRlIjoiMjAxNC0xMC0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MEczeHFDNkwzZUtGTlNJYUY0TUl5aSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI1ODYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNZQUgxNDAwMDQ0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82MGRSSmpTeDl4bWZYdUszSFh5c3cwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNjBkUkpqU3g5eG1mWHVLM0hYeXN3MCIsImlkIjoiNjBkUkpqU3g5eG1mWHVLM0hYeXN3MCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWLiAzMDA1IChCZWFjaCBQaWNuaWMgVmVyc2lvbikiLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NjBkUkpqU3g5eG1mWHVLM0hYeXN3MCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN0R0cExuZ3dIWUQ1ajBsWmxNRnV3VSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdEdHBMbmd3SFlENWowbFpsTUZ1d1UiLCJpZCI6IjdEdHBMbmd3SFlENQ==", + "ajBsWmxNRnV3VSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4MTFlMThkMDYxZmIwMzU4MDc2N2EwZjMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODExZTE4ZDA2MWZiMDM1ODA3NjdhMGYzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4MTFlMThkMDYxZmIwMzU4MDc2N2EwZjMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS2F1YWkiLCJyZWxlYXNlX2RhdGUiOiIyMDE0LTEwLTAzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3RHRwTG5nd0hZRDVqMGxabE1GdXdVIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjU4NjYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTQwMDAzNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNkFhbGdZcGtFVDk5Y1duR0gzQVRQcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZBYWxnWXBrRVQ5OWNXbkdIM0FUUHEiLCJpZCI6IjZBYWxnWXBrRVQ5OWNXbkdIM0FUUHEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVi4gMzAwNSAoQmVhY2ggUGljbmljIFZlcnNpb24pIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZBYWxnWXBrRVQ5OWNXbkdIM0FUUHEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQg==", + "SGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNXBDOGI1bUFrWE9RVEtnRzNXVnY4SyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVwQzhiNW1Ba1hPUVRLZ0czV1Z2OEsiLCJpZCI6IjVwQzhiNW1Ba1hPUVRLZ0czV1Z2OEsiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODdkODA1OTkwZjMwZTdlNTMyOGUwYjE4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjg3ZDgwNTk5MGYzMGU3ZTUzMjhlMGIxOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODdkODA1OTkwZjMwZTdlNTMyOGUwYjE4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlY2F1c2UgdGhlIEludGVybmV0IiwicmVsZWFzZV9kYXRlIjoiMjAxMy0xMi0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVwQzhiNW1Ba1hPUVRLZ0czV1Z2OEsifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNDIxNSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTMwMDI0MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNkJTakp1TWlJcDIyTUxZcmlPOXZvcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZCU2pKdU1pSXAyMk1MWXJpTzl2b3EiLCJpZCI6IjZCU2pKdU1pSXAyMk1MWXJpTzl2b3EiLCJpc19sbw==", + "Y2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWLiAzMDA1IiwidHJhY2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZCU2pKdU1pSXAyMk1MWXJpTzl2b3EifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%223005%22+artist%3A%22Childish+Gambino%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Sunflower%22%20artist%3A%22Post%20Malone%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/35s58BRTGAEWztPo9WqCIs"},"href":"https://api.spotify.com/v1/albums/35s58BRTGAEWztPo9WqCIs","id":"35s58BRTGAEWztPo9WqCIs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e2e352d89826aef6dbd5ff8f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e2e352d89826aef6dbd5ff8f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e2e352d89826aef6dbd5ff8f"}],"is_playable":true,"name":"Spider-Man: Into the Spider-Verse (Soundtrack From & Inspired by the Motion Picture)","release_date":"2018-12-14","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:35s58BRTGAEWztPo9WqCIs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zNqQNIdeOUZHb8zbZRFMX"},"href":"https://api.spotify.com/v1/artists/1zNqQNIdeOUZHb8zbZRFMX","id":"1zNqQNIdeOUZHb8zbZRFMX","name":"Swae Lee","type":"artist","uri":"spotify:artist:1zNqQNIdeOUZHb8zbZRFMX"}],"disc_number":1,"duration_ms":158040,"explicit":false,"external_ids":{"isrc":"USUM71814888"},"external_urls":{"spotify":"https://open.spotify.com/track/3KkXRkHbMCARz0aVfEt68P"},"href":"https://api.spotify.com/v1/tracks/3KkXRkHbMCARz0aVfEt68P","id":"3KkXRkHbMCARz0aVfEt68P","is_local":false,"is_playable":true,"name":"Sunflower - Spider-Man: Into the Spider-Verse","track_number":2,"type":"track","uri":"spotify:track:3KkXRkHbMCARz0aVfEt68P"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/4g1ZRSobMefqF6nelkgibi"},"href":"https://api.spotify.com/v1/albums/4g1ZRSobMefqF6nelkgibi","id":"4g1ZRSobMefqF6nelkgibi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739478c87599550dd73bfa7e02"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029478c87599550dd73bfa7e02"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519478c87599550dd73bfa7e02"}],"is_playable":true,"name":"Hollywood's Bleeding","release_date":"2019-09-06","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:4g1ZRSobMefqF6nelkgibi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zNqQNIdeOUZHb8zbZRFMX"},"href":"https://api.spotify.com/v1/artists/1zNqQNIdeOUZHb8zbZRFMX","id":"1zNqQNIdeOUZHb8zbZRFMX","name":"Swae Lee","type":"artist","uri":"spotify:artist:1zNqQNIdeOUZHb8zbZRFMX"}],"disc_number":1,"duration_ms":157560,"explicit":false,"external_ids":{"isrc":"USUM71814888"},"external_urls":{"spotify":"https://open.spotify.com/track/0RiRZpuVRbi7oqRdSMwhQY"},"href":"https://api.spotify.com/v1/tracks/0RiRZpuVRbi7oqRdSMwhQY","id":"0RiRZpuVRbi7oqRdSMwhQY","is_local":false,"is_playable":true,"name":"Sunflower - Spider-Man: Into the Spider-Verse","track_number":12,"type":"track","uri":"spotify:track:0RiRZpuVRbi7oqRdSMwhQY"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3pOj4mmxL5MUwR1IR8LPzL"},"href":"https://api.spotify.com/v1/albums/3pOj4mmxL5MUwR1IR8LPzL","id":"3pOj4mmxL5MUwR1IR8LPzL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ea0eb66d4b8fef4a84c599fe"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ea0eb66d4b8fef4a84c599fe"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ea0eb66d4b8fef4a84c599fe"}],"is_playable":true,"name":"Spider-Man: Into the Spider-Verse (Deluxe Edition / Soundtrack From & Inspired By The Motion Picture)","release_date":"2019-02-22","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:3pOj4mmxL5MUwR1IR8LPzL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zNqQNIdeOUZHb8zbZRFMX"},"href":"https://api.spotify.com/v1/artists/1zNqQNIdeOUZHb8zbZRFMX","id":"1zNqQNIdeOUZHb8zbZRFMX","name":"Swae Lee","type":"artist","uri":"spotify:artist:1zNqQNIdeOUZHb8zbZRFMX"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1SupJlEpv7RS2tPNRaHViT"},"href":"https://api.spotify.com/v1/artists/1SupJlEpv7RS2tPNRaHViT","id":"1SupJlEpv7RS2tPNRaHViT","name":"Nicky Jam","type":"artist","uri":"spotify:artist:1SupJlEpv7RS2tPNRaHViT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3MHaV05u0io8fQbZ2XPtlC"},"href":"https://api.spotify.com/v1/artists/3MHaV05u0io8fQbZ2XPtlC","id":"3MHaV05u0io8fQbZ2XPtlC","name":"Prince Royce","type":"artist","uri":"spotify:artist:3MHaV05u0io8fQbZ2XPtlC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7fiP6lgxb6HlZcq8gDYCmE"},"href":"https://api.spotify.com/v1/artists/7fiP6lgxb6HlZcq8gDYCmE","id":"7fiP6lgxb6HlZcq8gDYCmE","name":"G.O.K.B.","type":"artist","uri":"spotify:artist:7fiP6lgxb6HlZcq8gDYCmE"}],"disc_number":1,"duration_ms":210000,"explicit":false,"external_ids":{"isrc":"USUM71902679"},"external_urls":{"spotify":"https://open.spotify.com/track/0wt9RjddODlWDetpuaXfRK"},"href":"https://api.spotify.com/v1/tracks/0wt9RjddODlWDetpuaXfRK","id":"0wt9RjddODlWDetpuaXfRK","is_local":false,"is_playable":true,"name":"Sunflower (Remix) [with Swae Lee, Nicky Jam, and Prince Royce]","track_number":14,"type":"track","uri":"spotify:track:0wt9RjddODlWDetpuaXfRK"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3pOj4mmxL5MUwR1IR8LPzL"},"href":"https://api.spotify.com/v1/albums/3pOj4mmxL5MUwR1IR8LPzL","id":"3pOj4mmxL5MUwR1IR8LPzL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ea0eb66d4b8fef4a84c599fe"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ea0eb66d4b8fef4a84c599fe"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ea0eb66d4b8fef4a84c599fe"}],"is_playable":true,"name":"Spider-Man: Into the Spider-Verse (Deluxe Edition / Soundtrack From & Inspired By The Motion Picture)","release_date":"2019-02-22","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:3pOj4mmxL5MUwR1IR8LPzL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zNqQNIdeOUZHb8zbZRFMX"},"href":"https://api.spotify.com/v1/artists/1zNqQNIdeOUZHb8zbZRFMX","id":"1zNqQNIdeOUZHb8zbZRFMX","name":"Swae Lee","type":"artist","uri":"spotify:artist:1zNqQNIdeOUZHb8zbZRFMX"}],"disc_number":1,"duration_ms":158040,"explicit":false,"external_ids":{"isrc":"USUM71814888"},"external_urls":{"spotify":"https://open.spotify.com/track/7dbka99KTWke5o9hRp0JoB"},"href":"https://api.spotify.com/v1/tracks/7dbka99KTWke5o9hRp0JoB","id":"7dbka99KTWke5o9hRp0JoB","is_local":false,"is_playable":true,"name":"Sunflower - Spider-Man: Into the Spider-Verse","track_number":2,"type":"track","uri":"spotify:track:7dbka99KTWke5o9hRp0JoB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/3xiq77UtnlDXfcRz5IJu20"},"href":"https://api.spotify.com/v1/albums/3xiq77UtnlDXfcRz5IJu20","id":"3xiq77UtnlDXfcRz5IJu20","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27391bf597d2ed7528de53f71be"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0291bf597d2ed7528de53f71be"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485191bf597d2ed7528de53f71be"}],"is_playable":true,"name":"Hollywood's Bleeding","release_date":"2019-09-06","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:3xiq77UtnlDXfcRz5IJu20"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zNqQNIdeOUZHb8zbZRFMX"},"href":"https://api.spotify.com/v1/artists/1zNqQNIdeOUZHb8zbZRFMX","id":"1zNqQNIdeOUZHb8zbZRFMX","name":"Swae Lee","type":"artist","uri":"spotify:artist:1zNqQNIdeOUZHb8zbZRFMX"}],"disc_number":1,"duration_ms":157560,"explicit":false,"external_ids":{"isrc":"USUM71814888"},"external_urls":{"spotify":"https://open.spotify.com/track/6nY9ga57plhBYQnZX0Oqe8"},"href":"https://api.spotify.com/v1/tracks/6nY9ga57plhBYQnZX0Oqe8","id":"6nY9ga57plhBYQnZX0Oqe8","is_local":false,"is_playable":true,"name":"Sunflower - Spider-Man: Into the Spider-Verse","track_number":12,"type":"track","uri":"spotify:track:6nY9ga57plhBYQnZX0Oqe8"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2ppP3bOrsDPUGikeO7xOO2"},"href":"https://api.spotify.com/v1/albums/2ppP3bOrsDPUGikeO7xOO2","id":"2ppP3bOrsDPUGikeO7xOO2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d377298396fd9f3ad2ea6746"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d377298396fd9f3ad2ea6746"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d377298396fd9f3ad2ea6746"}],"is_playable":true,"name":"Relax Post-Trabajo","release_date":"2023-10-27","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:2ppP3bOrsDPUGikeO7xOO2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zNqQNIdeOUZHb8zbZRFMX"},"href":"https://api.spotify.com/v1/artists/1zNqQNIdeOUZHb8zbZRFMX","id":"1zNqQNIdeOUZHb8zbZRFMX","name":"Swae Lee","type":"artist","uri":"spotify:artist:1zNqQNIdeOUZHb8zbZRFMX"}],"disc_number":1,"duration_ms":157560,"explicit":false,"external_ids":{"isrc":"USUM71814888"},"external_urls":{"spotify":"https://open.spotify.com/track/06PeFT6F5PgiwpA8srwtYc"},"href":"https://api.spotify.com/v1/tracks/06PeFT6F5PgiwpA8srwtYc","id":"06PeFT6F5PgiwpA8srwtYc","is_local":false,"is_playable":true,"name":"Sunflower - Spider-Man: Into the Spider-Verse","track_number":1,"type":"track","uri":"spotify:track:06PeFT6F5PgiwpA8srwtYc"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/50PT458zbmJ71tLjqvjcoP"},"href":"https://api.spotify.com/v1/albums/50PT458zbmJ71tLjqvjcoP","id":"50PT458zbmJ71tLjqvjcoP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734d4196d02cf28cad7077f11c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024d4196d02cf28cad7077f11c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514d4196d02cf28cad7077f11c"}],"is_playable":true,"name":"The Diamond Collection (Deluxe)","release_date":"2023-04-21","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:50PT458zbmJ71tLjqvjcoP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zNqQNIdeOUZHb8zbZRFMX"},"href":"https://api.spotify.com/v1/artists/1zNqQNIdeOUZHb8zbZRFMX","id":"1zNqQNIdeOUZHb8zbZRFMX","name":"Swae Lee","type":"artist","uri":"spotify:artist:1zNqQNIdeOUZHb8zbZRFMX"}],"disc_number":1,"duration_ms":157559,"explicit":false,"external_ids":{"isrc":"USUM71814888"},"external_urls":{"spotify":"https://open.spotify.com/track/44PVCNMll9q0t5Imc9HKOh"},"href":"https://api.spotify.com/v1/tracks/44PVCNMll9q0t5Imc9HKOh","id":"44PVCNMll9q0t5Imc9HKOh","is_local":false,"is_playable":true,"name":"Sunflower - Spider-Man: Into the Spider-Verse","track_number":7,"type":"track","uri":"spotify:track:44PVCNMll9q0t5Imc9HKOh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/5d65XFiUf4f4fkmfMrxbaM"},"href":"https://api.spotify.com/v1/albums/5d65XFiUf4f4fkmfMrxbaM","id":"5d65XFiUf4f4fkmfMrxbaM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27339378653f59299c51b83b940"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0239378653f59299c51b83b940"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485139378653f59299c51b83b940"}],"is_playable":true,"name":"The Diamond Collection (Deluxe)","release_date":"2023-04-21","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:5d65XFiUf4f4fkmfMrxbaM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zNqQNIdeOUZHb8zbZRFMX"},"href":"https://api.spotify.com/v1/artists/1zNqQNIdeOUZHb8zbZRFMX","id":"1zNqQNIdeOUZHb8zbZRFMX","name":"Swae Lee","type":"artist","uri":"spotify:artist:1zNqQNIdeOUZHb8zbZRFMX"}],"disc_number":1,"duration_ms":157559,"explicit":false,"external_ids":{"isrc":"USUM71814888"},"external_urls":{"spotify":"https://open.spotify.com/track/3dY6k5mdqBctPMZazTxYx0"},"href":"https://api.spotify.com/v1/tracks/3dY6k5mdqBctPMZazTxYx0","id":"3dY6k5mdqBctPMZazTxYx0","is_local":false,"is_playable":true,"name":"Sunflower - Spider-Man: Into the Spider-Verse","track_number":7,"type":"track","uri":"spotify:track:3dY6k5mdqBctPMZazTxYx0"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/1nKIHlqMCuwkO19LEOHF5x"},"href":"https://api.spotify.com/v1/albums/1nKIHlqMCuwkO19LEOHF5x","id":"1nKIHlqMCuwkO19LEOHF5x","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733831590da594a5f457334528"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023831590da594a5f457334528"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513831590da594a5f457334528"}],"is_playable":true,"name":"The Diamond Collection (Deluxe)","release_date":"2023-04-21","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:1nKIHlqMCuwkO19LEOHF5x"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zNqQNIdeOUZHb8zbZRFMX"},"href":"https://api.spotify.com/v1/artists/1zNqQNIdeOUZHb8zbZRFMX","id":"1zNqQNIdeOUZHb8zbZRFMX","name":"Swae Lee","type":"artist","uri":"spotify:artist:1zNqQNIdeOUZHb8zbZRFMX"}],"disc_number":1,"duration_ms":157559,"explicit":false,"external_ids":{"isrc":"USUM71814888"},"external_urls":{"spotify":"https://open.spotify.com/track/4y8krOZsgP5mpJtGP2mx7B"},"href":"https://api.spotify.com/v1/tracks/4y8krOZsgP5mpJtGP2mx7B","id":"4y8krOZsgP5mpJtGP2mx7B","is_local":false,"is_playable":true,"name":"Sunflower - Spider-Man: Into the Spider-Verse","track_number":7,"type":"track","uri":"spotify:track:4y8krOZsgP5mpJtGP2mx7B"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN1bmZsb3dlciUyMiUyMGFydGlzdCUzQSUyMlBvc3QlMjBNYWxvbmUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjksIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzM1czU4QlJUR0FFV3p0UG85V3FDSXMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zNXM1OEJSVEdBRVd6dFBvOVdxQ0lzIiwiaWQiOiIzNXM1OEJSVEdBRVd6dFBvOVdxQ0lzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2UyZTM1MmQ4OTgyNmFlZjZkYmQ1ZmY4ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlMmUzNTJkODk4MjZhZWY2ZGJkNWZmOGYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWUyZTM1MmQ4OTgyNmFlZjZkYmQ1ZmY4ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTcGlkZXItTWFuOiBJbnRvIHRoZSBTcGlkZXItVmVyc2UgKFNvdW5kdHJhY2sgRnJvbSAmIEluc3BpcmVkIGJ5IHRoZSBNb3Rpb24gUGljdHVyZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDE4LTEyLTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MzVzNThCUlRHQUVXenRQbzlXcUNJcyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVHRpeWtYZTVoNjAifSwiaHJlZiI6Ig==", + "aHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwiaWQiOiIyNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwibmFtZSI6IlBvc3QgTWFsb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0NmRranZTMXpMVHRpeWtYZTVoNjAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXpOcVFOSWRlT1VaSGI4emJaUkZNWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xek5xUU5JZGVPVVpIYjh6YlpSRk1YIiwiaWQiOiIxek5xUU5JZGVPVVpIYjh6YlpSRk1YIiwibmFtZSI6IlN3YWUgTGVlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF6TnFRTklkZU9VWkhiOHpiWlJGTVgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTU4MDQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxODE0ODg4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zS2tYUmtIYk1DQVJ6MGFWZkV0NjhQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0trWFJrSGJNQ0FSejBhVmZFdDY4UCIsImlkIjoiM0trWFJrSGJNQ0FSejBhVmZFdDY4UCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW5mbG93ZXIgLSBTcGlkZXItTWFuOiBJbnRvIHRoZSBTcGlkZXItVmVyc2UiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0trWFJrSGJNQ0FSejBhVmZFdDY4UCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRnMVpSU29iTWVmcUY2bmVsa2dpYmkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80ZzFaUlNvYk1lZnFGNm5lbGtnaWJpIiwiaWQiOiI0ZzFaUlNvYk1lZnFGNm5lbGtnaWJpIiwiaW1hZ2VzIg==", + "Olt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTQ3OGM4NzU5OTU1MGRkNzNiZmE3ZTAyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjk0NzhjODc1OTk1NTBkZDczYmZhN2UwMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOTQ3OGM4NzU5OTU1MGRkNzNiZmE3ZTAyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhvbGx5d29vZCdzIEJsZWVkaW5nIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wOS0wNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRnMVpSU29iTWVmcUY2bmVsa2dpYmkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xek5xUU5JZGVPVVpIYjh6YlpSRk1YIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6TnFRTklkZU9VWkhiOHpiWlJGTVgiLCJpZCI6IjF6TnFRTklkZU9VWkhiOHpiWlJGTVgiLCJuYW1lIjoiU3dhZSBMZWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpOcVFOSWRlT1VaSGI4emJaUkZNWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTc1NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzE4MTQ4ODgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBSaVJacHVWUmJpN29xUmRTTXdoUVkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wUmlSWnB1VlJiaTdvcVJkU013aFFZIiwiaWQiOiIwUmlSWnB1VlJiaTdvcVJkU013aFFZIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bmZsb3dlciAtIFNwaWRlci1NYW46IEludG8gdA==", + "aGUgU3BpZGVyLVZlcnNlIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowUmlSWnB1VlJiaTdvcVJkU013aFFZIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNwT2o0bW14TDVNVXdSMUlSOExQekwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zcE9qNG1teEw1TVV3UjFJUjhMUHpMIiwiaWQiOiIzcE9qNG1teEw1TVV3UjFJUjhMUHpMIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2VhMGViNjZkNGI4ZmVmNGE4NGM1OTlmZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlYTBlYjY2ZDRiOGZlZjRhODRjNTk5ZmUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVhMGViNjZkNGI4ZmVmNGE4NGM1OTlmZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTcGlkZXItTWFuOiBJbnRvIHRoZSBTcGlkZXItVmVyc2UgKERlbHV4ZSBFZGl0aW9uIC8gU291bmR0cmFjayBGcm9tICYgSW5zcGlyZWQgQnkgVGhlIE1vdGlvbiBQaWN0dXJlKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDItMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozcE9qNG1teEw1TVV3UjFJUjhMUHpMIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwiaWQiOiIyNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwibmFtZSI6IlBvcw==", + "dCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xek5xUU5JZGVPVVpIYjh6YlpSRk1YIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6TnFRTklkZU9VWkhiOHpiWlJGTVgiLCJpZCI6IjF6TnFRTklkZU9VWkhiOHpiWlJGTVgiLCJuYW1lIjoiU3dhZSBMZWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpOcVFOSWRlT1VaSGI4emJaUkZNWCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xU3VwSmxFcHY3UlMydFBOUmFIVmlUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFTdXBKbEVwdjdSUzJ0UE5SYUhWaVQiLCJpZCI6IjFTdXBKbEVwdjdSUzJ0UE5SYUhWaVQiLCJuYW1lIjoiTmlja3kgSmFtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFTdXBKbEVwdjdSUzJ0UE5SYUhWaVQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM01IYVYwNXUwaW84ZlFiWjJYUHRsQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zTUhhVjA1dTBpbzhmUWJaMlhQdGxDIiwiaWQiOiIzTUhhVjA1dTBpbzhmUWJaMlhQdGxDIiwibmFtZSI6IlByaW5jZSBSb3ljZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozTUhhVjA1dTBpbzhmUWJaMlhQdGxDIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdmaVA2bGd4YjZIbFpjcThnRFlDbUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2ZpUDZsZ3hiNkhsWmNxOGdEWUNtRSIsImlkIjoiN2ZpUDZsZ3hiNkhsWmNxOGdEWUNtRSIsIm5hbWUiOiJHLk8uSy5CLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3ZmlQNmxneGI2SGxaY3E4Z0RZQ21FIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxMDAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTkwMjY3OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHd0OVJqZGRPRGxXRGV0cHVhWGZSSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzB3dDlSamRkT0RsV0RldHB1YVhmUksiLA==", + "ImlkIjoiMHd0OVJqZGRPRGxXRGV0cHVhWGZSSyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW5mbG93ZXIgKFJlbWl4KSBbd2l0aCBTd2FlIExlZSwgTmlja3kgSmFtLCBhbmQgUHJpbmNlIFJveWNlXSIsInRyYWNrX251bWJlciI6MTQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHd0OVJqZGRPRGxXRGV0cHVhWGZSSyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zcE9qNG1teEw1TVV3UjFJUjhMUHpMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM3BPajRtbXhMNU1Vd1IxSVI4TFB6TCIsImlkIjoiM3BPajRtbXhMNU1Vd1IxSVI4TFB6TCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlYTBlYjY2ZDRiOGZlZjRhODRjNTk5ZmUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZWEwZWI2NmQ0YjhmZWY0YTg0YzU5OWZlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlYTBlYjY2ZDRiOGZlZjRhODRjNTk5ZmUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3BpZGVyLU1hbjogSW50byB0aGUgU3BpZGVyLVZlcnNlIChEZWx1eGUgRWRpdGlvbiAvIFNvdW5kdHJhY2sgRnJvbSAmIEluc3BpcmVkIEJ5IFRoZSBNb3Rpb24gUGljdHVyZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTAyLTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M3BPajRtbXhMNU1Vd1IxSVI4TFB6TCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVA==", + "dGl5a1hlNWg2MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwiaWQiOiIyNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwibmFtZSI6IlBvc3QgTWFsb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0NmRranZTMXpMVHRpeWtYZTVoNjAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXpOcVFOSWRlT1VaSGI4emJaUkZNWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xek5xUU5JZGVPVVpIYjh6YlpSRk1YIiwiaWQiOiIxek5xUU5JZGVPVVpIYjh6YlpSRk1YIiwibmFtZSI6IlN3YWUgTGVlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF6TnFRTklkZU9VWkhiOHpiWlJGTVgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTU4MDQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxODE0ODg4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83ZGJrYTk5S1RXa2U1bzloUnAwSm9CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2Ria2E5OUtUV2tlNW85aFJwMEpvQiIsImlkIjoiN2Ria2E5OUtUV2tlNW85aFJwMEpvQiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW5mbG93ZXIgLSBTcGlkZXItTWFuOiBJbnRvIHRoZSBTcGlkZXItVmVyc2UiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2Ria2E5OUtUV2tlNW85aFJwMEpvQiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzN4aXE3N1V0bmxEWGZjUno1SUp1MjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zeGlxNzdVdG5sRFhmY1J6NUlKdTIwIiwiaWQiOiIzeGlxNzdVdG5sRA==", + "WGZjUno1SUp1MjAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTFiZjU5N2QyZWQ3NTI4ZGU1M2Y3MWJlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjkxYmY1OTdkMmVkNzUyOGRlNTNmNzFiZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOTFiZjU5N2QyZWQ3NTI4ZGU1M2Y3MWJlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhvbGx5d29vZCdzIEJsZWVkaW5nIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wOS0wNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjN4aXE3N1V0bmxEWGZjUno1SUp1MjAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xek5xUU5JZGVPVVpIYjh6YlpSRk1YIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6TnFRTklkZU9VWkhiOHpiWlJGTVgiLCJpZCI6IjF6TnFRTklkZU9VWkhiOHpiWlJGTVgiLCJuYW1lIjoiU3dhZSBMZWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpOcVFOSWRlT1VaSGI4emJaUkZNWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTc1NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzE4MTQ4ODgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZuWTlnYTU3cGxoQllRblpYME9xZTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82blk5Z2E1N3BsaEJZUW5aWDBPcWU4IiwiaWQiOiI2blk5Z2E1N3BsaEJZUW5aWDBPcWU4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bmZsb3dlcg==", + "IC0gU3BpZGVyLU1hbjogSW50byB0aGUgU3BpZGVyLVZlcnNlIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2blk5Z2E1N3BsaEJZUW5aWDBPcWU4In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJwcFAzYk9yc0RQVUdpa2VPN3hPTzIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8ycHBQM2JPcnNEUFVHaWtlTzd4T08yIiwiaWQiOiIycHBQM2JPcnNEUFVHaWtlTzd4T08yIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2QzNzcyOTgzOTZmZDlmM2FkMmVhNjc0NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkMzc3Mjk4Mzk2ZmQ5ZjNhZDJlYTY3NDYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWQzNzcyOTgzOTZmZDlmM2FkMmVhNjc0NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWxheCBQb3N0LVRyYWJham8iLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTEwLTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MnBwUDNiT3JzRFBVR2lrZU83eE9PMiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVHRpeWtYZTVoNjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsImlkIjoiMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsIm5hbWUiOiJQb3N0IE1hbG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDZka2p2UzF6TFR0aQ==", + "eWtYZTVoNjAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXpOcVFOSWRlT1VaSGI4emJaUkZNWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xek5xUU5JZGVPVVpIYjh6YlpSRk1YIiwiaWQiOiIxek5xUU5JZGVPVVpIYjh6YlpSRk1YIiwibmFtZSI6IlN3YWUgTGVlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF6TnFRTklkZU9VWkhiOHpiWlJGTVgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTU3NTYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxODE0ODg4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wNlBlRlQ2RjVQZ2l3cEE4c3J3dFljIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDZQZUZUNkY1UGdpd3BBOHNyd3RZYyIsImlkIjoiMDZQZUZUNkY1UGdpd3BBOHNyd3RZYyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW5mbG93ZXIgLSBTcGlkZXItTWFuOiBJbnRvIHRoZSBTcGlkZXItVmVyc2UiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MDZQZUZUNkY1UGdpd3BBOHNyd3RZYyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzUwUFQ0NTh6Ym1KNzF0TGpxdmpjb1AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81MFBUNDU4emJtSjcxdExqcXZqY29QIiwiaWQiOiI1MFBUNDU4emJtSjcxdExqcXZqY29QIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRkNDE5NmQwMmNmMjhjYWQ3MDc3ZjExYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYQ==", + "Z2UvYWI2NzYxNmQwMDAwMWUwMjRkNDE5NmQwMmNmMjhjYWQ3MDc3ZjExYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNGQ0MTk2ZDAyY2YyOGNhZDcwNzdmMTFjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBEaWFtb25kIENvbGxlY3Rpb24gKERlbHV4ZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA0LTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NTBQVDQ1OHpibUo3MXRManF2amNvUCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVHRpeWtYZTVoNjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsImlkIjoiMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsIm5hbWUiOiJQb3N0IE1hbG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6TnFRTklkZU9VWkhiOHpiWlJGTVgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpOcVFOSWRlT1VaSGI4emJaUkZNWCIsImlkIjoiMXpOcVFOSWRlT1VaSGI4emJaUkZNWCIsIm5hbWUiOiJTd2FlIExlZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxek5xUU5JZGVPVVpIYjh6YlpSRk1YIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE1NzU1OSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTgxNDg4OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDRQVkNOTWxsOXEwdDVJbWM5SEtPaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQ0UFZDTk1sbDlxMHQ1SW1jOUhLT2giLCJpZCI6IjQ0UFZDTk1sbDlxMHQ1SW1jOUhLT2giLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VuZmxvd2VyIC0gU3BpZGVyLU1hbjogSW50byB0aGUgU3BpZGVyLVZlcnNlIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjQ0UFZDTk1sbDlxMHQ1SW1jOUhLT2gifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7Ig==", + "ZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVkNjVYRmlVZjRmNGZrbWZNcnhiYU0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81ZDY1WEZpVWY0ZjRma21mTXJ4YmFNIiwiaWQiOiI1ZDY1WEZpVWY0ZjRma21mTXJ4YmFNIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzM5Mzc4NjUzZjU5Mjk5YzUxYjgzYjk0MCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzOTM3ODY1M2Y1OTI5OWM1MWI4M2I5NDAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTM5Mzc4NjUzZjU5Mjk5YzUxYjgzYjk0MCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgRGlhbW9uZCBDb2xsZWN0aW9uIChEZWx1eGUpIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wNC0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVkNjVYRmlVZjRmNGZrbWZNcnhiYU0ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xek5xUU5JZGVPVVpIYjh6YlpSRk1YIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6TnFRTklkZU9VWkhiOHpiWg==", + "UkZNWCIsImlkIjoiMXpOcVFOSWRlT1VaSGI4emJaUkZNWCIsIm5hbWUiOiJTd2FlIExlZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxek5xUU5JZGVPVVpIYjh6YlpSRk1YIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE1NzU1OSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTgxNDg4OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2RZNms1bWRxQmN0UE1aYXpUeFl4MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNkWTZrNW1kcUJjdFBNWmF6VHhZeDAiLCJpZCI6IjNkWTZrNW1kcUJjdFBNWmF6VHhZeDAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VuZmxvd2VyIC0gU3BpZGVyLU1hbjogSW50byB0aGUgU3BpZGVyLVZlcnNlIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNkWTZrNW1kcUJjdFBNWmF6VHhZeDAifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwiaWQiOiIyNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwibmFtZSI6IlBvc3QgTWFsb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0NmRranZTMXpMVHRpeWtYZTVoNjAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xbktJSGxxTUN1d2tPMTlMRU9IRjV4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMW5LSUhscU1DdXdrTzE5TEVPSEY1eCIsImlkIjoiMW5LSUhscU1DdXdrTzE5TEVPSEY1eCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzODMxNTkwZGE1OTRhNWY0NTczMzQ1MjgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzgzMTU5MGRhNTk0YTVmNDU3MzM0NTI4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzODMxNTkwZGE1OTRhNWY0NTczMzQ1MjgifV0sImlzX3BsYXlhYmxlIg==", + "OnRydWUsIm5hbWUiOiJUaGUgRGlhbW9uZCBDb2xsZWN0aW9uIChEZWx1eGUpIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wNC0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFuS0lIbHFNQ3V3a08xOUxFT0hGNXgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xek5xUU5JZGVPVVpIYjh6YlpSRk1YIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6TnFRTklkZU9VWkhiOHpiWlJGTVgiLCJpZCI6IjF6TnFRTklkZU9VWkhiOHpiWlJGTVgiLCJuYW1lIjoiU3dhZSBMZWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpOcVFOSWRlT1VaSGI4emJaUkZNWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTc1NTksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzE4MTQ4ODgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzR5OGtyT1pzZ1A1bXBKdEdQMm14N0IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80eThrck9ac2dQNW1wSnRHUDJteDdCIiwiaWQiOiI0eThrck9ac2dQNW1wSnRHUDJteDdCIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bmZsb3dlciAtIFNwaWRlci1NYW46IEludG8gdGhlIFNwaWRlci1WZXJzZSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0eThrck9ac2dQNW1wSnRHUDJteDdCIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Sunflower%22+artist%3A%22Post+Malone%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Sicko%20Mode%22%20artist%3A%22Travis%20Scott%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"}],"external_urls":{"spotify":"https://open.spotify.com/album/41GuZcammIkupMPKH2OJ6I"},"href":"https://api.spotify.com/v1/albums/41GuZcammIkupMPKH2OJ6I","id":"41GuZcammIkupMPKH2OJ6I","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273daec894c14c0ca42d76eeb32"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02daec894c14c0ca42d76eeb32"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851daec894c14c0ca42d76eeb32"}],"is_playable":true,"name":"ASTROWORLD","release_date":"2018-08-03","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:41GuZcammIkupMPKH2OJ6I"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"}],"disc_number":1,"duration_ms":312820,"explicit":true,"external_ids":{"isrc":"USSM11806660"},"external_urls":{"spotify":"https://open.spotify.com/track/2xLMifQCjDGFmkHkpNLD9h"},"href":"https://api.spotify.com/v1/tracks/2xLMifQCjDGFmkHkpNLD9h","id":"2xLMifQCjDGFmkHkpNLD9h","is_local":false,"is_playable":true,"name":"SICKO MODE","track_number":3,"type":"track","uri":"spotify:track:2xLMifQCjDGFmkHkpNLD9h"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5he5w2lnU9x7JFhnwcekXX"},"href":"https://api.spotify.com/v1/artists/5he5w2lnU9x7JFhnwcekXX","id":"5he5w2lnU9x7JFhnwcekXX","name":"Skrillex","type":"artist","uri":"spotify:artist:5he5w2lnU9x7JFhnwcekXX"}],"external_urls":{"spotify":"https://open.spotify.com/album/6TcKoifNw4hO5Nyl3pgwAa"},"href":"https://api.spotify.com/v1/albums/6TcKoifNw4hO5Nyl3pgwAa","id":"6TcKoifNw4hO5Nyl3pgwAa","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27339fe620ab64f37a6b476c94a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0239fe620ab64f37a6b476c94a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485139fe620ab64f37a6b476c94a"}],"is_playable":true,"name":"SICKO MODE (Skrillex Remix)","release_date":"2018-11-28","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6TcKoifNw4hO5Nyl3pgwAa"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5he5w2lnU9x7JFhnwcekXX"},"href":"https://api.spotify.com/v1/artists/5he5w2lnU9x7JFhnwcekXX","id":"5he5w2lnU9x7JFhnwcekXX","name":"Skrillex","type":"artist","uri":"spotify:artist:5he5w2lnU9x7JFhnwcekXX"}],"disc_number":1,"duration_ms":304512,"explicit":true,"external_ids":{"isrc":"USSM11808418"},"external_urls":{"spotify":"https://open.spotify.com/track/0u695M7KyzXaPIjpEbxOkB"},"href":"https://api.spotify.com/v1/tracks/0u695M7KyzXaPIjpEbxOkB","id":"0u695M7KyzXaPIjpEbxOkB","is_local":false,"is_playable":true,"name":"SICKO MODE - Skrillex Remix","track_number":1,"type":"track","uri":"spotify:track:0u695M7KyzXaPIjpEbxOkB"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/438iIqGkqrFzCCz2TvWOvy"},"href":"https://api.spotify.com/v1/albums/438iIqGkqrFzCCz2TvWOvy","id":"438iIqGkqrFzCCz2TvWOvy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734d902bfbdfa274d167af7d10"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024d902bfbdfa274d167af7d10"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514d902bfbdfa274d167af7d10"}],"is_playable":true,"name":"Bail\u00e3o da Virada - Top Hits 2024/2025","release_date":"2024-12-07","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:438iIqGkqrFzCCz2TvWOvy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"}],"disc_number":1,"duration_ms":312820,"explicit":true,"external_ids":{"isrc":"USSM11806660"},"external_urls":{"spotify":"https://open.spotify.com/track/68XcmlQpxF4oIXbmHBpZA9"},"href":"https://api.spotify.com/v1/tracks/68XcmlQpxF4oIXbmHBpZA9","id":"68XcmlQpxF4oIXbmHBpZA9","is_local":false,"is_playable":true,"name":"SICKO MODE","track_number":43,"type":"track","uri":"spotify:track:68XcmlQpxF4oIXbmHBpZA9"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QHcMgHxTM4vNdhyK6MmaU"},"href":"https://api.spotify.com/v1/albums/3QHcMgHxTM4vNdhyK6MmaU","id":"3QHcMgHxTM4vNdhyK6MmaU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273278cff111ee817e32ac889e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02278cff111ee817e32ac889e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851278cff111ee817e32ac889e7"}],"is_playable":true,"name":"Hip-Hop das Antigas - de 2000 at\u00e9 2010","release_date":"2024-12-22","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:3QHcMgHxTM4vNdhyK6MmaU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"}],"disc_number":1,"duration_ms":312820,"explicit":true,"external_ids":{"isrc":"USSM11806660"},"external_urls":{"spotify":"https://open.spotify.com/track/0D53ns7GLd782vrRxqK1AH"},"href":"https://api.spotify.com/v1/tracks/0D53ns7GLd782vrRxqK1AH","id":"0D53ns7GLd782vrRxqK1AH","is_local":false,"is_playable":true,"name":"SICKO MODE","track_number":25,"type":"track","uri":"spotify:track:0D53ns7GLd782vrRxqK1AH"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Sicko%20Mode%22%20artist%3A%22Travis%20Scott%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"}],"external_urls":{"spotify":"https://open.spotify.com/album/41GuZcammIkupMPKH2OJ6I"},"href":"https://api.spotify.com/v1/albums/41GuZcammIkupMPKH2OJ6I","id":"41GuZcammIkupMPKH2OJ6I","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273daec894c14c0ca42d76eeb32"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02daec894c14c0ca42d76eeb32"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851daec894c14c0ca42d76eeb32"}],"is_playable":true,"name":"ASTROWORLD","release_date":"2018-08-03","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:41GuZcammIkupMPKH2OJ6I"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"}],"disc_number":1,"duration_ms":312820,"explicit":true,"external_ids":{"isrc":"USSM11806660"},"external_urls":{"spotify":"https://open.spotify.com/track/2xLMifQCjDGFmkHkpNLD9h"},"href":"https://api.spotify.com/v1/tracks/2xLMifQCjDGFmkHkpNLD9h","id":"2xLMifQCjDGFmkHkpNLD9h","is_local":false,"is_playable":true,"name":"SICKO MODE","track_number":3,"type":"track","uri":"spotify:track:2xLMifQCjDGFmkHkpNLD9h"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5he5w2lnU9x7JFhnwcekXX"},"href":"https://api.spotify.com/v1/artists/5he5w2lnU9x7JFhnwcekXX","id":"5he5w2lnU9x7JFhnwcekXX","name":"Skrillex","type":"artist","uri":"spotify:artist:5he5w2lnU9x7JFhnwcekXX"}],"external_urls":{"spotify":"https://open.spotify.com/album/6TcKoifNw4hO5Nyl3pgwAa"},"href":"https://api.spotify.com/v1/albums/6TcKoifNw4hO5Nyl3pgwAa","id":"6TcKoifNw4hO5Nyl3pgwAa","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27339fe620ab64f37a6b476c94a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0239fe620ab64f37a6b476c94a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485139fe620ab64f37a6b476c94a"}],"is_playable":true,"name":"SICKO MODE (Skrillex Remix)","release_date":"2018-11-28","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6TcKoifNw4hO5Nyl3pgwAa"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5he5w2lnU9x7JFhnwcekXX"},"href":"https://api.spotify.com/v1/artists/5he5w2lnU9x7JFhnwcekXX","id":"5he5w2lnU9x7JFhnwcekXX","name":"Skrillex","type":"artist","uri":"spotify:artist:5he5w2lnU9x7JFhnwcekXX"}],"disc_number":1,"duration_ms":304512,"explicit":true,"external_ids":{"isrc":"USSM11808418"},"external_urls":{"spotify":"https://open.spotify.com/track/0u695M7KyzXaPIjpEbxOkB"},"href":"https://api.spotify.com/v1/tracks/0u695M7KyzXaPIjpEbxOkB","id":"0u695M7KyzXaPIjpEbxOkB","is_local":false,"is_playable":true,"name":"SICKO MODE - Skrillex Remix","track_number":1,"type":"track","uri":"spotify:track:0u695M7KyzXaPIjpEbxOkB"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/438iIqGkqrFzCCz2TvWOvy"},"href":"https://api.spotify.com/v1/albums/438iIqGkqrFzCCz2TvWOvy","id":"438iIqGkqrFzCCz2TvWOvy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734d902bfbdfa274d167af7d10"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024d902bfbdfa274d167af7d10"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514d902bfbdfa274d167af7d10"}],"is_playable":true,"name":"Bail\u00e3o da Virada - Top Hits 2024/2025","release_date":"2024-12-07","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:438iIqGkqrFzCCz2TvWOvy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"}],"disc_number":1,"duration_ms":312820,"explicit":true,"external_ids":{"isrc":"USSM11806660"},"external_urls":{"spotify":"https://open.spotify.com/track/68XcmlQpxF4oIXbmHBpZA9"},"href":"https://api.spotify.com/v1/tracks/68XcmlQpxF4oIXbmHBpZA9","id":"68XcmlQpxF4oIXbmHBpZA9","is_local":false,"is_playable":true,"name":"SICKO MODE","track_number":43,"type":"track","uri":"spotify:track:68XcmlQpxF4oIXbmHBpZA9"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QHcMgHxTM4vNdhyK6MmaU"},"href":"https://api.spotify.com/v1/albums/3QHcMgHxTM4vNdhyK6MmaU","id":"3QHcMgHxTM4vNdhyK6MmaU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273278cff111ee817e32ac889e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02278cff111ee817e32ac889e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851278cff111ee817e32ac889e7"}],"is_playable":true,"name":"Hip-Hop das Antigas - de 2000 at\u00e9 2010","release_date":"2024-12-22","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:3QHcMgHxTM4vNdhyK6MmaU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Y5tJX1MQlPlqiwlOH1tJY"},"href":"https://api.spotify.com/v1/artists/0Y5tJX1MQlPlqiwlOH1tJY","id":"0Y5tJX1MQlPlqiwlOH1tJY","name":"Travis Scott","type":"artist","uri":"spotify:artist:0Y5tJX1MQlPlqiwlOH1tJY"}],"disc_number":1,"duration_ms":312820,"explicit":true,"external_ids":{"isrc":"USSM11806660"},"external_urls":{"spotify":"https://open.spotify.com/track/0D53ns7GLd782vrRxqK1AH"},"href":"https://api.spotify.com/v1/tracks/0D53ns7GLd782vrRxqK1AH","id":"0D53ns7GLd782vrRxqK1AH","is_local":false,"is_playable":true,"name":"SICKO MODE","track_number":25,"type":"track","uri":"spotify:track:0D53ns7GLd782vrRxqK1AH"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Sicko+Mode%22+artist%3A%22Travis+Scott%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Sweater%20Weather%22%20artist%3A%22The%20Neighbourhood%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"external_urls":{"spotify":"https://open.spotify.com/album/4xkM0BwLM9H2IUcbYzpcBI"},"href":"https://api.spotify.com/v1/albums/4xkM0BwLM9H2IUcbYzpcBI","id":"4xkM0BwLM9H2IUcbYzpcBI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738265a736a1eb838ad5a0b921"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028265a736a1eb838ad5a0b921"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518265a736a1eb838ad5a0b921"}],"is_playable":true,"name":"I Love You.","release_date":"2013-04-22","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4xkM0BwLM9H2IUcbYzpcBI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":240400,"explicit":false,"external_ids":{"isrc":"USSM11300080"},"external_urls":{"spotify":"https://open.spotify.com/track/2QjOHCTQ1Jl3zawyYOpxh6"},"href":"https://api.spotify.com/v1/tracks/2QjOHCTQ1Jl3zawyYOpxh6","id":"2QjOHCTQ1Jl3zawyYOpxh6","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":4,"type":"track","uri":"spotify:track:2QjOHCTQ1Jl3zawyYOpxh6"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FRfJyV85zb19tO6uiXBGl"},"href":"https://api.spotify.com/v1/artists/2FRfJyV85zb19tO6uiXBGl","id":"2FRfJyV85zb19tO6uiXBGl","name":"sped up + slowed","type":"artist","uri":"spotify:artist:2FRfJyV85zb19tO6uiXBGl"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nDM0bDRJ1Ni1sMzx7YQ0J"},"href":"https://api.spotify.com/v1/albums/6nDM0bDRJ1Ni1sMzx7YQ0J","id":"6nDM0bDRJ1Ni1sMzx7YQ0J","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b46be90f276243fdd995cf83"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b46be90f276243fdd995cf83"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b46be90f276243fdd995cf83"}],"is_playable":true,"name":"I Love You. (Sped Up)","release_date":"2013-04-22","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:6nDM0bDRJ1Ni1sMzx7YQ0J"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":218938,"explicit":false,"external_ids":{"isrc":"USSM12302374"},"external_urls":{"spotify":"https://open.spotify.com/track/5HzMZWEwP8baubqhmpjX75"},"href":"https://api.spotify.com/v1/tracks/5HzMZWEwP8baubqhmpjX75","id":"5HzMZWEwP8baubqhmpjX75","is_local":false,"is_playable":true,"name":"Sweater Weather - Sped Up","track_number":4,"type":"track","uri":"spotify:track:5HzMZWEwP8baubqhmpjX75"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"external_urls":{"spotify":"https://open.spotify.com/album/64uUQtKfndQguejYmA40lL"},"href":"https://api.spotify.com/v1/albums/64uUQtKfndQguejYmA40lL","id":"64uUQtKfndQguejYmA40lL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737177fb5667cdafd34b871257"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027177fb5667cdafd34b871257"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517177fb5667cdafd34b871257"}],"is_playable":true,"name":"I'm Sorry...","release_date":"2012-08-07","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:64uUQtKfndQguejYmA40lL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":240040,"explicit":false,"external_ids":{"isrc":"USSM11204647"},"external_urls":{"spotify":"https://open.spotify.com/track/4pGqFOfzvfe6avb9kbZicC"},"href":"https://api.spotify.com/v1/tracks/4pGqFOfzvfe6avb9kbZicC","id":"4pGqFOfzvfe6avb9kbZicC","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":4,"type":"track","uri":"spotify:track:4pGqFOfzvfe6avb9kbZicC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FRfJyV85zb19tO6uiXBGl"},"href":"https://api.spotify.com/v1/artists/2FRfJyV85zb19tO6uiXBGl","id":"2FRfJyV85zb19tO6uiXBGl","name":"sped up + slowed","type":"artist","uri":"spotify:artist:2FRfJyV85zb19tO6uiXBGl"}],"external_urls":{"spotify":"https://open.spotify.com/album/742rc3IvCNtvhEZIsjLfyu"},"href":"https://api.spotify.com/v1/albums/742rc3IvCNtvhEZIsjLfyu","id":"742rc3IvCNtvhEZIsjLfyu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb85ef5503fd690ed5a8497b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb85ef5503fd690ed5a8497b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb85ef5503fd690ed5a8497b"}],"is_playable":true,"name":"I Love You. (Slowed Down)","release_date":"2013-04-23","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:742rc3IvCNtvhEZIsjLfyu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":301144,"explicit":false,"external_ids":{"isrc":"USSM12302385"},"external_urls":{"spotify":"https://open.spotify.com/track/6jhzQyn6cwPHc85PE4qBp0"},"href":"https://api.spotify.com/v1/tracks/6jhzQyn6cwPHc85PE4qBp0","id":"6jhzQyn6cwPHc85PE4qBp0","is_local":false,"is_playable":true,"name":"Sweater Weather - Slowed Down","track_number":4,"type":"track","uri":"spotify:track:6jhzQyn6cwPHc85PE4qBp0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"external_urls":{"spotify":"https://open.spotify.com/album/5n7S9xN6tYY8aGJU3kE0Va"},"href":"https://api.spotify.com/v1/albums/5n7S9xN6tYY8aGJU3kE0Va","id":"5n7S9xN6tYY8aGJU3kE0Va","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273354be6d543058b65075b9d16"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02354be6d543058b65075b9d16"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851354be6d543058b65075b9d16"}],"is_playable":true,"name":"I Love You. (10th Anniversary Edition)","release_date":"2013-04-23","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:5n7S9xN6tYY8aGJU3kE0Va"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":240400,"explicit":false,"external_ids":{"isrc":"USSM11300891"},"external_urls":{"spotify":"https://open.spotify.com/track/00xYOITpx6SEi1ntfdlA39"},"href":"https://api.spotify.com/v1/tracks/00xYOITpx6SEi1ntfdlA39","id":"00xYOITpx6SEi1ntfdlA39","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":4,"type":"track","uri":"spotify:track:00xYOITpx6SEi1ntfdlA39"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ayY1GNvCgBfu0U9WoOeie"},"href":"https://api.spotify.com/v1/albums/4ayY1GNvCgBfu0U9WoOeie","id":"4ayY1GNvCgBfu0U9WoOeie","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273893c4569e7b9779f3489b665"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02893c4569e7b9779f3489b665"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851893c4569e7b9779f3489b665"}],"is_playable":true,"name":"Viral TikTok Hits 2022 | 2023","release_date":"2022-12-16","release_date_precision":"day","total_tracks":74,"type":"album","uri":"spotify:album:4ayY1GNvCgBfu0U9WoOeie"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":239813,"explicit":false,"external_ids":{"isrc":"USSM11300080"},"external_urls":{"spotify":"https://open.spotify.com/track/00RAEgcN1xhaMulI5Zl9HG"},"href":"https://api.spotify.com/v1/tracks/00RAEgcN1xhaMulI5Zl9HG","id":"00RAEgcN1xhaMulI5Zl9HG","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":62,"type":"track","uri":"spotify:track:00RAEgcN1xhaMulI5Zl9HG"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2c3LBDNnptvWquptllUuyq"},"href":"https://api.spotify.com/v1/albums/2c3LBDNnptvWquptllUuyq","id":"2c3LBDNnptvWquptllUuyq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273659ba1ce127df61286fa26e1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02659ba1ce127df61286fa26e1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851659ba1ce127df61286fa26e1"}],"is_playable":true,"name":"Spooky Halloween Hits","release_date":"2022-10-03","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:2c3LBDNnptvWquptllUuyq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":240400,"explicit":false,"external_ids":{"isrc":"USSM11300080"},"external_urls":{"spotify":"https://open.spotify.com/track/0MHJpqfSeUIt5Xtjqbzssm"},"href":"https://api.spotify.com/v1/tracks/0MHJpqfSeUIt5Xtjqbzssm","id":"0MHJpqfSeUIt5Xtjqbzssm","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":8,"type":"track","uri":"spotify:track:0MHJpqfSeUIt5Xtjqbzssm"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN3ZWF0ZXIlMjBXZWF0aGVyJTIyJTIwYXJ0aXN0JTNBJTIyVGhlJTIwTmVpZ2hib3VyaG9vZCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N1NXOUJueExZOHJKMFJjaUZxa0hoIiwiaWQiOiI3N1NXOUJueExZOHJKMFJjaUZxa0hoIiwibmFtZSI6IlRoZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80eGtNMEJ3TE05SDJJVWNiWXpwY0JJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHhrTTBCd0xNOUgySVVjYll6cGNCSSIsImlkIjoiNHhrTTBCd0xNOUgySVVjYll6cGNCSSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4MjY1YTczNmExZWI4MzhhZDVhMGI5MjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODI2NWE3MzZhMWViODM4YWQ1YTBiOTIxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4MjY1YTczNmExZWI4MzhhZDVhMGI5MjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSBMb3ZlIFlvdS4iLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTA0LTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NHhrTTBCd0xNOUgySVVjYll6cGNCSSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaGUgTmVpZ2hib3VyaG9vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N1NXOUJueExZOHJKMFJjaUZxa0hoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMTMwMDA4MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMlFqT0hDVFExSmwzemF3eVlPcHhoNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJRak9IQ1RRMUpsM3phd3lZT3B4aDYiLCJpZCI6IjJRak9IQ1RRMUpsM3phd3lZT3B4aDYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3dlYXRlciBXZWF0aGVyIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJRak9IQ1RRMUpsM3phd3lZT3B4aDYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkZSZkp5Vjg1emIxOXRPNnVpWEJHbCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRlJmSnlWODV6YjE5dE82dWlYQkdsIiwiaWQiOiIyRlJmSnlWODV6YjE5dE82dWlYQkdsIiwibmFtZSI6InNwZQ==", + "ZCB1cCArIHNsb3dlZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRlJmSnlWODV6YjE5dE82dWlYQkdsIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNm5ETTBiRFJKMU5pMXNNeng3WVEwSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZuRE0wYkRSSjFOaTFzTXp4N1lRMEoiLCJpZCI6IjZuRE0wYkRSSjFOaTFzTXp4N1lRMEoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjQ2YmU5MGYyNzYyNDNmZGQ5OTVjZjgzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmI0NmJlOTBmMjc2MjQzZmRkOTk1Y2Y4MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjQ2YmU5MGYyNzYyNDNmZGQ5OTVjZjgzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkkgTG92ZSBZb3UuIChTcGVkIFVwKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDQtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2bkRNMGJEUkoxTmkxc016eDdZUTBKIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N1NXOUJueExZOHJKMFJjaUZxa0hoIiwiaWQiOiI3N1NXOUJueExZOHJKMFJjaUZxa0hoIiwibmFtZSI6IlRoZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE4OTM4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEyMzAyMzc0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81SHpNWldFd1A4YmF1YnFobXBqWDc1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUh6TVpXRXdQOGJhdWJxaG1walg3NSIsImlkIjoiNUh6TVpXRXdQOGJhdWJxaG1walg3NSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTd2VhdGVyIFdlYXRoZXIgLSBTcA==", + "ZWQgVXAiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUh6TVpXRXdQOGJhdWJxaG1walg3NSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N1NXOUJueExZOHJKMFJjaUZxa0hoIiwiaWQiOiI3N1NXOUJueExZOHJKMFJjaUZxa0hoIiwibmFtZSI6IlRoZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82NHVVUXRLZm5kUWd1ZWpZbUE0MGxMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjR1VVF0S2ZuZFFndWVqWW1BNDBsTCIsImlkIjoiNjR1VVF0S2ZuZFFndWVqWW1BNDBsTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3MTc3ZmI1NjY3Y2RhZmQzNGI4NzEyNTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzE3N2ZiNTY2N2NkYWZkMzRiODcxMjU3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3MTc3ZmI1NjY3Y2RhZmQzNGI4NzEyNTcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSdtIFNvcnJ5Li4uIiwicmVsZWFzZV9kYXRlIjoiMjAxMi0wOC0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NjR1VVF0S2ZuZFFndWVqWW1BNDBsTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaGUgTmVpZ2hib3VyaG9vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N1NXOUJueExZOHJKMFJjaUZxa0hoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpbw==", + "bl9tcyI6MjQwMDQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTExMjA0NjQ3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80cEdxRk9menZmZTZhdmI5a2JaaWNDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNHBHcUZPZnp2ZmU2YXZiOWtiWmljQyIsImlkIjoiNHBHcUZPZnp2ZmU2YXZiOWtiWmljQyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTd2VhdGVyIFdlYXRoZXIiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NHBHcUZPZnp2ZmU2YXZiOWtiWmljQyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRlJmSnlWODV6YjE5dE82dWlYQkdsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJGUmZKeVY4NXpiMTl0TzZ1aVhCR2wiLCJpZCI6IjJGUmZKeVY4NXpiMTl0TzZ1aVhCR2wiLCJuYW1lIjoic3BlZCB1cCArIHNsb3dlZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRlJmSnlWODV6YjE5dE82dWlYQkdsIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzQycmMzSXZDTnR2aEVaSXNqTGZ5dSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc0MnJjM0l2Q050dmhFWklzakxmeXUiLCJpZCI6Ijc0MnJjM0l2Q050dmhFWklzakxmeXUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmI4NWVmNTUwM2ZkNjkwZWQ1YTg0OTdiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZiODVlZjU1MDNmZDY5MGVkNWE4NDk3YiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmI4NWVmNTUwM2ZkNjkwZWQ1YTg0OTdiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkkgTG92ZSBZb3UuIChTbG93ZWQgRG93bikiLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTA0LTIzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzQycmMzSXZDTnR2aEVaSXNqTA==", + "Znl1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N1NXOUJueExZOHJKMFJjaUZxa0hoIiwiaWQiOiI3N1NXOUJueExZOHJKMFJjaUZxa0hoIiwibmFtZSI6IlRoZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzAxMTQ0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEyMzAyMzg1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82amh6UXluNmN3UEhjODVQRTRxQnAwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmpoelF5bjZjd1BIYzg1UEU0cUJwMCIsImlkIjoiNmpoelF5bjZjd1BIYzg1UEU0cUJwMCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTd2VhdGVyIFdlYXRoZXIgLSBTbG93ZWQgRG93biIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2amh6UXluNmN3UEhjODVQRTRxQnAwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaGUgTmVpZ2hib3VyaG9vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N1NXOUJueExZOHJKMFJjaUZxa0hoIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNW43Uzl4TjZ0WVk4YUdKVTNrRTBWYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVuN1M5eE42dFlZOGFHSlUza0UwVmEiLCJpZCI6IjVuN1M5eE42dFlZOGFHSlUza0UwVmEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzU0YmU2ZDU0MzA1OGI2NTA3NWI5ZDE2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZw==", + "ZS9hYjY3NjE2ZDAwMDAxZTAyMzU0YmU2ZDU0MzA1OGI2NTA3NWI5ZDE2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzNTRiZTZkNTQzMDU4YjY1MDc1YjlkMTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSBMb3ZlIFlvdS4gKDEwdGggQW5uaXZlcnNhcnkgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTA0LTIzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NW43Uzl4TjZ0WVk4YUdKVTNrRTBWYSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaGUgTmVpZ2hib3VyaG9vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N1NXOUJueExZOHJKMFJjaUZxa0hoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMTMwMDg5MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMDB4WU9JVHB4NlNFaTFudGZkbEEzOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzAweFlPSVRweDZTRWkxbnRmZGxBMzkiLCJpZCI6IjAweFlPSVRweDZTRWkxbnRmZGxBMzkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3dlYXRlciBXZWF0aGVyIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjAweFlPSVRweDZTRWkxbnRmZGxBMzkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cg==", + "bHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80YXlZMUdOdkNnQmZ1MFU5V29PZWllIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNGF5WTFHTnZDZ0JmdTBVOVdvT2VpZSIsImlkIjoiNGF5WTFHTnZDZ0JmdTBVOVdvT2VpZSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4OTNjNDU2OWU3Yjk3NzlmMzQ4OWI2NjUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODkzYzQ1NjllN2I5Nzc5ZjM0ODliNjY1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4OTNjNDU2OWU3Yjk3NzlmMzQ4OWI2NjUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVmlyYWwgVGlrVG9rIEhpdHMgMjAyMiB8IDIwMjMiLCJyZWxlYXNlX2RhdGUiOiIyMDIyLTEyLTE2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NzQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NGF5WTFHTnZDZ0JmdTBVOVdvT2VpZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaGUgTmVpZ2hib3VyaG9vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N1NXOUJueExZOHJKMFJjaUZxa0hoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzOTgxMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMTMwMDA4MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMDBSQUVnY04xeGhhTXVsSTVabDlIRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzAwUkFFZ2NOMXhoYU11bEk1Wmw5SEciLCJpZCI6IjAwUkFFZ2NOMXhoYU11bEk1Wmw5SEciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3dlYXRlciBXZWF0aGVyIiwidHJhY2tfbnVtYmVyIjo2MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowMFJBRWdjTjF4aGFNdWxJNVpsOUhHIn0seyJhbGJ1bQ==", + "Ijp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMmMzTEJETm5wdHZXcXVwdGxsVXV5cSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJjM0xCRE5ucHR2V3F1cHRsbFV1eXEiLCJpZCI6IjJjM0xCRE5ucHR2V3F1cHRsbFV1eXEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNjU5YmExY2UxMjdkZjYxMjg2ZmEyNmUxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjY1OWJhMWNlMTI3ZGY2MTI4NmZhMjZlMSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjU5YmExY2UxMjdkZjYxMjg2ZmEyNmUxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNwb29reSBIYWxsb3dlZW4gSGl0cyIsInJlbGVhc2VfZGF0ZSI6IjIwMjItMTAtMDMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyYzNMQkRObnB0dldxdXB0bGxVdXlxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N1NXOUJueExZOHJKMFJjaUZxa0hoIiwiaWQiOiI3N1NXOUJueExZOHJKMFJjaUZxa0hoIiwibmFtZSI6IlRoZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQwNDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTExMzAwMDgwIn0sImV4dGVybmFsXw==", + "dXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBNSEpwcWZTZVVJdDVYdGpxYnpzc20ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wTUhKcHFmU2VVSXQ1WHRqcWJ6c3NtIiwiaWQiOiIwTUhKcHFmU2VVSXQ1WHRqcWJ6c3NtIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN3ZWF0ZXIgV2VhdGhlciIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowTUhKcHFmU2VVSXQ1WHRqcWJ6c3NtIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Sweater+Weather%22+artist%3A%22The+Neighbourhood%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlR3byUyMFdlZWtzJTIyJTIwYXJ0aXN0JTNBJTIyRktBJTIwdHdpZ3MlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZuQjBpWTFjalNZMUt5aFl5dUlJS0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm5CMGlZMWNqU1kxS3loWXl1SUlLSCIsImlkIjoiNm5CMGlZMWNqU1kxS3loWXl1SUlLSCIsIm5hbWUiOiJGS0EgdHdpZ3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm5CMGlZMWNqU1kxS3loWXl1SUlLSCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzI1UFF4aTlTUjFPT0RCNVhHNm00OEoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yNVBReGk5U1IxT09EQjVYRzZtNDhKIiwiaWQiOiIyNVBReGk5U1IxT09EQjVYRzZtNDhKIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZw==", + "ZS9hYjY3NjE2ZDAwMDBiMjczNzdhMzlhNGUxZDVkMGYyNGRhYzExMzBhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjc3YTM5YTRlMWQ1ZDBmMjRkYWMxMTMwYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzdhMzlhNGUxZDVkMGYyNGRhYzExMzBhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxQMSIsInJlbGVhc2VfZGF0ZSI6IjIwMTQtMDgtMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyNVBReGk5U1IxT09EQjVYRzZtNDhKIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm5CMGlZMWNqU1kxS3loWXl1SUlLSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bkIwaVkxY2pTWTFLeWhZeXVJSUtIIiwiaWQiOiI2bkIwaVkxY2pTWTFLeWhZeXVJSUtIIiwibmFtZSI6IkZLQSB0d2lncyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bkIwaVkxY2pTWTFLeWhZeXVJSUtIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NzU0NywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JCS1MxNDAwMjI3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82VjBMWDBoUDFTMHFINTEzQ0NoQUt0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNlYwTFgwaFAxUzBxSDUxM0NDaEFLdCIsImlkIjoiNlYwTFgwaFAxUzBxSDUxM0NDaEFLdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUd28gV2Vla3MiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NlYwTFgwaFAxUzBxSDUxM0NDaEFLdCJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Two+Weeks%22+artist%3A%22FKA+twigs%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Electric%20Feel%22%20artist%3A%22MGMT%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/6mm1Skz3JE6AXneya9Nyiv"},"href":"https://api.spotify.com/v1/albums/6mm1Skz3JE6AXneya9Nyiv","id":"6mm1Skz3JE6AXneya9Nyiv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273abdf7749aeb5229dbf305f03"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02abdf7749aeb5229dbf305f03"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851abdf7749aeb5229dbf305f03"}],"is_playable":true,"name":"Oracular Spectacular","release_date":"2007-12-14","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:6mm1Skz3JE6AXneya9Nyiv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":229640,"explicit":false,"external_ids":{"isrc":"USSM10702131"},"external_urls":{"spotify":"https://open.spotify.com/track/3FtYbEfBqAlGO46NUDQSAt"},"href":"https://api.spotify.com/v1/tracks/3FtYbEfBqAlGO46NUDQSAt","id":"3FtYbEfBqAlGO46NUDQSAt","is_local":false,"is_playable":true,"name":"Electric Feel","track_number":4,"type":"track","uri":"spotify:track:3FtYbEfBqAlGO46NUDQSAt"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/6wqufLWm8D5CUPB9A11opq"},"href":"https://api.spotify.com/v1/albums/6wqufLWm8D5CUPB9A11opq","id":"6wqufLWm8D5CUPB9A11opq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a798fc88faec4742d22c59d6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a798fc88faec4742d22c59d6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a798fc88faec4742d22c59d6"}],"is_playable":true,"name":"Electric Feel (Justice Remix)","release_date":"2008-07-15","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6wqufLWm8D5CUPB9A11opq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1gR0gsQYfi6joyO1dlp76N"},"href":"https://api.spotify.com/v1/artists/1gR0gsQYfi6joyO1dlp76N","id":"1gR0gsQYfi6joyO1dlp76N","name":"Justice","type":"artist","uri":"spotify:artist:1gR0gsQYfi6joyO1dlp76N"}],"disc_number":1,"duration_ms":327386,"explicit":false,"external_ids":{"isrc":"USSM10802119"},"external_urls":{"spotify":"https://open.spotify.com/track/2eGHyarZyRvUgFI4d3G8GN"},"href":"https://api.spotify.com/v1/tracks/2eGHyarZyRvUgFI4d3G8GN","id":"2eGHyarZyRvUgFI4d3G8GN","is_local":false,"is_playable":true,"name":"Electric Feel - Justice Remix","track_number":1,"type":"track","uri":"spotify:track:2eGHyarZyRvUgFI4d3G8GN"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/5wj6QWEUEvPnNO3A5QUt4c"},"href":"https://api.spotify.com/v1/albums/5wj6QWEUEvPnNO3A5QUt4c","id":"5wj6QWEUEvPnNO3A5QUt4c","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738cd8e60c899eae6f2a54704a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028cd8e60c899eae6f2a54704a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518cd8e60c899eae6f2a54704a"}],"is_playable":true,"name":"Electric Feel","release_date":"2008-06-20","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:5wj6QWEUEvPnNO3A5QUt4c"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":231746,"explicit":false,"external_ids":{"isrc":"USSM10802071"},"external_urls":{"spotify":"https://open.spotify.com/track/6GTmGEAiR9pyWN5f1lgXSt"},"href":"https://api.spotify.com/v1/tracks/6GTmGEAiR9pyWN5f1lgXSt","id":"6GTmGEAiR9pyWN5f1lgXSt","is_local":false,"is_playable":true,"name":"Electric Feel - Video Mix","track_number":1,"type":"track","uri":"spotify:track:6GTmGEAiR9pyWN5f1lgXSt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tn4OkXyDMemo4zWthSdu0"},"href":"https://api.spotify.com/v1/albums/0tn4OkXyDMemo4zWthSdu0","id":"0tn4OkXyDMemo4zWthSdu0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273881c6a903ecc697df91d5d44"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02881c6a903ecc697df91d5d44"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851881c6a903ecc697df91d5d44"}],"is_playable":true,"name":"Oracular Spectacular","release_date":"2008-02-11","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0tn4OkXyDMemo4zWthSdu0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":229640,"explicit":false,"external_ids":{"isrc":"USSM10702131"},"external_urls":{"spotify":"https://open.spotify.com/track/4is2Cqz6AkcLXPwuJl7sUB"},"href":"https://api.spotify.com/v1/tracks/4is2Cqz6AkcLXPwuJl7sUB","id":"4is2Cqz6AkcLXPwuJl7sUB","is_local":false,"is_playable":true,"name":"Electric Feel","track_number":4,"type":"track","uri":"spotify:track:4is2Cqz6AkcLXPwuJl7sUB"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0jVGdTKQ0pValbbtxv5h5O"},"href":"https://api.spotify.com/v1/albums/0jVGdTKQ0pValbbtxv5h5O","id":"0jVGdTKQ0pValbbtxv5h5O","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b33e4b3384a7a0428f990757"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b33e4b3384a7a0428f990757"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b33e4b3384a7a0428f990757"}],"is_playable":true,"name":"Happiness Forever","release_date":"2018-04-10","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0jVGdTKQ0pValbbtxv5h5O"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":229640,"explicit":false,"external_ids":{"isrc":"USSM10702131"},"external_urls":{"spotify":"https://open.spotify.com/track/1gWCykFM4bhEKeQE86Qozf"},"href":"https://api.spotify.com/v1/tracks/1gWCykFM4bhEKeQE86Qozf","id":"1gWCykFM4bhEKeQE86Qozf","is_local":false,"is_playable":true,"name":"Electric Feel","track_number":43,"type":"track","uri":"spotify:track:1gWCykFM4bhEKeQE86Qozf"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/75UkH5p5wLpU5utEcYd9qX"},"href":"https://api.spotify.com/v1/albums/75UkH5p5wLpU5utEcYd9qX","id":"75UkH5p5wLpU5utEcYd9qX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f12525c572cf4d7e69c05a91"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f12525c572cf4d7e69c05a91"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f12525c572cf4d7e69c05a91"}],"is_playable":true,"name":"Happy Summer Songs","release_date":"2022-05-26","release_date_precision":"day","total_tracks":49,"type":"album","uri":"spotify:album:75UkH5p5wLpU5utEcYd9qX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":229640,"explicit":false,"external_ids":{"isrc":"USSM10702131"},"external_urls":{"spotify":"https://open.spotify.com/track/2gtEpCpKUt1R4Plk6Qs9ld"},"href":"https://api.spotify.com/v1/tracks/2gtEpCpKUt1R4Plk6Qs9ld","id":"2gtEpCpKUt1R4Plk6Qs9ld","is_local":false,"is_playable":true,"name":"Electric Feel","track_number":26,"type":"track","uri":"spotify:track:2gtEpCpKUt1R4Plk6Qs9ld"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7uwawRuxHhKsxeesnevBQn"},"href":"https://api.spotify.com/v1/albums/7uwawRuxHhKsxeesnevBQn","id":"7uwawRuxHhKsxeesnevBQn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27349bfa451ba88ffdd6476f54a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0249bfa451ba88ffdd6476f54a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485149bfa451ba88ffdd6476f54a"}],"is_playable":true,"name":"Surf Music Chill","release_date":"2018-08-31","release_date_precision":"day","total_tracks":38,"type":"album","uri":"spotify:album:7uwawRuxHhKsxeesnevBQn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":229640,"explicit":false,"external_ids":{"isrc":"USSM10702131"},"external_urls":{"spotify":"https://open.spotify.com/track/5V89ZHZcrESRu9ijeCPt3a"},"href":"https://api.spotify.com/v1/tracks/5V89ZHZcrESRu9ijeCPt3a","id":"5V89ZHZcrESRu9ijeCPt3a","is_local":false,"is_playable":true,"name":"Electric Feel","track_number":13,"type":"track","uri":"spotify:track:5V89ZHZcrESRu9ijeCPt3a"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6SShC5ACxSUSlTvPbk6A0j"},"href":"https://api.spotify.com/v1/albums/6SShC5ACxSUSlTvPbk6A0j","id":"6SShC5ACxSUSlTvPbk6A0j","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b8f1dbae86f992e818cc56f3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b8f1dbae86f992e818cc56f3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b8f1dbae86f992e818cc56f3"}],"is_playable":true,"name":"Summer Songs: 2000s Pop","release_date":"2022-05-26","release_date_precision":"day","total_tracks":49,"type":"album","uri":"spotify:album:6SShC5ACxSUSlTvPbk6A0j"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":229640,"explicit":false,"external_ids":{"isrc":"USSM10702131"},"external_urls":{"spotify":"https://open.spotify.com/track/0OsbQq92LvA1IR8MT08Bg2"},"href":"https://api.spotify.com/v1/tracks/0OsbQq92LvA1IR8MT08Bg2","id":"0OsbQq92LvA1IR8MT08Bg2","is_local":false,"is_playable":true,"name":"Electric Feel","track_number":26,"type":"track","uri":"spotify:track:0OsbQq92LvA1IR8MT08Bg2"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4JG23uEycAKdgefr1rFSYp"},"href":"https://api.spotify.com/v1/albums/4JG23uEycAKdgefr1rFSYp","id":"4JG23uEycAKdgefr1rFSYp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736359b57a4dfa7a00b58e742c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026359b57a4dfa7a00b58e742c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516359b57a4dfa7a00b58e742c"}],"is_playable":true,"name":"Feel Good Summer Songs","release_date":"2022-05-26","release_date_precision":"day","total_tracks":49,"type":"album","uri":"spotify:album:4JG23uEycAKdgefr1rFSYp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":229640,"explicit":false,"external_ids":{"isrc":"USSM10702131"},"external_urls":{"spotify":"https://open.spotify.com/track/54GvJ1fwD9M0XwAW85jqjM"},"href":"https://api.spotify.com/v1/tracks/54GvJ1fwD9M0XwAW85jqjM","id":"54GvJ1fwD9M0XwAW85jqjM","is_local":false,"is_playable":true,"name":"Electric Feel","track_number":26,"type":"track","uri":"spotify:track:54GvJ1fwD9M0XwAW85jqjM"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkVsZWN0cmljJTIwRmVlbCUyMiUyMGFydGlzdCUzQSUyMk1HTVQlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjksIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTd083U1dlREhKaWpRM1hOUzd4RUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFN3TzdTV2VESEppalEzWE5TN3hFRSIsImlkIjoiMFN3TzdTV2VESEppalEzWE5TN3hFRSIsIm5hbWUiOiJNR01UIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTd083U1dlREhKaWpRM1hOUzd4RUUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82bW0xU2t6M0pFNkFYbmV5YTlOeWl2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNm1tMVNrejNKRTZBWG5leWE5TnlpdiIsImlkIjoiNm1tMVNrejNKRTZBWG5leWE5TnlpdiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2", + "MTZkMDAwMGIyNzNhYmRmNzc0OWFlYjUyMjlkYmYzMDVmMDMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWJkZjc3NDlhZWI1MjI5ZGJmMzA1ZjAzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhYmRmNzc0OWFlYjUyMjlkYmYzMDVmMDMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT3JhY3VsYXIgU3BlY3RhY3VsYXIiLCJyZWxlYXNlX2RhdGUiOiIyMDA3LTEyLTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nm1tMVNrejNKRTZBWG5leWE5TnlpdiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTd083U1dlREhKaWpRM1hOUzd4RUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFN3TzdTV2VESEppalEzWE5TN3hFRSIsImlkIjoiMFN3TzdTV2VESEppalEzWE5TN3hFRSIsIm5hbWUiOiJNR01UIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTd083U1dlREhKaWpRM1hOUzd4RUUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI5NjQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEwNzAyMTMxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zRnRZYkVmQnFBbEdPNDZOVURRU0F0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0Z0WWJFZkJxQWxHTzQ2TlVEUVNBdCIsImlkIjoiM0Z0WWJFZkJxQWxHTzQ2TlVEUVNBdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJFbGVjdHJpYyBGZWVsIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNGdFliRWZCcUFsR080Nk5VRFFTQXQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTd083U1dlREhKaWpRM1hOUzd4RUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFN3TzdTV2VESEppalEzWE5TN3hFRSIsImlkIjoiMFN3TzdTV2VESEppalEzWE5TN3hFRSIsIm5hbWUiOiJNR01UIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YQ==", + "cnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ3cXVmTFdtOEQ1Q1VQQjlBMTFvcHEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82d3F1ZkxXbThENUNVUEI5QTExb3BxIiwiaWQiOiI2d3F1ZkxXbThENUNVUEI5QTExb3BxIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2E3OThmYzg4ZmFlYzQ3NDJkMjJjNTlkNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhNzk4ZmM4OGZhZWM0NzQyZDIyYzU5ZDYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWE3OThmYzg4ZmFlYzQ3NDJkMjJjNTlkNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJFbGVjdHJpYyBGZWVsIChKdXN0aWNlIFJlbWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMDctMTUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZ3cXVmTFdtOEQ1Q1VQQjlBMTFvcHEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFnUjBnc1FZZmk2am95TzFkbHA3Nk4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMWdSMGdzUVlmaTZqb3lPMWRscDc2TiIsImlkIjoiMWdSMGdzUVlmaTZqb3lPMWRscDc2TiIsIm5hbWUiOiJKdXN0aWNlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFnUjBnc1FZZmk2am95TzFkbHA3Nk4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI3Mzg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEwODAyMTE5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOg==", + "Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJlR0h5YXJaeVJ2VWdGSTRkM0c4R04ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yZUdIeWFyWnlSdlVnRkk0ZDNHOEdOIiwiaWQiOiIyZUdIeWFyWnlSdlVnRkk0ZDNHOEdOIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVsZWN0cmljIEZlZWwgLSBKdXN0aWNlIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJlR0h5YXJaeVJ2VWdGSTRkM0c4R04ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTd083U1dlREhKaWpRM1hOUzd4RUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFN3TzdTV2VESEppalEzWE5TN3hFRSIsImlkIjoiMFN3TzdTV2VESEppalEzWE5TN3hFRSIsIm5hbWUiOiJNR01UIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTd083U1dlREhKaWpRM1hOUzd4RUUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81d2o2UVdFVUV2UG5OTzNBNVFVdDRjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNXdqNlFXRVVFdlBuTk8zQTVRVXQ0YyIsImlkIjoiNXdqNlFXRVVFdlBuTk8zQTVRVXQ0YyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4Y2Q4ZTYwYzg5OWVhZTZmMmE1NDcwNGEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOGNkOGU2MGM4OTllYWU2ZjJhNTQ3MDRhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4Y2Q4ZTYwYzg5OWVhZTZmMmE1NDcwNGEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRWxlY3RyaWMgRmVlbCIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMDYtMjAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjV3ajZRV0VVRXZQbk5PM0E1UVV0NGMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodA==", + "dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFN3TzdTV2VESEppalEzWE5TN3hFRSIsImlkIjoiMFN3TzdTV2VESEppalEzWE5TN3hFRSIsIm5hbWUiOiJNR01UIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTd083U1dlREhKaWpRM1hOUzd4RUUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMxNzQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEwODAyMDcxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82R1RtR0VBaVI5cHlXTjVmMWxnWFN0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNkdUbUdFQWlSOXB5V041ZjFsZ1hTdCIsImlkIjoiNkdUbUdFQWlSOXB5V041ZjFsZ1hTdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJFbGVjdHJpYyBGZWVsIC0gVmlkZW8gTWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZHVG1HRUFpUjlweVdONWYxbGdYU3QifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzB0bjRPa1h5RE1lbW80eld0aFNkdTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wdG40T2tYeURNZW1vNHpXdGhTZHUwIiwiaWQiOiIwdG40T2tYeURNZW1vNHpXdGhTZHUwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzg4MWM2YTkwM2VjYzY5N2RmOTFkNWQ0NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4ODFjNmE5MDNlY2M2OTdkZjkxZDVkNDQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTg4MWM2YTkwM2VjYzY5N2RmOTFkNWQ0NCJ9XQ==", + "LCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik9yYWN1bGFyIFNwZWN0YWN1bGFyIiwicmVsZWFzZV9kYXRlIjoiMjAwOC0wMi0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjB0bjRPa1h5RE1lbW80eld0aFNkdTAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyOTY0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDcwMjEzMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGlzMkNxejZBa2NMWFB3dUpsN3NVQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRpczJDcXo2QWtjTFhQd3VKbDdzVUIiLCJpZCI6IjRpczJDcXo2QWtjTFhQd3VKbDdzVUIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRWxlY3RyaWMgRmVlbCIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0aXMyQ3F6NkFrY0xYUHd1Smw3c1VCIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBqVkdkVEtRMHBWYWxiYnR4djVoNU8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8walZHZFRLUTBwVmFsYmJ0eHY1aDVPIiwiaWQiOiIwalZHZFRLUTBwVmFsYmJ0eHY1aDVPIiwiaW1hZ2VzIg==", + "Olt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjMzZTRiMzM4NGE3YTA0MjhmOTkwNzU3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmIzM2U0YjMzODRhN2EwNDI4Zjk5MDc1NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjMzZTRiMzM4NGE3YTA0MjhmOTkwNzU3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhhcHBpbmVzcyBGb3JldmVyIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0wNC0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowalZHZFRLUTBwVmFsYmJ0eHY1aDVPIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjk2NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTA3MDIxMzEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFnV0N5a0ZNNGJoRUtlUUU4NlFvemYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xZ1dDeWtGTTRiaEVLZVFFODZRb3pmIiwiaWQiOiIxZ1dDeWtGTTRiaEVLZVFFODZRb3pmIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVsZWN0cmljIEZlZWwiLCJ0cmFja19udW1iZXIiOjQzLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFnV0N5a0ZNNGJoRUtlUUU4NlFvemYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTA==", + "eWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83NVVrSDVwNXdMcFU1dXRFY1lkOXFYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzVVa0g1cDV3THBVNXV0RWNZZDlxWCIsImlkIjoiNzVVa0g1cDV3THBVNXV0RWNZZDlxWCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmMTI1MjVjNTcyY2Y0ZDdlNjljMDVhOTEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjEyNTI1YzU3MmNmNGQ3ZTY5YzA1YTkxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmMTI1MjVjNTcyY2Y0ZDdlNjljMDVhOTEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGFwcHkgU3VtbWVyIFNvbmdzIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0wNS0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc1VWtINXA1d0xwVTV1dEVjWWQ5cVgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyOTY0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDcwMjEzMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMmd0RXBDcEtVdDFSNFBsazZRczlsZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJndEVwQ3BLVXQxUjRQbGs2UXM5bGQiLCJpZCI6IjJndEVwQ3BLVXQxUjRQbGs2UXM5bGQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRWxlYw==", + "dHJpYyBGZWVsIiwidHJhY2tfbnVtYmVyIjoyNiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyZ3RFcENwS1V0MVI0UGxrNlFzOWxkIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzd1d2F3UnV4SGhLc3hlZXNuZXZCUW4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83dXdhd1J1eEhoS3N4ZWVzbmV2QlFuIiwiaWQiOiI3dXdhd1J1eEhoS3N4ZWVzbmV2QlFuIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQ5YmZhNDUxYmE4OGZmZGQ2NDc2ZjU0YSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0OWJmYTQ1MWJhODhmZmRkNjQ3NmY1NGEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQ5YmZhNDUxYmE4OGZmZGQ2NDc2ZjU0YSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdXJmIE11c2ljIENoaWxsIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0wOC0zMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjd1d2F3UnV4SGhLc3hlZXNuZXZCUW4ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpbw==", + "bl9tcyI6MjI5NjQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEwNzAyMTMxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81Vjg5WkhaY3JFU1J1OWlqZUNQdDNhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNVY4OVpIWmNyRVNSdTlpamVDUHQzYSIsImlkIjoiNVY4OVpIWmNyRVNSdTlpamVDUHQzYSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJFbGVjdHJpYyBGZWVsIiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1Vjg5WkhaY3JFU1J1OWlqZUNQdDNhIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZTU2hDNUFDeFNVU2xUdlBiazZBMGoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82U1NoQzVBQ3hTVVNsVHZQYms2QTBqIiwiaWQiOiI2U1NoQzVBQ3hTVVNsVHZQYms2QTBqIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I4ZjFkYmFlODZmOTkyZTgxOGNjNTZmMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiOGYxZGJhZTg2Zjk5MmU4MThjYzU2ZjMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI4ZjFkYmFlODZmOTkyZTgxOGNjNTZmMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW1tZXIgU29uZ3M6IDIwMDBzIFBvcCIsInJlbGVhc2VfZGF0ZSI6IjIwMjItMDUtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2U1NoQzVBQ3hTVVNsVHZQYg==", + "azZBMGoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyOTY0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDcwMjEzMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svME9zYlFxOTJMdkExSVI4TVQwOEJnMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBPc2JRcTkyTHZBMUlSOE1UMDhCZzIiLCJpZCI6IjBPc2JRcTkyTHZBMUlSOE1UMDhCZzIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRWxlY3RyaWMgRmVlbCIsInRyYWNrX251bWJlciI6MjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6ME9zYlFxOTJMdkExSVI4TVQwOEJnMiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80SkcyM3VFeWNBS2RnZWZyMXJGU1lwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNEpHMjN1RXljQUtkZ2VmcjFyRlNZcCIsImlkIjoiNEpHMjN1RXljQUtkZ2VmcjFyRlNZcCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2MzU5YjU3YTRkZmE3YTAwYjU4ZTc0MmMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNjM1OQ==", + "YjU3YTRkZmE3YTAwYjU4ZTc0MmMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTYzNTliNTdhNGRmYTdhMDBiNThlNzQyYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGZWVsIEdvb2QgU3VtbWVyIFNvbmdzIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0wNS0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRKRzIzdUV5Y0FLZGdlZnIxckZTWXAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyOTY0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDcwMjEzMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNTRHdkoxZndEOU0wWHdBVzg1anFqTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzU0R3ZKMWZ3RDlNMFh3QVc4NWpxak0iLCJpZCI6IjU0R3ZKMWZ3RDlNMFh3QVc4NWpxak0iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRWxlY3RyaWMgRmVlbCIsInRyYWNrX251bWJlciI6MjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NTRHdkoxZndEOU0wWHdBVzg1anFqTSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Electric+Feel%22+artist%3A%22MGMT%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Time%20to%20Pretend%22%20artist%3A%22MGMT%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/6mm1Skz3JE6AXneya9Nyiv"},"href":"https://api.spotify.com/v1/albums/6mm1Skz3JE6AXneya9Nyiv","id":"6mm1Skz3JE6AXneya9Nyiv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273abdf7749aeb5229dbf305f03"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02abdf7749aeb5229dbf305f03"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851abdf7749aeb5229dbf305f03"}],"is_playable":true,"name":"Oracular Spectacular","release_date":"2007-12-14","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:6mm1Skz3JE6AXneya9Nyiv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":261000,"explicit":true,"external_ids":{"isrc":"USSM10702127"},"external_urls":{"spotify":"https://open.spotify.com/track/4iG2gAwKXsOcijVaVXzRPW"},"href":"https://api.spotify.com/v1/tracks/4iG2gAwKXsOcijVaVXzRPW","id":"4iG2gAwKXsOcijVaVXzRPW","is_local":false,"is_playable":true,"name":"Time to Pretend","track_number":1,"type":"track","uri":"spotify:track:4iG2gAwKXsOcijVaVXzRPW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/47sAJtdoVKUvZQy7lsCobi"},"href":"https://api.spotify.com/v1/albums/47sAJtdoVKUvZQy7lsCobi","id":"47sAJtdoVKUvZQy7lsCobi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734c5583bf0fb8c32640b51e76"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024c5583bf0fb8c32640b51e76"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514c5583bf0fb8c32640b51e76"}],"is_playable":true,"name":"Time to Pretend","release_date":"2005-08-30","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:47sAJtdoVKUvZQy7lsCobi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":272279,"explicit":true,"external_ids":{"isrc":"USME30900177"},"external_urls":{"spotify":"https://open.spotify.com/track/1brLt6o5uAu4kCQkVAM41v"},"href":"https://api.spotify.com/v1/tracks/1brLt6o5uAu4kCQkVAM41v","id":"1brLt6o5uAu4kCQkVAM41v","is_local":false,"is_playable":true,"name":"Time to Pretend","track_number":1,"type":"track","uri":"spotify:track:1brLt6o5uAu4kCQkVAM41v"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7A19ynZIohLCG6dr9k44rJ"},"href":"https://api.spotify.com/v1/albums/7A19ynZIohLCG6dr9k44rJ","id":"7A19ynZIohLCG6dr9k44rJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ea4dbfbc9b150a29f71de4f1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ea4dbfbc9b150a29f71de4f1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ea4dbfbc9b150a29f71de4f1"}],"is_playable":true,"name":"Party Hits: Summer Edition","release_date":"2013-07-05","release_date_precision":"day","total_tracks":80,"type":"album","uri":"spotify:album:7A19ynZIohLCG6dr9k44rJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":239906,"explicit":false,"external_ids":{"isrc":"USSM10800915"},"external_urls":{"spotify":"https://open.spotify.com/track/2CkR7sg9Pi8mm0TzTxlXEo"},"href":"https://api.spotify.com/v1/tracks/2CkR7sg9Pi8mm0TzTxlXEo","id":"2CkR7sg9Pi8mm0TzTxlXEo","is_local":false,"is_playable":true,"name":"Time to Pretend - Radio Edit","track_number":65,"type":"track","uri":"spotify:track:2CkR7sg9Pi8mm0TzTxlXEo"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/3sHVO9p1CdKuZblBeFqemi"},"href":"https://api.spotify.com/v1/albums/3sHVO9p1CdKuZblBeFqemi","id":"3sHVO9p1CdKuZblBeFqemi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c6bad15300472f3415b6cc6c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c6bad15300472f3415b6cc6c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c6bad15300472f3415b6cc6c"}],"is_playable":true,"name":"Time to Pretend","release_date":"2008-01-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3sHVO9p1CdKuZblBeFqemi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":261000,"explicit":true,"external_ids":{"isrc":"USSM10702127"},"external_urls":{"spotify":"https://open.spotify.com/track/3Q9FA2LP9Abih9xkFeNb6U"},"href":"https://api.spotify.com/v1/tracks/3Q9FA2LP9Abih9xkFeNb6U","id":"3Q9FA2LP9Abih9xkFeNb6U","is_local":false,"is_playable":true,"name":"Time to Pretend","track_number":1,"type":"track","uri":"spotify:track:3Q9FA2LP9Abih9xkFeNb6U"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/5frywKK1H8j7JKieY4VGiM"},"href":"https://api.spotify.com/v1/albums/5frywKK1H8j7JKieY4VGiM","id":"5frywKK1H8j7JKieY4VGiM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cdccb671cc1dd54ff42d573e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cdccb671cc1dd54ff42d573e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cdccb671cc1dd54ff42d573e"}],"is_playable":true,"name":"Time To Pretend","release_date":"2007","release_date_precision":"year","total_tracks":2,"type":"album","uri":"spotify:album:5frywKK1H8j7JKieY4VGiM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":261000,"explicit":true,"external_ids":{"isrc":"USSM10702127"},"external_urls":{"spotify":"https://open.spotify.com/track/1U0mXbREaTeDN7alQ3D3RE"},"href":"https://api.spotify.com/v1/tracks/1U0mXbREaTeDN7alQ3D3RE","id":"1U0mXbREaTeDN7alQ3D3RE","is_local":false,"is_playable":true,"name":"Time to Pretend","track_number":1,"type":"track","uri":"spotify:track:1U0mXbREaTeDN7alQ3D3RE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tn4OkXyDMemo4zWthSdu0"},"href":"https://api.spotify.com/v1/albums/0tn4OkXyDMemo4zWthSdu0","id":"0tn4OkXyDMemo4zWthSdu0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273881c6a903ecc697df91d5d44"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02881c6a903ecc697df91d5d44"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851881c6a903ecc697df91d5d44"}],"is_playable":true,"name":"Oracular Spectacular","release_date":"2008-02-11","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0tn4OkXyDMemo4zWthSdu0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":262853,"explicit":false,"external_ids":{"isrc":"USSM10705286"},"external_urls":{"spotify":"https://open.spotify.com/track/0wWXcZlRjfetNmJwcfGN5I"},"href":"https://api.spotify.com/v1/tracks/0wWXcZlRjfetNmJwcfGN5I","id":"0wWXcZlRjfetNmJwcfGN5I","is_local":false,"is_playable":true,"name":"Time to Pretend","track_number":1,"type":"track","uri":"spotify:track:0wWXcZlRjfetNmJwcfGN5I"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"external_urls":{"spotify":"https://open.spotify.com/album/0QPI2dd9ATZZ9mpUzz8cAq"},"href":"https://api.spotify.com/v1/albums/0QPI2dd9ATZZ9mpUzz8cAq","id":"0QPI2dd9ATZZ9mpUzz8cAq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733d66fcf5f45076a13f591316"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023d66fcf5f45076a13f591316"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513d66fcf5f45076a13f591316"}],"is_playable":true,"name":"Time To Pretend","release_date":"2008-02-25","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:0QPI2dd9ATZZ9mpUzz8cAq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":262173,"explicit":true,"external_ids":{"isrc":"USSM10702127"},"external_urls":{"spotify":"https://open.spotify.com/track/7FHqWqmnnhPiB3bNYzP6dC"},"href":"https://api.spotify.com/v1/tracks/7FHqWqmnnhPiB3bNYzP6dC","id":"7FHqWqmnnhPiB3bNYzP6dC","is_local":false,"is_playable":true,"name":"Time to Pretend","track_number":1,"type":"track","uri":"spotify:track:7FHqWqmnnhPiB3bNYzP6dC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6uqQP2jsszOsS9b1VMcfid"},"href":"https://api.spotify.com/v1/albums/6uqQP2jsszOsS9b1VMcfid","id":"6uqQP2jsszOsS9b1VMcfid","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a95330331764ba85b846943a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a95330331764ba85b846943a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a95330331764ba85b846943a"}],"is_playable":true,"name":"Pure... Dance Party","release_date":"2014-08-29","release_date_precision":"day","total_tracks":64,"type":"album","uri":"spotify:album:6uqQP2jsszOsS9b1VMcfid"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":2,"duration_ms":259333,"explicit":true,"external_ids":{"isrc":"USSM10702127"},"external_urls":{"spotify":"https://open.spotify.com/track/6AKFGCbqyxhTItQ5bYbloa"},"href":"https://api.spotify.com/v1/tracks/6AKFGCbqyxhTItQ5bYbloa","id":"6AKFGCbqyxhTItQ5bYbloa","is_local":false,"is_playable":true,"name":"Time to Pretend","track_number":14,"type":"track","uri":"spotify:track:6AKFGCbqyxhTItQ5bYbloa"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4B4nVmQZWZ44Y4yzLDa5n1"},"href":"https://api.spotify.com/v1/albums/4B4nVmQZWZ44Y4yzLDa5n1","id":"4B4nVmQZWZ44Y4yzLDa5n1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730ecae1ff4b14444a376db7ea"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020ecae1ff4b14444a376db7ea"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510ecae1ff4b14444a376db7ea"}],"is_playable":true,"name":"Seize the Day! Your Morning Commute","release_date":"2016-03-11","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:4B4nVmQZWZ44Y4yzLDa5n1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SwO7SWeDHJijQ3XNS7xEE"},"href":"https://api.spotify.com/v1/artists/0SwO7SWeDHJijQ3XNS7xEE","id":"0SwO7SWeDHJijQ3XNS7xEE","name":"MGMT","type":"artist","uri":"spotify:artist:0SwO7SWeDHJijQ3XNS7xEE"}],"disc_number":1,"duration_ms":261000,"explicit":true,"external_ids":{"isrc":"USSM10702127"},"external_urls":{"spotify":"https://open.spotify.com/track/1Fp9ZSyx3InL232bIdE0Dm"},"href":"https://api.spotify.com/v1/tracks/1Fp9ZSyx3InL232bIdE0Dm","id":"1Fp9ZSyx3InL232bIdE0Dm","is_local":false,"is_playable":true,"name":"Time to Pretend","track_number":19,"type":"track","uri":"spotify:track:1Fp9ZSyx3InL232bIdE0Dm"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRpbWUlMjB0byUyMFByZXRlbmQlMjIlMjBhcnRpc3QlM0ElMjJNR01UJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo5LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNm1tMVNrejNKRTZBWG5leWE5TnlpdiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZtbTFTa3ozSkU2QVhuZXlhOU55aXYiLCJpZCI6IjZtbTFTa3ozSkU2QVhuZXlhOU55aXYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9h", + "YjY3NjE2ZDAwMDBiMjczYWJkZjc3NDlhZWI1MjI5ZGJmMzA1ZjAzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmFiZGY3NzQ5YWViNTIyOWRiZjMwNWYwMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYWJkZjc3NDlhZWI1MjI5ZGJmMzA1ZjAzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik9yYWN1bGFyIFNwZWN0YWN1bGFyIiwicmVsZWFzZV9kYXRlIjoiMjAwNy0xMi0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZtbTFTa3ozSkU2QVhuZXlhOU55aXYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2MTAwMCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEwNzAyMTI3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80aUcyZ0F3S1hzT2NpalZhVlh6UlBXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGlHMmdBd0tYc09jaWpWYVZYelJQVyIsImlkIjoiNGlHMmdBd0tYc09jaWpWYVZYelJQVyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaW1lIHRvIFByZXRlbmQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGlHMmdBd0tYc09jaWpWYVZYelJQVyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdA==", + "aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNDdzQUp0ZG9WS1V2WlF5N2xzQ29iaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzQ3c0FKdGRvVktVdlpReTdsc0NvYmkiLCJpZCI6IjQ3c0FKdGRvVktVdlpReTdsc0NvYmkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNGM1NTgzYmYwZmI4YzMyNjQwYjUxZTc2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjRjNTU4M2JmMGZiOGMzMjY0MGI1MWU3NiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNGM1NTgzYmYwZmI4YzMyNjQwYjUxZTc2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRpbWUgdG8gUHJldGVuZCIsInJlbGVhc2VfZGF0ZSI6IjIwMDUtMDgtMzAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjQ3c0FKdGRvVktVdlpReTdsc0NvYmkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI3MjI3OSwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNRTMwOTAwMTc3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xYnJMdDZvNXVBdTRrQ1FrVkFNNDF2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMWJyTHQ2bzV1QXU0a0NRa1ZBTTQxdiIsImlkIjoiMWJyTHQ2bzV1QXU0a0NRa1ZBTTQxdiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaW1lIHRvIFByZXRlbmQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MWJyTHQ2bzV1QXU0aw==", + "Q1FrVkFNNDF2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdBMTl5blpJb2hMQ0c2ZHI5azQ0ckoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83QTE5eW5aSW9oTENHNmRyOWs0NHJKIiwiaWQiOiI3QTE5eW5aSW9oTENHNmRyOWs0NHJKIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2VhNGRiZmJjOWIxNTBhMjlmNzFkZTRmMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlYTRkYmZiYzliMTUwYTI5ZjcxZGU0ZjEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVhNGRiZmJjOWIxNTBhMjlmNzFkZTRmMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQYXJ0eSBIaXRzOiBTdW1tZXIgRWRpdGlvbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDctMDUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo4MCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3QTE5eW5aSW9oTENHNmRyOWs0NHJKIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzk5MDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTA4MDA5MTUifQ==", + "LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMkNrUjdzZzlQaThtbTBUelR4bFhFbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJDa1I3c2c5UGk4bW0wVHpUeGxYRW8iLCJpZCI6IjJDa1I3c2c5UGk4bW0wVHpUeGxYRW8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGltZSB0byBQcmV0ZW5kIC0gUmFkaW8gRWRpdCIsInRyYWNrX251bWJlciI6NjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MkNrUjdzZzlQaThtbTBUelR4bFhFbyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNzSFZPOXAxQ2RLdVpibEJlRnFlbWkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zc0hWTzlwMUNkS3VaYmxCZUZxZW1pIiwiaWQiOiIzc0hWTzlwMUNkS3VaYmxCZUZxZW1pIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2M2YmFkMTUzMDA0NzJmMzQxNWI2Y2M2YyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjNmJhZDE1MzAwNDcyZjM0MTViNmNjNmMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM2YmFkMTUzMDA0NzJmMzQxNWI2Y2M2YyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaW1lIHRvIFByZXRlbmQiLCJyZWxlYXNlX2RhdGUiOiIyMDA4LTAxLTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozc0hWTzlwMUNkS3VaYmxCZUZxZW1pIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpcw==", + "dC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2MTAwMCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEwNzAyMTI3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zUTlGQTJMUDlBYmloOXhrRmVOYjZVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM1E5RkEyTFA5QWJpaDl4a0ZlTmI2VSIsImlkIjoiM1E5RkEyTFA5QWJpaDl4a0ZlTmI2VSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaW1lIHRvIFByZXRlbmQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M1E5RkEyTFA5QWJpaDl4a0ZlTmI2VSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVmcnl3S0sxSDhqN0pLaWVZNFZHaU0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81ZnJ5d0tLMUg4ajdKS2llWTRWR2lNIiwiaWQiOiI1ZnJ5d0tLMUg4ajdKS2llWTRWR2lNIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2NkY2NiNjcxY2MxZGQ1NGZmNDJkNTczZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjZGNjYjY3MWNjMWRkNTRmZjQyZDU3M2UifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MQ==", + "Y2RjY2I2NzFjYzFkZDU0ZmY0MmQ1NzNlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRpbWUgVG8gUHJldGVuZCIsInJlbGVhc2VfZGF0ZSI6IjIwMDciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1ZnJ5d0tLMUg4ajdKS2llWTRWR2lNIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjEwMDAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDcwMjEyNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVUwbVhiUkVhVGVETjdhbFEzRDNSRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFVMG1YYlJFYVRlRE43YWxRM0QzUkUiLCJpZCI6IjFVMG1YYlJFYVRlRE43YWxRM0QzUkUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGltZSB0byBQcmV0ZW5kIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFVMG1YYlJFYVRlRE43YWxRM0QzUkUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzB0bjRPa1h5RE1lbW80eld0aFNkdTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wdG40T2tYeURNZW1vNHpXdGhTZHUwIiwiaWQiOiIwdG40T2tYeURNZW1vNHpXdGhTZHUwIiwiaW1hZ2VzIg==", + "Olt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODgxYzZhOTAzZWNjNjk3ZGY5MWQ1ZDQ0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjg4MWM2YTkwM2VjYzY5N2RmOTFkNWQ0NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODgxYzZhOTAzZWNjNjk3ZGY5MWQ1ZDQ0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik9yYWN1bGFyIFNwZWN0YWN1bGFyIiwicmVsZWFzZV9kYXRlIjoiMjAwOC0wMi0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjB0bjRPa1h5RE1lbW80eld0aFNkdTAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU3dPN1NXZURISmlqUTNYTlM3eEVFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJpZCI6IjBTd083U1dlREhKaWpRM1hOUzd4RUUiLCJuYW1lIjoiTUdNVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU3dPN1NXZURISmlqUTNYTlM3eEVFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2Mjg1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDcwNTI4NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHdXWGNabFJqZmV0Tm1Kd2NmR041SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzB3V1hjWmxSamZldE5tSndjZkdONUkiLCJpZCI6IjB3V1hjWmxSamZldE5tSndjZkdONUkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGltZSB0byBQcmV0ZW5kIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjB3V1hjWmxSamZldE5tSndjZkdONUkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTd083U1dlREhKaWpRM1hOUzd4RUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFN3TzdTV2VESEppalEzWE5TN3hFRSIsImlkIjoiMFN3Tw==", + "N1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBRUEkyZGQ5QVRaWjltcFV6ejhjQXEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wUVBJMmRkOUFUWlo5bXBVeno4Y0FxIiwiaWQiOiIwUVBJMmRkOUFUWlo5bXBVeno4Y0FxIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzNkNjZmY2Y1ZjQ1MDc2YTEzZjU5MTMxNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzZDY2ZmNmNWY0NTA3NmExM2Y1OTEzMTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTNkNjZmY2Y1ZjQ1MDc2YTEzZjU5MTMxNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaW1lIFRvIFByZXRlbmQiLCJyZWxlYXNlX2RhdGUiOiIyMDA4LTAyLTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowUVBJMmRkOUFUWlo5bXBVeno4Y0FxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjIxNzMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDcwMjEyNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN0ZIcVdxbW5uaFBpQjNiTll6UDZkQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdGSHFXcW1ubmhQaUIzYk5ZelA2ZEMiLCJpZCI6IjdGSHFXcW1ubmhQaUIzYk5ZelA2ZEMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGltZSB0byBQcmV0ZW5kIiwidHJhYw==", + "a19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N0ZIcVdxbW5uaFBpQjNiTll6UDZkQyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82dXFRUDJqc3N6T3NTOWIxVk1jZmlkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnVxUVAyanNzek9zUzliMVZNY2ZpZCIsImlkIjoiNnVxUVAyanNzek9zUzliMVZNY2ZpZCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhOTUzMzAzMzE3NjRiYTg1Yjg0Njk0M2EifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTk1MzMwMzMxNzY0YmE4NWI4NDY5NDNhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhOTUzMzAzMzE3NjRiYTg1Yjg0Njk0M2EifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUHVyZS4uLiBEYW5jZSBQYXJ0eSIsInJlbGVhc2VfZGF0ZSI6IjIwMTQtMDgtMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2dXFRUDJqc3N6T3NTOWIxVk1jZmlkIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFN3TzdTV2VESEppalEzWE5TN3hFRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU3dPN1NXZURISmlqUTNYTlM3eEVFIiwiaWQiOiIwU3dPN1NXZURISmlqUTNYTlM3eEVFIiwibmFtZSI6Ik1HTVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFN3TzdTV2VESEppalEzWE5TN3hFRSJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjoyNTkzMzMsIg==", + "ZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEwNzAyMTI3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82QUtGR0NicXl4aFRJdFE1YllibG9hIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNkFLRkdDYnF5eGhUSXRRNWJZYmxvYSIsImlkIjoiNkFLRkdDYnF5eGhUSXRRNWJZYmxvYSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaW1lIHRvIFByZXRlbmQiLCJ0cmFja19udW1iZXIiOjE0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZBS0ZHQ2JxeXhoVEl0UTViWWJsb2EifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNEI0blZtUVpXWjQ0WTR5ekxEYTVuMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRCNG5WbVFaV1o0NFk0eXpMRGE1bjEiLCJpZCI6IjRCNG5WbVFaV1o0NFk0eXpMRGE1bjEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMGVjYWUxZmY0YjE0NDQ0YTM3NmRiN2VhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjBlY2FlMWZmNGIxNDQ0NGEzNzZkYjdlYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMGVjYWUxZmY0YjE0NDQ0YTM3NmRiN2VhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNlaXplIHRoZSBEYXkhIFlvdXIgTW9ybmluZyBDb21tdXRlIiwicmVsZWFzZV9kYXRlIjoiMjAxNi0wMy0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRCNG5WbVFaV1o0NFk0eXpMRA==", + "YTVuMSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTd083U1dlREhKaWpRM1hOUzd4RUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFN3TzdTV2VESEppalEzWE5TN3hFRSIsImlkIjoiMFN3TzdTV2VESEppalEzWE5TN3hFRSIsIm5hbWUiOiJNR01UIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTd083U1dlREhKaWpRM1hOUzd4RUUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjYxMDAwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTA3MDIxMjcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFGcDlaU3l4M0luTDIzMmJJZEUwRG0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xRnA5WlN5eDNJbkwyMzJiSWRFMERtIiwiaWQiOiIxRnA5WlN5eDNJbkwyMzJiSWRFMERtIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRpbWUgdG8gUHJldGVuZCIsInRyYWNrX251bWJlciI6MTksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUZwOVpTeXgzSW5MMjMyYklkRTBEbSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Time+to+Pretend%22+artist%3A%22MGMT%22&type=track&limit=10" + } +] diff --git a/eval/fixtures/dutch-chill/anthropic.json b/eval/fixtures/dutch-chill/anthropic.json new file mode 100644 index 0000000..2dc63d5 --- /dev/null +++ b/eval/fixtures/dutch-chill/anthropic.json @@ -0,0 +1,55 @@ +[ + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"query\":\"relaxed Dutch-language music for the couch\",\"history\":[],\"prior_recommendations\":[],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"required_candidate_count\":35}"}],"model":"claude-sonnet-5","output_config":{"effort":"low","format":{"schema":{"$defs":{"CandidateOutput":{"type":"object","description":"One bounded candidate in the intent response.","title":"CandidateOutput","properties":{"title":{"type":"string","title":"Title","description":"{maxLength: 200, minLength: 1}"},"artist":{"type":"string","title":"Artist","description":"{maxLength: 200, minLength: 1}"}},"additionalProperties":false,"required":["title","artist"]},"Familiarity":{"type":"string","enum":["familiar","mix","new"],"description":"How strongly a request should favor known or unknown music.","title":"Familiarity"}},"type":"object","description":"Bounded structured output for the intent call.","title":"IntentOutput","properties":{"mood":{"type":"array","title":"Mood","items":{"type":"string"},"description":"{maxItems: 6}"},"activity":{"anyOf":[{"type":"string","description":"{maxLength: 100}"},{"type":"null"}],"title":"Activity","description":"{default: None}"},"era":{"type":"array","title":"Era","items":{"type":"string"},"description":"{maxItems: 5}"},"languages":{"type":"array","title":"Languages","items":{"type":"string"},"description":"{maxItems: 8}"},"genres":{"type":"array","title":"Genres","items":{"type":"string"},"description":"{maxItems: 8}"},"familiarity":{"$ref":"#/$defs/Familiarity"},"is_refinement":{"type":"boolean","title":"Is Refinement"},"intent_summary":{"type":"string","title":"Intent Summary","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"},"candidates":{"type":"array","title":"Candidates","items":{"$ref":"#/$defs/CandidateOutput"},"description":"{maxItems: 50, minItems: 10}"}},"additionalProperties":false,"required":["familiarity","is_refinement","intent_summary","candidates"]},"type":"json_schema"}},"system":[{"type":"text","text":"You are the intent interpreter and candidate generator for a music discovery system. Your job is to understand one listener request, use the supplied taste evidence carefully, and propose real recordings that another service can resolve against Spotify. Return only data that conforms to the provided output schema. Do not add prose before or after the structured response.\n\nInterpret the request in context. The variable input can contain a current query, a bounded conversation history, recommendations from an earlier response, and a compact taste profile. Treat the current query as authoritative. Use history only to resolve references, continuity, or explicit changes such as \"more like the third one\" or \"less energetic.\" Prior recommendations are evidence about what the listener has just seen, not proof that the listener likes every item. The Spotify taste profile is evidence of listening behavior, not a complete identity and not permission to stereotype the listener.\n\nPopulate every schema field honestly. Mood is a short bounded list of useful musical or emotional qualities. Activity is a concise listening context when one is stated or strongly implied, otherwise null. Era contains only time periods that matter to the request. Languages contains requested or strongly implied vocal languages; use an empty list when language is irrelevant or the music can be instrumental. Genres should be specific enough to guide selection without inventing a false precision. Familiarity must be familiar, mix, or new. Use familiar when the listener asks for comfort, favorites, known songs, or reliable crowd recognition. Use new when the listener asks for discovery, obscurity, unfamiliar music, or a departure from their habits. Use mix for a balanced bridge or when the request does not justify either extreme.\n\nSet is_refinement to true only when the listener is revising, narrowing, extending, or referring to an earlier recommendation result in the supplied conversation. A standalone request is not a refinement merely because history exists. The intent summary must be one plain-English sentence that tells the listener how the request was understood. It must not mention internal models, candidate generation, schemas, retrieval, or Spotify search behavior.\n\nGenerate the exact candidate count requested in the variable input. Each candidate contains only a track title and the credited artist name most likely to identify the recording. Choose recordings that plausibly exist in Spotify's catalog. Use canonical spellings. Do not fabricate tracks, mash up titles and artists, translate titles, or use descriptive placeholders. Avoid remixes, live versions, remasters, edits, sped-up versions, slowed versions, karaoke versions, covers, and tribute recordings unless the user explicitly asks for them. When several recordings share a title, choose the artist credit that makes the intended recording unambiguous.\n\nCandidate quality matters more than superficial variety. Every candidate should fit the interpreted mood, activity, era, language, genre, and familiarity. Still, spread the set across artists. Do not let one artist dominate the candidate list, even when that artist appears prominently in the taste profile. Avoid duplicate titles by the same artist and avoid multiple editions of the same recording. Use a range of strong fits so a later ranking step has meaningful choices rather than thirty near-identical songs.\n\nWhen familiarity leans new, propose music the listener plausibly does not know. Move beyond the named top artists and tracks while retaining understandable bridges through genre, scene, production style, instrumentation, energy, era, or songwriting. Do not simply select deep cuts from every familiar artist. Prefer adjacent artists, overlooked catalogs, regional scenes, and credible cross-genre connections. The profile is not exhaustive, so never claim that a candidate is definitely unknown. When familiarity is familiar, candidates may include supplied top or saved tracks, but remain responsive to the current request. When familiarity is mix, combine recognizable anchors with adjacent discoveries rather than splitting into unrelated halves.\n\nUse musical knowledge conservatively. Base selection on durable, commonly knowable attributes of recordings. Do not invent listening statistics, personal memories, release stories, chart facts, cultural identities, lyrical meanings, or audio features. Do not infer sensitive traits from taste. Explicit safety or content constraints in the request are binding. If a request is broad, create a coherent interpretation instead of asking a question. If constraints conflict, prioritize explicit exclusions, then the current query, then history, then taste evidence.\n\nThe downstream resolver first tries an exact field-filtered search and then a fuzzy bare-text search. Help it succeed with correct title and artist spelling. It will reject weak title or artist matches, so substituting a vaguely related track wastes a candidate. Prefer a confidently identifiable recording over an obscure item whose title or credit you cannot state accurately. Do not include Spotify identifiers, album names, explanations, scores, or justifications in candidate objects.\n\nBefore returning, silently check that the response matches the schema, the candidate list has exactly the requested size, familiarity uses the allowed value, is_refinement reflects conversation continuity, the intent summary is one line, spellings are credible, artist distribution is broad, and no candidate violates an explicit exclusion. Return strictly the structured response and nothing else.\n","cache_control":{"type":"ephemeral"}}]}", + "response_body_base64": "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", + "response_chunks_base64": [ + "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" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"intent\":{\"mood\":[\"relaxed\",\"laid-back\",\"mellow\",\"cozy\"],\"activity\":\"lounging on the couch\",\"era\":[],\"languages\":[\"Dutch\"],\"genres\":[\"Nederhop\",\"Dutch pop\",\"Nederpop\"],\"familiarity\":\"mix\",\"intent_summary\":\"Chill Dutch-language songs suited to relaxing at home on the couch.\"},\"grounded_pool\":[{\"track_id\":\"5Wwqq8Qdo4fm0HwYuKikNM\",\"title\":\"Iedereenzaam\",\"artists\":[\"Fresku\"]},{\"track_id\":\"7mOrWFQZU09Rwj61hF8Jk2\",\"title\":\"Fada\",\"artists\":[\"Fresku\"]},{\"track_id\":\"5yuwir3qmjGjQomLMy3l0D\",\"title\":\"DWDD\",\"artists\":[\"Fresku\",\"Asiah\"]},{\"track_id\":\"2nqPiVE7vKPiHyttanWfXi\",\"title\":\"Zonnetje Op M'n Porem\",\"artists\":[\"Didier Armeni\"]},{\"track_id\":\"5bYSqdcyJ74rLL299UJAcC\",\"title\":\"One of Those Nights\",\"artists\":[\"Didier Armeni\"]},{\"track_id\":\"4aoWDST9N8u2VZbqBwlXZ9\",\"title\":\"narcose\",\"artists\":[\"Sef\"]},{\"track_id\":\"25zMR1oVxUx16YZiEaPdiq\",\"title\":\"hel\",\"artists\":[\"Sef\"]},{\"track_id\":\"6aAJY5FYW0TMLsUe2T7x4p\",\"title\":\"Zoutelande\",\"artists\":[\"BL\\u00d8F\"]},{\"track_id\":\"1ZaWR909NbpUVEAxpgf7hW\",\"title\":\"Waarom Nou Jij\",\"artists\":[\"Marco Borsato\"]},{\"track_id\":\"3yxFiZHkQgJmLEyhij30rr\",\"title\":\"Rood\",\"artists\":[\"Marco Borsato\"]},{\"track_id\":\"69B6SgxGtxSzeTbl6IRGwP\",\"title\":\"Het Is Een Nacht... (Levensecht)\",\"artists\":[\"Guus Meeuwis\",\"Vagant\"]},{\"track_id\":\"1Q0p30HuN1ADMX2CmPzIvO\",\"title\":\"Nobody's Wife\",\"artists\":[\"Anouk\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"history\":[],\"requested_selection_count\":15,\"correction\":null}"}],"model":"claude-sonnet-5","output_config":{"effort":"medium","format":{"type":"json_schema","schema":{"$defs":{"RerankSelectionOutput":{"type":"object","description":"One validated object extracted from the rerank stream.","title":"RerankSelectionOutput","properties":{"track_id":{"type":"string","title":"Track Id","description":"{maxLength: 200, minLength: 1}"},"justification":{"type":"string","title":"Justification","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"}},"additionalProperties":false,"required":["track_id","justification"]}},"type":"object","description":"Complete bounded rerank output used for final validation.","title":"RerankOutput","properties":{"recommendations":{"type":"array","title":"Recommendations","items":{"$ref":"#/$defs/RerankSelectionOutput"},"minItems":1,"description":"{maxItems: 50}"}},"additionalProperties":false,"required":["recommendations"]}}},"system":[{"type":"text","text":"You are the final ranking component of a music discovery system. Select and order tracks only from the grounded Spotify pool supplied in the variable input. Return only data that conforms to the provided JSON schema. Output strictly the JSON object required by that schema, with no markdown, no code fence, no introductory sentence, and no trailing commentary.\n\nThe variable input contains the interpreted intent, a compact listener taste summary, bounded conversation history, and a grounded pool. Every pool entry includes a Spotify track id, title, and artist names. The pool is the complete set of allowed choices. Copy track_id values exactly. Never create, alter, guess, shorten, or normalize an id. Never select a title that is absent from the pool, even if it would be a better recommendation. Never return the same track id twice.\n\nChoose up to the requested selection count, ordered from strongest to weakest recommendation. Prefer a shorter set of honest strong fits over padding with clearly unsuitable material, but normally fill the requested count when the pool contains enough relevant choices. Ranking should respond to the current intent first. Use the taste summary to personalize among plausible fits, not to override an explicit request. Use history to understand refinements and references. Treat prior assistant statements as conversation context rather than verified facts about a recording.\n\nRespect the interpreted mood, activity, era, languages, genres, and familiarity together. A track need not satisfy every soft descriptor equally, but the ordering should form a coherent listening path. Put the clearest overall matches early. Consider transitions in energy, texture, and familiarity when that creates a more useful sequence, while avoiding a mechanical pattern. Spread selections across artists where the grounded pool permits it. Do not rank several editions of the same recording merely to fill space.\n\nFamiliarity affects ordering, but it does not grant access to information outside the input. For familiar requests, favor grounded tracks that visibly connect to the supplied taste evidence or prior recommendations. For new requests, favor credible adjacent discoveries and avoid leaning entirely on artists named in the taste summary. For mix requests, use recognizable anchors and exploratory choices in a coherent balance. The application may already have filtered known tracks, so do not claim that any selection is definitely new or previously unheard.\n\nWrite one concise, plain-English justification for each selection. It should connect the track to the stated intent and, only when supported, to an explicit item or pattern in the supplied taste summary. Keep it to one line. Make the reason useful to the listener rather than describing internal ranking operations. Good reasons identify a grounded connection such as pacing for the activity, a genre bridge, a requested era, a compatible vocal language, a mood transition, or continuity with a named preference.\n\nBe exact and modest. Do not invent audio measurements, tempo values, key signatures, instrumentation, lyrical subjects, release dates, artist biographies, chart history, cultural significance, collaborations, popularity, or claims about what the listener has heard. A title and artist name alone do not prove detailed sonic or lyrical facts. You may use stable general musical knowledge when confident, but phrase the justification around the supplied intent and visible evidence. If the inputs do not support a specific fact, use a restrained reason such as \"A focused fit for the requested late-night electronic mood\" rather than manufacturing detail.\n\nDo not mention Spotify search, grounding, the candidate generator, language models, schemas, hidden scores, safety filters, cache state, or missing data in a justification. Do not tell the listener that a track was selected because it was available in the pool. Do not compare a selection with tracks that are not in the pool. Do not repeat the same generic sentence for every item. Avoid promotional language and absolute claims such as \"perfect,\" \"guaranteed,\" or \"the best.\"\n\nWhen the variable input says this is a correction attempt, treat the stated validation failure as a strict constraint. Return a fresh complete JSON object, not a patch or explanation. Correct invalid ids, duplicates, malformed fields, count problems, and formatting errors using only the supplied pool. The correction instruction never allows an out-of-pool id.\n\nThe response must be one JSON object with the exact top-level field required by the schema. Each array item must contain exactly a track_id and justification in the required types. Preserve the requested ranking order in the array. Use valid JSON quoting and escaping. Do not emit comments, dangling commas, alternate keys, null justifications, numeric ids, or additional properties.\n\nBefore returning, silently verify every track_id against the supplied pool, ensure all ids are unique, ensure the number of items does not exceed the requested count, confirm each justification is honest and one line, confirm the ranking follows the current intent, and confirm the entire response is valid against the provided JSON schema. Return only the JSON object.\n","cache_control":{"type":"ephemeral"}}],"stream":true}", + "response_body_base64": "event: message_start
data: {"type":"message_start","message":{"model":"claude-sonnet-5","id":"msg_011CdtuQm5wG6QNnokEu5EQh","type":"message","role":"assistant","content":[],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":5745,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"global"}}              }

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}              }

event: ping
data: {"type": "ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"{"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"recommendations\":[{\"track_id\":\"2nqPiVE7vK"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"PiHyttanWfXi\",\"justification\":\"A"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" mellow Dutch track from an artist already in your saved list, easing into couch mode.\"},{\"track_id\":\"5bYSqd"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"cyJ74rLL299UJAc"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"C\",\"justification\":\"Laid-back groove from Didier Armeni that matches the cozy, low-key vibe you're after.\"},{\"track_id\":\"4aoW"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"DST9N8u2VZbqB"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"wlXZ9\",\"justification\":\"Sef's narcose keeps the mellow Dutch-language m"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ood going with a relaxed pace.\"},{\"track_id\":\"25zMR1oVxU"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"x16YZiEaPdiq\",\"justification\":\"Another"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" chill Sef track that fits comfortably alongside your saved Dutch picks.\"},{\"track_id\":\"5Wwqq"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"8Qdo4fm0HwYuK"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ikNM\",\"justification\":\"Fresku's reflective tone suits lounging at home in Dutch.\"},{\"track_id\":\"7mOrW"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"FQZU09Rwj61hF8"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Jk2\",\"justification\":\"Continues the Fresku thread with a smooth, unhurried feel for relaxing.\"},{\"track_id\":\"5yu"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"wir3qmjGjQomLM"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"y3l0D\",\"justification\":\"A collaborative Fresku track adding variety while staying in the mellow Nederhop lane.\"},{\""}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"track_id\":\"6aAJY5FYW0TMLs"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Ue2T7x4p\",\"justification\":\"BLØF's warm D"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"utch pop tone offers a gentle, cozy shift in texture.\"},{\"track_id\":\"3yxFiZ"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"HkQgJmLEyhij30"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"rr\",\"justification\":\"Marco Borsato brings a soft Nederpop ballad quality fitting for winding down.\"},{\"track_"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"id\":\"1ZaWR909NbpUVEAxpg"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"f7hW\",\"justification\":\"Another relaxed Borsato track to keep the laid-back Dutch pop th"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"read coherent.\"},{\"track_id\":\"69B6SgxGtxSz"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"eTbl6IRGwP\",\"justification\":\"Guus Mee"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"uwis adds a familiar, comforting Dutch pop touch for a lounging afternoon.\"},{\"track_id\":\"1Q"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"0p30HuN1ADMX2CmP"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"zIvO\",\"justification\":\"Anouk's mellow tone closes the set with a smooth, cozy finish in Dutch.\"}]}"}             }

event: content_block_stop
data: {"type":"content_block_stop","index":0  }

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null,"stop_details":null},"usage":{"input_tokens":5745,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"output_tokens":783,"output_tokens_details":{"thinking_tokens":0}}      }

event: message_stop
data: {"type":"message_stop"   }

", + "response_chunks_base64": [ + "ZXZlbnQ6IG1lc3NhZ2Vfc3RhcnQKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9zdGFydCIsIm1lc3NhZ2U=", + "Ijp7Im1vZGVsIjoiY2xhdWRlLXNvbm5ldC01IiwiaWQiOiJtc2dfMDExQ2R0dVFtNXdHNlFObm9rRXU1RVFoIiwidHlwZSI6Im1lc3NhZ2UiLCJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6W10sInN0b3BfcmVhc29uIjpudWxsLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NTc0NSwiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MjExMywiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MCwiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjEsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Imdsb2JhbCJ9fSAgICAgICAgICAgICAgfQoKZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RhcnQKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19zdGFydCIsImluZGV4IjowLCJjb250ZW50X2Jsb2NrIjp7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IiJ9ICAgICAgICAgICAgICB9CgpldmVudDogcGluZwpkYXRhOiB7InR5cGUiOiAicGluZyJ9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ7In0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInJlY29tbWVuZGF0aW9uc1wiOlt7XCJ0cmFja19pZFwiOlwiMm5xUGlWRTd2SyJ9ICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJQaUh5dHRhbldmWGlcIixcImp1c3RpZmljYXRpb25cIjpcIkEifSAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgbWVsbG93IER1dGNoIHRyYWNrIGZyb20gYW4gYXJ0aXN0IGFscmVhZHkgaW4geW91ciBzYXZlZCBsaXN0LCBlYXNpbmcgaW50byBjb3VjaCBtb2RlLlwifSx7XCJ0cmFja19pZFwiOlwiNWJZU3FkIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJjeUo3NHJMTDI5OVVKQWMifSAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJDXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJMYWlkLWJhY2sgZ3Jvb3ZlIGZyb20gRGlkaWVyIEFybWVuaSB0aGF0IG1hdGNoZXMgdGhlIGNvenksIGxvdy1rZXkgdmliZSB5b3UncmUgYWZ0ZXIuXCJ9LHtcInRyYWNrX2lkXCI6XCI0YW9XIn0gICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJEU1Q5Tjh1MlZaYnFCIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ3bFhaOVwiLFwianVzdGlmaWNhdGlvblwiOlwiU2VmJ3MgbmFyY29zZSBrZWVwcyB0aGUgbWVsbG93IER1dGNoLWxhbmd1YWdlIG0ifSAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvb2QgZ29pbmcgd2l0aCBhIHJlbGF4ZWQgcGFjZS5cIn0se1widHJhY2tfaWRcIjpcIjI1ek1SMW9WeFUifSAgICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ4MTZZWmlFYVBkaXFcIixcImp1c3RpZmljYXRpb25cIjpcIkFub3RoZXIifSAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgY2hpbGwgU2VmIHRyYWNrIHRoYXQgZml0cyBjb21mb3J0YWJseSBhbG9uZ3NpZGUgeW91ciBzYXZlZCBEdXRjaCBwaWNrcy5cIn0se1widHJhY2tfaWRcIjpcIjVXd3FxIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI4UWRvNGZtMEh3WXVLIn0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpa05NXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJGcmVza3UncyByZWZsZWN0aXZlIHRvbmUgc3VpdHMgbG91bmdpbmcgYXQgaG9tZSBpbiBEdXRjaC5cIn0se1widHJhY2tfaWRcIjpcIjdtT3JXIn0gICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJGUVpVMDlSd2o2MWhGOCJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJKazJcIixcImp1c3RpZmljYXRpb25cIjpcIkNvbnRpbnVlcyB0aGUgRnJlc2t1IHRocmVhZCB3aXRoIGEgc21vb3RoLCB1bmh1cnJpZWQgZmVlbCBmb3IgcmVsYXhpbmcuXCJ9LHtcInRyYWNrX2lkXCI6XCI1eXUifSAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ3aXIzcW1qR2pRb21MTSJ9IH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ5M2wwRFwiLFwianVzdGlmaWNhdGlvblwiOlwiQSBjb2xsYWJvcmF0aXZlIEZyZXNrdSB0cmFjayBhZGRpbmcgdmFyaWV0eSB3aGlsZSBzdGF5aW5nIGluIHRoZSBtZWxsb3cgTmVkZXJob3AgbGFuZS5cIn0se1wiIn0gICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ0cmFja19pZFwiOlwiNmFBSlk1RllXMFRNTHMifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJVZTJUN3g0cFwiLFwianVzdGlmaWNhdGlvblwiOlwiQkzDmEYncyB3YXJtIEQifSAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ1dGNoIHBvcCB0b25lIG9mZmVycyBhIGdlbnRsZSwgY296eSBzaGlmdCBpbiB0ZXh0dXJlLlwifSx7XCJ0cmFja19pZFwiOlwiM3l4RmlaIn0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJIa1FnSm1MRXloaWozMCJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJyclwiLFwianVzdGlmaWNhdGlvblwiOlwiTWFyY28gQm9yc2F0byBicmluZ3MgYSBzb2Z0IE5lZGVycG9wIGJhbGxhZCBxdWFsaXR5IGZpdHRpbmcgZm9yIHdpbmRpbmcgZG93bi5cIn0se1widHJhY2tfIn0gICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpZFwiOlwiMVphV1I5MDlOYnBVVkVBeHBnIn0gIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJmN2hXXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBbm90aGVyIHJlbGF4ZWQgQm9yc2F0byB0cmFjayB0byBrZWVwIHRoZSBsYWlkLWJhY2sgRHV0Y2ggcG9wIHRoIn0gICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJyZWFkIGNvaGVyZW50LlwifSx7XCJ0cmFja19pZFwiOlwiNjlCNlNneEd0eFN6In0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlVGJsNklSR3dQXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJHdXVzIE1lZSJ9ICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ1d2lzIGFkZHMgYSBmYW1pbGlhciwgY29tZm9ydGluZyBEdXRjaCBwb3AgdG91Y2ggZm9yIGEgbG91bmdpbmcgYWZ0ZXJub29uLlwifSx7XCJ0cmFja19pZFwiOlwiMVEifSAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIwcDMwSHVOMUFETVgyQ21QIn0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ6SXZPXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBbm91aydzIG1lbGxvdyB0b25lIGNsb3NlcyB0aGUgc2V0IHdpdGggYSBzbW9vdGgsIGNvenkgZmluaXNoIGluIER1dGNoLlwifV19In0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RvcApkYXRhOiB7InR5cGUiOiJjb250ZW50X2Jsb2NrX3N0b3AiLCJpbmRleCI6MCAgfQoK", + "ZXZlbnQ6IG1lc3NhZ2VfZGVsdGEKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9kZWx0YSIsImRlbHRhIjp7InN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGx9LCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjU3NDUsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjIxMTMsIm91dHB1dF90b2tlbnMiOjc4Mywib3V0cHV0X3Rva2Vuc19kZXRhaWxzIjp7InRoaW5raW5nX3Rva2VucyI6MH19ICAgICAgfQoK", + "ZXZlbnQ6IG1lc3NhZ2Vfc3RvcApkYXRhOiB7InR5cGUiOiJtZXNzYWdlX3N0b3AiICAgfQoK" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + } +] diff --git a/eval/fixtures/dutch-chill/spotify.json b/eval/fixtures/dutch-chill/spotify.json new file mode 100644 index 0000000..d136f2b --- /dev/null +++ b/eval/fixtures/dutch-chill/spotify.json @@ -0,0 +1,894 @@ +[ + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=", + "response_chunks_base64": [ + "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=0" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkllZGVyZWVuemFhbSUyMiUyMGFydGlzdCUzQSUyMkZyZXNrdSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MiwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNW0xY0xtZ1pJZkVZUExlamhMRlIxMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81bTFjTG1nWklmRVlQTGVqaExGUjEwIiwiaWQiOiI1bTFjTG1nWklmRVlQTGVqaExGUjEwIiwibmFtZSI6IkZyZXNrdSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1bTFjTG1nWklmRVlQTGVqaExGUjEwIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2NGSThuZkRGd0JHZFJiS3BPUEhLeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNjRkk4bmZERndCR2RSYktwT1BIS3giLCJpZCI6IjNjRkk4bmZERndCR2RSYktwT1BIS3giLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3Ng==", + "MTZkMDAwMGIyNzMzMmFkNGY4NTZlMDdkZTlhYzRiNmE1ZjAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzJhZDRmODU2ZTA3ZGU5YWM0YjZhNWYwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzMmFkNGY4NTZlMDdkZTlhYzRiNmE1ZjAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW4gZGUgTHVjaHQgKERlZWwgMSkiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTEwLTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2NGSThuZkRGd0JHZFJiS3BPUEhLeCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVtMWNMbWdaSWZFWVBMZWpoTEZSMTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNW0xY0xtZ1pJZkVZUExlamhMRlIxMCIsImlkIjoiNW0xY0xtZ1pJZkVZUExlamhMRlIxMCIsIm5hbWUiOiJGcmVza3UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NW0xY0xtZ1pJZkVZUExlamhMRlIxMCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTU0NzQsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaTUVQMjEyNTQ2NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVd3cXE4UWRvNGZtMEh3WXVLaWtOTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVXd3FxOFFkbzRmbTBId1l1S2lrTk0iLCJpZCI6IjVXd3FxOFFkbzRmbTBId1l1S2lrTk0iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSWVkZXJlZW56YWFtIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVXd3FxOFFkbzRmbTBId1l1S2lrTk0ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVtMWNMbWdaSWZFWVBMZWpoTEZSMTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNW0xY0xtZ1pJZkVZUExlamhMRlIxMCIsImlkIjoiNW0xY0xtZ1pJZkVZUExlamhMRlIxMCIsIm5hbWUiOiJGcmVza3UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeQ==", + "OmFydGlzdDo1bTFjTG1nWklmRVlQTGVqaExGUjEwIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlVMZmtkWWtQQnRMejNHdGVKSEliUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJVTGZrZFlrUEJ0THozR3RlSkhJYlEiLCJpZCI6IjJVTGZrZFlrUEJ0THozR3RlSkhJYlEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTA0ZDczZjFiYzQ4NzUwYWEwNTJhZmFiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEwNGQ3M2YxYmM0ODc1MGFhMDUyYWZhYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTA0ZDczZjFiYzQ4NzUwYWEwNTJhZmFiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkllZGVyZWVuemFhbSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDktMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJVTGZrZFlrUEJ0THozR3RlSkhJYlEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81bTFjTG1nWklmRVlQTGVqaExGUjEwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVtMWNMbWdaSWZFWVBMZWpoTEZSMTAiLCJpZCI6IjVtMWNMbWdaSWZFWVBMZWpoTEZSMTAiLCJuYW1lIjoiRnJlc2t1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVtMWNMbWdaSWZFWVBMZWpoTEZSMTAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE1NDc0LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWk1FUDIxMjU0NjcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzAyT2hLNWw2elZHQUdLUWpXWWE4VnAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wMk9oSzVsNnpWR0FHS1FqV1lhOFZwIiwiaWQiOiIwMk9oSzVsNnpWR0FHS1FqV1lhOFZwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkllZGVyZWVuemFhbSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowMk9oSzVsNnpWR0FHS1FqV1lhOA==", + "VnAifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Iedereenzaam%22+artist%3A%22Fresku%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk9uZSUyMG9mJTIwVGhvc2UlMjBOaWdodHMlMjIlMjBhcnRpc3QlM0ElMjJEaWRpZXIlMjBBcm1lbmklMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wckFXelFiQjBRYnc0UDR2QmZGcGthIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzByQVd6UWJCMFFidzRQNHZCZkZwa2EiLCJpZCI6IjByQVd6UWJCMFFidzRQNHZCZkZwa2EiLCJuYW1lIjoiRGlkaWVyIEFybWVuaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowckFXelFiQjBRYnc0UDR2QmZGcGthIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM1ZyRDg4VU9Zako4SFZTU0RIdXJrcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNWckQ4OFVPWWpKOEhWU1NESHVya3EiLCJpZCI6IjNWckQ4OFVPWWpKOEhWU1NESHVya3EiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOg==", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhNzY4NDE5ODFjMWQ4ZWNkYTExNWEzMTIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTc2ODQxOTgxYzFkOGVjZGExMTVhMzEyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhNzY4NDE5ODFjMWQ4ZWNkYTExNWEzMTIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT25lIG9mIFRob3NlIE5pZ2h0cyIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDctMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNWckQ4OFVPWWpKOEhWU1NESHVya3EifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wckFXelFiQjBRYnc0UDR2QmZGcGthIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzByQVd6UWJCMFFidzRQNHZCZkZwa2EiLCJpZCI6IjByQVd6UWJCMFFidzRQNHZCZkZwa2EiLCJuYW1lIjoiRGlkaWVyIEFybWVuaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowckFXelFiQjBRYnc0UDR2QmZGcGthIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMzczOCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaSE45MjAyNjQ0NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWJZU3FkY3lKNzRyTEwyOTlVSkFjQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzViWVNxZGN5Sjc0ckxMMjk5VUpBY0MiLCJpZCI6IjViWVNxZGN5Sjc0ckxMMjk5VUpBY0MiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT25lIG9mIFRob3NlIE5pZ2h0cyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1YllTcWRjeUo3NHJMTDI5OVVKQWNDIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22One+of+Those+Nights%22+artist%3A%22Didier+Armeni%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZhZGElMjIlMjBhcnRpc3QlM0ElMjJGcmVza3UlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVtMWNMbWdaSWZFWVBMZWpoTEZSMTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNW0xY0xtZ1pJZkVZUExlamhMRlIxMCIsImlkIjoiNW0xY0xtZ1pJZkVZUExlamhMRlIxMCIsIm5hbWUiOiJGcmVza3UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NW0xY0xtZ1pJZkVZUExlamhMRlIxMCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzEweUxIcVRwWnlxbXF0VHZqZFhncFoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xMHlMSHFUcFp5cW1xdFR2amRYZ3BaIiwiaWQiOiIxMHlMSHFUcFp5cW1xdFR2amRYZ3BaIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYg==", + "MjczOWMzOGYzODU3NDc5ZmFmNTA0MzY4ZmE0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjljMzhmMzg1NzQ3OWZhZjUwNDM2OGZhNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWMzOGYzODU3NDc5ZmFmNTA0MzY4ZmE0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkluIEhldCBEaWVwZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTEtMjQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxMHlMSHFUcFp5cW1xdFR2amRYZ3BaIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNW0xY0xtZ1pJZkVZUExlamhMRlIxMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81bTFjTG1nWklmRVlQTGVqaExGUjEwIiwiaWQiOiI1bTFjTG1nWklmRVlQTGVqaExGUjEwIiwibmFtZSI6IkZyZXNrdSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1bTFjTG1nWklmRVlQTGVqaExGUjEwIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5OTA0MiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzY2MTkwMDg5NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN21PcldGUVpVMDlSd2o2MWhGOEprMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdtT3JXRlFaVTA5UndqNjFoRjhKazIiLCJpZCI6IjdtT3JXRlFaVTA5UndqNjFoRjhKazIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmFkYSIsInRyYWNrX251bWJlciI6MTUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N21PcldGUVpVMDlSd2o2MWhGOEprMiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Fada%22+artist%3A%22Fresku%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRXREQlMjIlMjBhcnRpc3QlM0ElMjJGcmVza3UlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVtMWNMbWdaSWZFWVBMZWpoTEZSMTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNW0xY0xtZ1pJZkVZUExlamhMRlIxMCIsImlkIjoiNW0xY0xtZ1pJZkVZUExlamhMRlIxMCIsIm5hbWUiOiJGcmVza3UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NW0xY0xtZ1pJZkVZUExlamhMRlIxMCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzEweUxIcVRwWnlxbXF0VHZqZFhncFoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xMHlMSHFUcFp5cW1xdFR2amRYZ3BaIiwiaWQiOiIxMHlMSHFUcFp5cW1xdFR2amRYZ3BaIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYg==", + "MjczOWMzOGYzODU3NDc5ZmFmNTA0MzY4ZmE0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjljMzhmMzg1NzQ3OWZhZjUwNDM2OGZhNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWMzOGYzODU3NDc5ZmFmNTA0MzY4ZmE0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkluIEhldCBEaWVwZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTEtMjQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxMHlMSHFUcFp5cW1xdFR2amRYZ3BaIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNW0xY0xtZ1pJZkVZUExlamhMRlIxMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81bTFjTG1nWklmRVlQTGVqaExGUjEwIiwiaWQiOiI1bTFjTG1nWklmRVlQTGVqaExGUjEwIiwibmFtZSI6IkZyZXNrdSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1bTFjTG1nWklmRVlQTGVqaExGUjEwIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNjQVdndzVkeTZBMU9oZUtaeDB1WlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2NBV2d3NWR5NkExT2hlS1p4MHVaWCIsImlkIjoiM2NBV2d3NWR5NkExT2hlS1p4MHVaWCIsIm5hbWUiOiJBc2lhaCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozY0FXZ3c1ZHk2QTFPaGVLWngwdVpYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyNjQwNywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzY2MjAwMDE3OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNXl1d2lyM3FtakdqUW9tTE15M2wwRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzV5dXdpcjNxbWpHalFvbUxNeTNsMEQiLCJpZCI6IjV5dXdpcjNxbWpHalFvbUxNeTNsMEQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRFdERCIsInRyYWNrX251bWJlciI6MTcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXl1d2lyM3FtakdqUW9tTE15M2wwRCJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22DWDD%22+artist%3A%22Fresku%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlpvbm5ldGplJTIwT3AlMjBNJTI3biUyMFBvcmVtJTIyJTIwYXJ0aXN0JTNBJTIyRGlkaWVyJTIwQXJtZW5pJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMHJBV3pRYkIwUWJ3NFA0dkJmRnBrYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wckFXelFiQjBRYnc0UDR2QmZGcGthIiwiaWQiOiIwckFXelFiQjBRYnc0UDR2QmZGcGthIiwibmFtZSI6IkRpZGllciBBcm1lbmkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHJBV3pRYkIwUWJ3NFA0dkJmRnBrYSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ5MVczc2RIMGRyYnpwbkN3ZEVCc2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82eTFXM3NkSDBkcmJ6cG5Dd2RFQnNmIiwiaWQiOiI2eTFXM3NkSDBkcmJ6cG5Dd2RFQnNmIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidQ==", + "cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzZmZDc3YjE2MWY0NDRmYWZmYjk5Y2JmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjM2ZmQ3N2IxNjFmNDQ0ZmFmZmI5OWNiZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzZmZDc3YjE2MWY0NDRmYWZmYjk5Y2JmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ilpvbm5ldGplIE9wIE0nbiBQb3JlbSIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDMtMjgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZ5MVczc2RIMGRyYnpwbkN3ZEVCc2YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wckFXelFiQjBRYnc0UDR2QmZGcGthIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzByQVd6UWJCMFFidzRQNHZCZkZwa2EiLCJpZCI6IjByQVd6UWJCMFFidzRQNHZCZkZwa2EiLCJuYW1lIjoiRGlkaWVyIEFybWVuaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowckFXelFiQjBRYnc0UDR2QmZGcGthIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2MTM1OCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaREE0MTk5NDY5OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMm5xUGlWRTd2S1BpSHl0dGFuV2ZYaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJucVBpVkU3dktQaUh5dHRhbldmWGkiLCJpZCI6IjJucVBpVkU3dktQaUh5dHRhbldmWGkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWm9ubmV0amUgT3AgTSduIFBvcmVtIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJucVBpVkU3dktQaUh5dHRhbldmWGkifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Zonnetje+Op+M%27n+Porem%22+artist%3A%22Didier+Armeni%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1laXNqZSUyMHZhbiUyMDE2JTIyJTIwYXJ0aXN0JTNBJTIyUm9ubmllJTIwRmxleCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1laXNqZSUyMHZhbiUyMDE2JTIyJTIwYXJ0aXN0JTNBJTIyUm9ubmllJTIwRmxleCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Meisje+van+16%22+artist%3A%22Ronnie+Flex%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkFscyUyMEhldCUyMEF2b25kJTIwSXMlMjIlMjBhcnRpc3QlM0ElMjJSb25uaWUlMjBGbGV4JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkFscyUyMEhldCUyMEF2b25kJTIwSXMlMjIlMjBhcnRpc3QlM0ElMjJSb25uaWUlMjBGbGV4JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Als+Het+Avond+Is%22+artist%3A%22Ronnie+Flex%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNsYXBlbG96ZSUyME5hY2h0ZW4lMjIlMjBhcnRpc3QlM0ElMjJCcm9lZGVybGllZmRlJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNsYXBlbG96ZSUyME5hY2h0ZW4lMjIlMjBhcnRpc3QlM0ElMjJCcm9lZGVybGllZmRlJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Slapeloze+Nachten%22+artist%3A%22Broederliefde%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZsaW5kZXJzJTIyJTIwYXJ0aXN0JTNBJTIyUzEwJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZsaW5kZXJzJTIyJTIwYXJ0aXN0JTNBJTIyUzEwJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Vlinders%22+artist%3A%22S10%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk5hY2h0bGljaHQlMjIlMjBhcnRpc3QlM0ElMjJTMTAlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk5hY2h0bGljaHQlMjIlMjBhcnRpc3QlM0ElMjJTMTAlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Nachtlicht%22+artist%3A%22S10%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJsYXV3JTIyJTIwYXJ0aXN0JTNBJTIyRnJvdWtqZSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJsYXV3JTIyJTIwYXJ0aXN0JTNBJTIyRnJvdWtqZSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Blauw%22+artist%3A%22Froukje%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Meisje%20van%2016%20Ronnie%20Flex&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Meisje%20van%2016%20Ronnie%20Flex&type=track","offset":0,"previous":null,"total":19,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4AripACtwIVH69NdCbsJus"},"href":"https://api.spotify.com/v1/artists/4AripACtwIVH69NdCbsJus","id":"4AripACtwIVH69NdCbsJus","name":"Niels Destadsbader","type":"artist","uri":"spotify:artist:4AripACtwIVH69NdCbsJus"}],"external_urls":{"spotify":"https://open.spotify.com/album/7yzvsygLvtAvPXVMqKCXzd"},"href":"https://api.spotify.com/v1/albums/7yzvsygLvtAvPXVMqKCXzd","id":"7yzvsygLvtAvPXVMqKCXzd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739cb0c5a1d5d03765dbea02f2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029cb0c5a1d5d03765dbea02f2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519cb0c5a1d5d03765dbea02f2"}],"is_playable":true,"name":"Speeltijd (Niels & Wiels Editie)","release_date":"2017-02-17","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:7yzvsygLvtAvPXVMqKCXzd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2qOiPRcHqn8ytGWxCf8U4S"},"href":"https://api.spotify.com/v1/artists/2qOiPRcHqn8ytGWxCf8U4S","id":"2qOiPRcHqn8ytGWxCf8U4S","name":"Niels & Wiels","type":"artist","uri":"spotify:artist:2qOiPRcHqn8ytGWxCf8U4S"}],"disc_number":1,"duration_ms":165493,"explicit":false,"external_ids":{"isrc":"BEK011700066"},"external_urls":{"spotify":"https://open.spotify.com/track/3hFDxjmXkN8SVIKzUA304I"},"href":"https://api.spotify.com/v1/tracks/3hFDxjmXkN8SVIKzUA304I","id":"3hFDxjmXkN8SVIKzUA304I","is_local":false,"is_playable":true,"name":"Skwon Meiske","track_number":19,"type":"track","uri":"spotify:track:3hFDxjmXkN8SVIKzUA304I"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/11YiKYULtpVKbNGdpKjaj0"},"href":"https://api.spotify.com/v1/albums/11YiKYULtpVKbNGdpKjaj0","id":"11YiKYULtpVKbNGdpKjaj0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273566d303809ace090f10101c9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02566d303809ace090f10101c9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851566d303809ace090f10101c9"}],"is_playable":true,"name":"New Wave","release_date":"2015-04-07","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:11YiKYULtpVKbNGdpKjaj0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"disc_number":1,"duration_ms":145978,"explicit":true,"external_ids":{"isrc":"NLG661500224"},"external_urls":{"spotify":"https://open.spotify.com/track/0ya4rRxJIIF1B0bLpbJrNP"},"href":"https://api.spotify.com/v1/tracks/0ya4rRxJIIF1B0bLpbJrNP","id":"0ya4rRxJIIF1B0bLpbJrNP","is_local":false,"is_playable":true,"name":"Drank & Drugs","track_number":11,"type":"track","uri":"spotify:track:0ya4rRxJIIF1B0bLpbJrNP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/4dhjoNEwjKzRFE4AuRYFSV"},"href":"https://api.spotify.com/v1/albums/4dhjoNEwjKzRFE4AuRYFSV","id":"4dhjoNEwjKzRFE4AuRYFSV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335a30b58634baf0a81a0ede4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235a30b58634baf0a81a0ede4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135a30b58634baf0a81a0ede4"}],"is_playable":true,"name":"Alleen","release_date":"2017-06-23","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4dhjoNEwjKzRFE4AuRYFSV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":268016,"explicit":true,"external_ids":{"isrc":"NLG661700452"},"external_urls":{"spotify":"https://open.spotify.com/track/5mu1UYwTNcY1tRMtZc0urE"},"href":"https://api.spotify.com/v1/tracks/5mu1UYwTNcY1tRMtZc0urE","id":"5mu1UYwTNcY1tRMtZc0urE","is_local":false,"is_playable":true,"name":"Vliegtuig","track_number":11,"type":"track","uri":"spotify:track:5mu1UYwTNcY1tRMtZc0urE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/4dhjoNEwjKzRFE4AuRYFSV"},"href":"https://api.spotify.com/v1/albums/4dhjoNEwjKzRFE4AuRYFSV","id":"4dhjoNEwjKzRFE4AuRYFSV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335a30b58634baf0a81a0ede4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235a30b58634baf0a81a0ede4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135a30b58634baf0a81a0ede4"}],"is_playable":true,"name":"Alleen","release_date":"2017-06-23","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4dhjoNEwjKzRFE4AuRYFSV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":165365,"explicit":true,"external_ids":{"isrc":"NLG661700450"},"external_urls":{"spotify":"https://open.spotify.com/track/33aKDOoySACXO0DtUg5D5t"},"href":"https://api.spotify.com/v1/tracks/33aKDOoySACXO0DtUg5D5t","id":"33aKDOoySACXO0DtUg5D5t","is_local":false,"is_playable":true,"name":"Kleine Jongen","track_number":9,"type":"track","uri":"spotify:track:33aKDOoySACXO0DtUg5D5t"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/4dhjoNEwjKzRFE4AuRYFSV"},"href":"https://api.spotify.com/v1/albums/4dhjoNEwjKzRFE4AuRYFSV","id":"4dhjoNEwjKzRFE4AuRYFSV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335a30b58634baf0a81a0ede4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235a30b58634baf0a81a0ede4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135a30b58634baf0a81a0ede4"}],"is_playable":true,"name":"Alleen","release_date":"2017-06-23","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4dhjoNEwjKzRFE4AuRYFSV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7ge3QfYPMTjDbMoVLuuIuJ"},"href":"https://api.spotify.com/v1/artists/7ge3QfYPMTjDbMoVLuuIuJ","id":"7ge3QfYPMTjDbMoVLuuIuJ","name":"Hef","type":"artist","uri":"spotify:artist:7ge3QfYPMTjDbMoVLuuIuJ"}],"disc_number":1,"duration_ms":288237,"explicit":true,"external_ids":{"isrc":"NLG661700474"},"external_urls":{"spotify":"https://open.spotify.com/track/7oUs0d0G52BlySg6BkmNPa"},"href":"https://api.spotify.com/v1/tracks/7oUs0d0G52BlySg6BkmNPa","id":"7oUs0d0G52BlySg6BkmNPa","is_local":false,"is_playable":true,"name":"Batterij","track_number":18,"type":"track","uri":"spotify:track:7oUs0d0G52BlySg6BkmNPa"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ZGI2wKCmxmq9hJuj3QeCz"},"href":"https://api.spotify.com/v1/albums/5ZGI2wKCmxmq9hJuj3QeCz","id":"5ZGI2wKCmxmq9hJuj3QeCz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d16b2a7f81378d81075e2bbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d16b2a7f81378d81075e2bbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d16b2a7f81378d81075e2bbc"}],"is_playable":true,"name":"Hits Van Hier - Het Beste Van 2018 en veel meer...","release_date":"2018-11-16","release_date_precision":"day","total_tracks":63,"type":"album","uri":"spotify:album:5ZGI2wKCmxmq9hJuj3QeCz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2qOiPRcHqn8ytGWxCf8U4S"},"href":"https://api.spotify.com/v1/artists/2qOiPRcHqn8ytGWxCf8U4S","id":"2qOiPRcHqn8ytGWxCf8U4S","name":"Niels & Wiels","type":"artist","uri":"spotify:artist:2qOiPRcHqn8ytGWxCf8U4S"}],"disc_number":1,"duration_ms":165493,"explicit":false,"external_ids":{"isrc":"BEK011700066"},"external_urls":{"spotify":"https://open.spotify.com/track/77UF6mhJ7Vn1lwUUKPqjlv"},"href":"https://api.spotify.com/v1/tracks/77UF6mhJ7Vn1lwUUKPqjlv","id":"77UF6mhJ7Vn1lwUUKPqjlv","is_local":false,"is_playable":true,"name":"Skwon Meiske","track_number":48,"type":"track","uri":"spotify:track:77UF6mhJ7Vn1lwUUKPqjlv"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6VT2Npi6yGDqn3H07qI1DY"},"href":"https://api.spotify.com/v1/artists/6VT2Npi6yGDqn3H07qI1DY","id":"6VT2Npi6yGDqn3H07qI1DY","name":"ADF","type":"artist","uri":"spotify:artist:6VT2Npi6yGDqn3H07qI1DY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qeFPM2PZUCzcpkY4e4RC8"},"href":"https://api.spotify.com/v1/artists/5qeFPM2PZUCzcpkY4e4RC8","id":"5qeFPM2PZUCzcpkY4e4RC8","name":"ADF Samski","type":"artist","uri":"spotify:artist:5qeFPM2PZUCzcpkY4e4RC8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qbldCiZAkn2KfwyUfithX"},"href":"https://api.spotify.com/v1/artists/5qbldCiZAkn2KfwyUfithX","id":"5qbldCiZAkn2KfwyUfithX","name":"Carel","type":"artist","uri":"spotify:artist:5qbldCiZAkn2KfwyUfithX"}],"external_urls":{"spotify":"https://open.spotify.com/album/3TuIkrTo6MZGWQLkchWExB"},"href":"https://api.spotify.com/v1/albums/3TuIkrTo6MZGWQLkchWExB","id":"3TuIkrTo6MZGWQLkchWExB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273789394176534477c50fdfebb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02789394176534477c50fdfebb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851789394176534477c50fdfebb"}],"is_playable":true,"name":"AL ME LADIES (feat. Scarface)","release_date":"2026-07-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3TuIkrTo6MZGWQLkchWExB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6VT2Npi6yGDqn3H07qI1DY"},"href":"https://api.spotify.com/v1/artists/6VT2Npi6yGDqn3H07qI1DY","id":"6VT2Npi6yGDqn3H07qI1DY","name":"ADF","type":"artist","uri":"spotify:artist:6VT2Npi6yGDqn3H07qI1DY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qeFPM2PZUCzcpkY4e4RC8"},"href":"https://api.spotify.com/v1/artists/5qeFPM2PZUCzcpkY4e4RC8","id":"5qeFPM2PZUCzcpkY4e4RC8","name":"ADF Samski","type":"artist","uri":"spotify:artist:5qeFPM2PZUCzcpkY4e4RC8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qbldCiZAkn2KfwyUfithX"},"href":"https://api.spotify.com/v1/artists/5qbldCiZAkn2KfwyUfithX","id":"5qbldCiZAkn2KfwyUfithX","name":"Carel","type":"artist","uri":"spotify:artist:5qbldCiZAkn2KfwyUfithX"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0AKfGRIDWDiLB8EHORfP8J"},"href":"https://api.spotify.com/v1/artists/0AKfGRIDWDiLB8EHORfP8J","id":"0AKfGRIDWDiLB8EHORfP8J","name":"Scarface","type":"artist","uri":"spotify:artist:0AKfGRIDWDiLB8EHORfP8J"}],"disc_number":1,"duration_ms":127493,"explicit":true,"external_ids":{"isrc":"NL5HJ2600103"},"external_urls":{"spotify":"https://open.spotify.com/track/5xatt9NJdj7mAYE5ZxrpPo"},"href":"https://api.spotify.com/v1/tracks/5xatt9NJdj7mAYE5ZxrpPo","id":"5xatt9NJdj7mAYE5ZxrpPo","is_local":false,"is_playable":true,"name":"AL ME LADIES (feat. Scarface)","track_number":1,"type":"track","uri":"spotify:track:5xatt9NJdj7mAYE5ZxrpPo"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6VT2Npi6yGDqn3H07qI1DY"},"href":"https://api.spotify.com/v1/artists/6VT2Npi6yGDqn3H07qI1DY","id":"6VT2Npi6yGDqn3H07qI1DY","name":"ADF","type":"artist","uri":"spotify:artist:6VT2Npi6yGDqn3H07qI1DY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0UW6JJvOT28AEOnu9H9d5l"},"href":"https://api.spotify.com/v1/artists/0UW6JJvOT28AEOnu9H9d5l","id":"0UW6JJvOT28AEOnu9H9d5l","name":"DJ DYLVN","type":"artist","uri":"spotify:artist:0UW6JJvOT28AEOnu9H9d5l"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qbldCiZAkn2KfwyUfithX"},"href":"https://api.spotify.com/v1/artists/5qbldCiZAkn2KfwyUfithX","id":"5qbldCiZAkn2KfwyUfithX","name":"Carel","type":"artist","uri":"spotify:artist:5qbldCiZAkn2KfwyUfithX"}],"external_urls":{"spotify":"https://open.spotify.com/album/3EZYBf3uZB5ilS6Olfammf"},"href":"https://api.spotify.com/v1/albums/3EZYBf3uZB5ilS6Olfammf","id":"3EZYBf3uZB5ilS6Olfammf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ddc03d154fc2d2fa6db1d59f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ddc03d154fc2d2fa6db1d59f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ddc03d154fc2d2fa6db1d59f"}],"is_playable":true,"name":"Punta cana (feat. ADF Antje & Trapmoneybiggie)","release_date":"2026-04-24","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3EZYBf3uZB5ilS6Olfammf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6VT2Npi6yGDqn3H07qI1DY"},"href":"https://api.spotify.com/v1/artists/6VT2Npi6yGDqn3H07qI1DY","id":"6VT2Npi6yGDqn3H07qI1DY","name":"ADF","type":"artist","uri":"spotify:artist:6VT2Npi6yGDqn3H07qI1DY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0UW6JJvOT28AEOnu9H9d5l"},"href":"https://api.spotify.com/v1/artists/0UW6JJvOT28AEOnu9H9d5l","id":"0UW6JJvOT28AEOnu9H9d5l","name":"DJ DYLVN","type":"artist","uri":"spotify:artist:0UW6JJvOT28AEOnu9H9d5l"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qbldCiZAkn2KfwyUfithX"},"href":"https://api.spotify.com/v1/artists/5qbldCiZAkn2KfwyUfithX","id":"5qbldCiZAkn2KfwyUfithX","name":"Carel","type":"artist","uri":"spotify:artist:5qbldCiZAkn2KfwyUfithX"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0CKK7htZL4Vhg1OycK8FFP"},"href":"https://api.spotify.com/v1/artists/0CKK7htZL4Vhg1OycK8FFP","id":"0CKK7htZL4Vhg1OycK8FFP","name":"ADF Antje","type":"artist","uri":"spotify:artist:0CKK7htZL4Vhg1OycK8FFP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2chklSpWYaRe261GLkvKrv"},"href":"https://api.spotify.com/v1/artists/2chklSpWYaRe261GLkvKrv","id":"2chklSpWYaRe261GLkvKrv","name":"Trapmoneybiggie","type":"artist","uri":"spotify:artist:2chklSpWYaRe261GLkvKrv"}],"disc_number":1,"duration_ms":148185,"explicit":true,"external_ids":{"isrc":"NL5MB2600002"},"external_urls":{"spotify":"https://open.spotify.com/track/6zDGORdshSWpR5nYMnEUZH"},"href":"https://api.spotify.com/v1/tracks/6zDGORdshSWpR5nYMnEUZH","id":"6zDGORdshSWpR5nYMnEUZH","is_local":false,"is_playable":true,"name":"PUNTA CANA","track_number":1,"type":"track","uri":"spotify:track:6zDGORdshSWpR5nYMnEUZH"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1aK4CAEPdOJS3wBL0OnQts"},"href":"https://api.spotify.com/v1/artists/1aK4CAEPdOJS3wBL0OnQts","id":"1aK4CAEPdOJS3wBL0OnQts","name":"Clouseau","type":"artist","uri":"spotify:artist:1aK4CAEPdOJS3wBL0OnQts"}],"external_urls":{"spotify":"https://open.spotify.com/album/1Mb33LmzfpZxWa2KrsmE98"},"href":"https://api.spotify.com/v1/albums/1Mb33LmzfpZxWa2KrsmE98","id":"1Mb33LmzfpZxWa2KrsmE98","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273150388b78805ffbdac9c14ef"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02150388b78805ffbdac9c14ef"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851150388b78805ffbdac9c14ef"}],"is_playable":true,"name":"Vonken & Vuur","release_date":"2007-04-20","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1Mb33LmzfpZxWa2KrsmE98"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1aK4CAEPdOJS3wBL0OnQts"},"href":"https://api.spotify.com/v1/artists/1aK4CAEPdOJS3wBL0OnQts","id":"1aK4CAEPdOJS3wBL0OnQts","name":"Clouseau","type":"artist","uri":"spotify:artist:1aK4CAEPdOJS3wBL0OnQts"}],"disc_number":1,"duration_ms":235146,"explicit":false,"external_ids":{"isrc":"BEI010700121"},"external_urls":{"spotify":"https://open.spotify.com/track/08E1H7KVLH5fwZ9CWK6okB"},"href":"https://api.spotify.com/v1/tracks/08E1H7KVLH5fwZ9CWK6okB","id":"08E1H7KVLH5fwZ9CWK6okB","is_local":false,"is_playable":true,"name":"Hoe lang","track_number":7,"type":"track","uri":"spotify:track:08E1H7KVLH5fwZ9CWK6okB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1aK4CAEPdOJS3wBL0OnQts"},"href":"https://api.spotify.com/v1/artists/1aK4CAEPdOJS3wBL0OnQts","id":"1aK4CAEPdOJS3wBL0OnQts","name":"Clouseau","type":"artist","uri":"spotify:artist:1aK4CAEPdOJS3wBL0OnQts"}],"external_urls":{"spotify":"https://open.spotify.com/album/02c3CsK16gQll5KhAxZ0cg"},"href":"https://api.spotify.com/v1/albums/02c3CsK16gQll5KhAxZ0cg","id":"02c3CsK16gQll5KhAxZ0cg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27363de7ce0b3db1bcf34c22ea2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0263de7ce0b3db1bcf34c22ea2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485163de7ce0b3db1bcf34c22ea2"}],"is_playable":true,"name":"In Stereo","release_date":"1999","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:02c3CsK16gQll5KhAxZ0cg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1aK4CAEPdOJS3wBL0OnQts"},"href":"https://api.spotify.com/v1/artists/1aK4CAEPdOJS3wBL0OnQts","id":"1aK4CAEPdOJS3wBL0OnQts","name":"Clouseau","type":"artist","uri":"spotify:artist:1aK4CAEPdOJS3wBL0OnQts"}],"disc_number":1,"duration_ms":278800,"explicit":false,"external_ids":{"isrc":"BEI019900402"},"external_urls":{"spotify":"https://open.spotify.com/track/0d1AwREvnro03avsG7zDJB"},"href":"https://api.spotify.com/v1/tracks/0d1AwREvnro03avsG7zDJB","id":"0d1AwREvnro03avsG7zDJB","is_local":false,"is_playable":true,"name":"Hoe lang nog?","track_number":2,"type":"track","uri":"spotify:track:0d1AwREvnro03avsG7zDJB"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1NZWlzamUlMjB2YW4lMjAxNiUyMFJvbm5pZSUyMEZsZXgmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MTAmbGltaXQ9MTAmcXVlcnk9TWVpc2plJTIwdmFuJTIwMTYlMjBSb25uaWUlMjBGbGV4JnR5cGU9dHJhY2siLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MTksIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRBcmlwQUN0d0lWSDY5TmRDYnNKdXMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEFyaXBBQ3R3SVZINjlOZENic0p1cyIsImlkIjoiNEFyaXBBQ3R3SVZINjlOZENic0p1cyIsIm5hbWUiOiJOaWVscyBEZXN0YWRzYmFkZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEFyaXBBQ3R3SVZINjlOZENic0p1cyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzd5enZzeWdMdnRBdlBYVk1xS0NYemQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83eXp2c3lnTHZ0QXZQWFZNcUtDWHpkIiwiaWQiOiI3eXp2c3lnTHZ0QXZQWFZNcUtDWHpkIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzljYjBjNWExZDVkMDM3NjVkYmVhMDJmMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5Y2IwYzVhMWQ1ZDAzNzY1ZGJlYTAyZjIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTljYjBjNWExZDVkMDM3NjVkYmVhMDJmMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTcGVlbHRpamQgKE5pZWxzICYgV2llbHMgRWRpdGllKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDItMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3eXp2c3lnTHZ0QXZQWFZNcUtDWHpkIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMnFPaVBSYw==", + "SHFuOHl0R1d4Q2Y4VTRTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJxT2lQUmNIcW44eXRHV3hDZjhVNFMiLCJpZCI6IjJxT2lQUmNIcW44eXRHV3hDZjhVNFMiLCJuYW1lIjoiTmllbHMgJiBXaWVscyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoycU9pUFJjSHFuOHl0R1d4Q2Y4VTRTIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2NTQ5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkJFSzAxMTcwMDA2NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2hGRHhqbVhrTjhTVklLelVBMzA0SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNoRkR4am1Ya044U1ZJS3pVQTMwNEkiLCJpZCI6IjNoRkR4am1Ya044U1ZJS3pVQTMwNEkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2t3b24gTWVpc2tlIiwidHJhY2tfbnVtYmVyIjoxOSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozaEZEeGptWGtOOFNWSUt6VUEzMDRJIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzExWWlLWVVMdHBWS2JOR2RwS2phajAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xMVlpS1lVTHRwVktiTkdkcEtqYWowIiwiaWQiOiIxMVlpS1lVTHRwVktiTkdkcEtqYWowIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzU2NmQzMDM4MDlhY2UwOTBmMTAxMDFjOSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1NjZkMzAzODA5YWNlMDkwZjEwMTAxYzkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYQ==", + "YjY3NjE2ZDAwMDA0ODUxNTY2ZDMwMzgwOWFjZTA5MGYxMDEwMWM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5ldyBXYXZlIiwicmVsZWFzZV9kYXRlIjoiMjAxNS0wNC0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjExWWlLWVVMdHBWS2JOR2RwS2phajAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zQWxSaXlqTXl3VFZOelRjSGJmOVFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNBbFJpeWpNeXdUVk56VGNIYmY5UVQiLCJpZCI6IjNBbFJpeWpNeXdUVk56VGNIYmY5UVQiLCJuYW1lIjoiTGlsIEtsZWluZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozQWxSaXlqTXl3VFZOelRjSGJmOVFUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCIsImlkIjoiNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCIsIm5hbWUiOiJSb25uaWUgRmxleCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0NTk3OCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYxNTAwMjI0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8weWE0clJ4SklJRjFCMGJMcGJKck5QIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMHlhNHJSeEpJSUYxQjBiTHBiSnJOUCIsImlkIjoiMHlhNHJSeEpJSUYxQjBiTHBiSnJOUCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEcmFuayAmIERydWdzIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoweWE0clJ4SklJRjFCMGJMcGJKck5QIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNBbFJpeWpNeXdUVk56VGNIYmY5UVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0FsUml5ak15d1RWTnpUY0hiZjlRVCIsImlkIjoiM0FsUg==", + "aXlqTXl3VFZOelRjSGJmOVFUIiwibmFtZSI6IkxpbCBLbGVpbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0FsUml5ak15d1RWTnpUY0hiZjlRVCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRkaGpvTkV3akt6UkZFNEF1UllGU1YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80ZGhqb05Fd2pLelJGRTRBdVJZRlNWIiwiaWQiOiI0ZGhqb05Fd2pLelJGRTRBdVJZRlNWIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzM1YTMwYjU4NjM0YmFmMGE4MWEwZWRlNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzNWEzMGI1ODYzNGJhZjBhODFhMGVkZTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTM1YTMwYjU4NjM0YmFmMGE4MWEwZWRlNCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbGxlZW4iLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA2LTIzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NGRoam9ORXdqS3pSRkU0QXVSWUZTViJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNBbFJpeWpNeXdUVk56VGNIYmY5UVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0FsUml5ak15d1RWTnpUY0hiZjlRVCIsImlkIjoiM0FsUml5ak15d1RWTnpUY0hiZjlRVCIsIm5hbWUiOiJMaWwgS2xlaW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNBbFJpeWpNeXdUVk56VGNIYmY5UVQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY4MDE2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjE3MDA0NTIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVtdTFVWXdUTmNZMXRSTXRaYzB1ckUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81bXUxVVl3VE5jWTF0Uk10WmMwdXJFIiwiaWQiOiI1bXUxVVl3VE5jWTF0Uk10WmMwdXJFIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZsaWVndHVpZyIsInRyYWNrXw==", + "bnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1bXUxVVl3VE5jWTF0Uk10WmMwdXJFIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNBbFJpeWpNeXdUVk56VGNIYmY5UVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0FsUml5ak15d1RWTnpUY0hiZjlRVCIsImlkIjoiM0FsUml5ak15d1RWTnpUY0hiZjlRVCIsIm5hbWUiOiJMaWwgS2xlaW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNBbFJpeWpNeXdUVk56VGNIYmY5UVQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80ZGhqb05Fd2pLelJGRTRBdVJZRlNWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNGRoam9ORXdqS3pSRkU0QXVSWUZTViIsImlkIjoiNGRoam9ORXdqS3pSRkU0QXVSWUZTViIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzNWEzMGI1ODYzNGJhZjBhODFhMGVkZTQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzVhMzBiNTg2MzRiYWYwYTgxYTBlZGU0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzNWEzMGI1ODYzNGJhZjBhODFhMGVkZTQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWxsZWVuIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wNi0yMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRkaGpvTkV3akt6UkZFNEF1UllGU1YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zQWxSaXlqTXl3VFZOelRjSGJmOVFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNBbFJpeWpNeXdUVk56VGNIYmY5UVQiLCJpZCI6IjNBbFJpeWpNeXdUVk56VGNIYmY5UVQiLCJuYW1lIjoiTGlsIEtsZWluZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozQWxSaXlqTXl3VFZOelRjSGJmOVFUIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2NTM2NSwiZXhwbGljaXQiOnRydWUsImV4dA==", + "ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjE3MDA0NTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzMzYUtET295U0FDWE8wRHRVZzVENXQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zM2FLRE9veVNBQ1hPMER0VWc1RDV0IiwiaWQiOiIzM2FLRE9veVNBQ1hPMER0VWc1RDV0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IktsZWluZSBKb25nZW4iLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MzNhS0RPb3lTQUNYTzBEdFVnNUQ1dCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zQWxSaXlqTXl3VFZOelRjSGJmOVFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNBbFJpeWpNeXdUVk56VGNIYmY5UVQiLCJpZCI6IjNBbFJpeWpNeXdUVk56VGNIYmY5UVQiLCJuYW1lIjoiTGlsIEtsZWluZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozQWxSaXlqTXl3VFZOelRjSGJmOVFUIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNGRoam9ORXdqS3pSRkU0QXVSWUZTViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRkaGpvTkV3akt6UkZFNEF1UllGU1YiLCJpZCI6IjRkaGpvTkV3akt6UkZFNEF1UllGU1YiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzVhMzBiNTg2MzRiYWYwYTgxYTBlZGU0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjM1YTMwYjU4NjM0YmFmMGE4MWEwZWRlNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzVhMzBiNTg2MzRiYWYwYTgxYTBlZGU0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFsbGVlbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDYtMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0ZGhqb05Fd2pLelJGRTRBdVJZRlNWIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcA==", + "b3RpZnkuY29tL2FydGlzdC8zQWxSaXlqTXl3VFZOelRjSGJmOVFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNBbFJpeWpNeXdUVk56VGNIYmY5UVQiLCJpZCI6IjNBbFJpeWpNeXdUVk56VGNIYmY5UVQiLCJuYW1lIjoiTGlsIEtsZWluZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozQWxSaXlqTXl3VFZOelRjSGJmOVFUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdnZTNRZllQTVRqRGJNb1ZMdXVJdUoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2dlM1FmWVBNVGpEYk1vVkx1dUl1SiIsImlkIjoiN2dlM1FmWVBNVGpEYk1vVkx1dUl1SiIsIm5hbWUiOiJIZWYiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N2dlM1FmWVBNVGpEYk1vVkx1dUl1SiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyODgyMzcsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzY2MTcwMDQ3NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN29VczBkMEc1MkJseVNnNkJrbU5QYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdvVXMwZDBHNTJCbHlTZzZCa21OUGEiLCJpZCI6IjdvVXMwZDBHNTJCbHlTZzZCa21OUGEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmF0dGVyaWoiLCJ0cmFja19udW1iZXIiOjE4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdvVXMwZDBHNTJCbHlTZzZCa21OUGEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVpHSTJ3S0NteG1xOWhKdWozUWVDeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVaR0kyd0tDbXhtcTloSnVqM1FlQ3oiLCJpZCI6IjVaR0kyd0tDbXhtcTloSg==", + "dWozUWVDeiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkMTZiMmE3ZjgxMzc4ZDgxMDc1ZTJiYmMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZDE2YjJhN2Y4MTM3OGQ4MTA3NWUyYmJjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkMTZiMmE3ZjgxMzc4ZDgxMDc1ZTJiYmMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGl0cyBWYW4gSGllciAtIEhldCBCZXN0ZSBWYW4gMjAxOCBlbiB2ZWVsIG1lZXIuLi4iLCJyZWxlYXNlX2RhdGUiOiIyMDE4LTExLTE2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVpHSTJ3S0NteG1xOWhKdWozUWVDeiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJxT2lQUmNIcW44eXRHV3hDZjhVNFMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMnFPaVBSY0hxbjh5dEdXeENmOFU0UyIsImlkIjoiMnFPaVBSY0hxbjh5dEdXeENmOFU0UyIsIm5hbWUiOiJOaWVscyAmIFdpZWxzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJxT2lQUmNIcW44eXRHV3hDZjhVNFMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTY1NDkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiQkVLMDExNzAwMDY2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83N1VGNm1oSjdWbjFsd1VVS1Bxamx2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNzdVRjZtaEo3Vm4xbHdVVUtQcWpsdiIsImlkIjoiNzdVRjZtaEo3Vm4xbHdVVUtQcWpsdiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTa3dvbiBNZWlza2UiLCJ0cmFja19udW1iZXIiOjQ4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjc3VUY2bWhKN1ZuMWx3VVVLUHFqbHYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZWVDJOcGk2eUdEcW4zSDA3cUkxRFkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwbw==", + "dGlmeS5jb20vdjEvYXJ0aXN0cy82VlQyTnBpNnlHRHFuM0gwN3FJMURZIiwiaWQiOiI2VlQyTnBpNnlHRHFuM0gwN3FJMURZIiwibmFtZSI6IkFERiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2VlQyTnBpNnlHRHFuM0gwN3FJMURZIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCIsImlkIjoiNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCIsIm5hbWUiOiJSb25uaWUgRmxleCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVxZUZQTTJQWlVDemNwa1k0ZTRSQzgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXFlRlBNMlBaVUN6Y3BrWTRlNFJDOCIsImlkIjoiNXFlRlBNMlBaVUN6Y3BrWTRlNFJDOCIsIm5hbWUiOiJBREYgU2Ftc2tpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVxZUZQTTJQWlVDemNwa1k0ZTRSQzgifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXFibGRDaVpBa24yS2Z3eVVmaXRoWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81cWJsZENpWkFrbjJLZnd5VWZpdGhYIiwiaWQiOiI1cWJsZENpWkFrbjJLZnd5VWZpdGhYIiwibmFtZSI6IkNhcmVsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVxYmxkQ2laQWtuMktmd3lVZml0aFgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zVHVJa3JUbzZNWkdXUUxrY2hXRXhCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM1R1SWtyVG82TVpHV1FMa2NoV0V4QiIsImlkIjoiM1R1SWtyVG82TVpHV1FMa2NoV0V4QiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3ODkzOTQxNzY1MzQ0NzdjNTBmZGZlYmIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzg5Mzk0MTc2NTM0NDc3YzUwZmRmZWJiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zYw==", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTc4OTM5NDE3NjUzNDQ3N2M1MGZkZmViYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBTCBNRSBMQURJRVMgKGZlYXQuIFNjYXJmYWNlKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDctMDMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNUdUlrclRvNk1aR1dRTGtjaFdFeEIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82VlQyTnBpNnlHRHFuM0gwN3FJMURZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZWVDJOcGk2eUdEcW4zSDA3cUkxRFkiLCJpZCI6IjZWVDJOcGk2eUdEcW4zSDA3cUkxRFkiLCJuYW1lIjoiQURGIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZWVDJOcGk2eUdEcW4zSDA3cUkxRFkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIiwiaWQiOiI1ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIiwibmFtZSI6IlJvbm5pZSBGbGV4IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXFlRlBNMlBaVUN6Y3BrWTRlNFJDOCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81cWVGUE0yUFpVQ3pjcGtZNGU0UkM4IiwiaWQiOiI1cWVGUE0yUFpVQ3pjcGtZNGU0UkM4IiwibmFtZSI6IkFERiBTYW1za2kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFlRlBNMlBaVUN6Y3BrWTRlNFJDOCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81cWJsZENpWkFrbjJLZnd5VWZpdGhYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVxYmxkQ2laQWtuMktmd3lVZml0aFgiLCJpZCI6IjVxYmxkQ2laQWtuMktmd3lVZml0aFgiLCJuYW1lIjoiQ2FyZWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFibGRDaVpBa24yS2Z3eVVmaXRoWCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wQQ==", + "S2ZHUklEV0RpTEI4RUhPUmZQOEoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEFLZkdSSURXRGlMQjhFSE9SZlA4SiIsImlkIjoiMEFLZkdSSURXRGlMQjhFSE9SZlA4SiIsIm5hbWUiOiJTY2FyZmFjZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowQUtmR1JJRFdEaUxCOEVIT1JmUDhKIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEyNzQ5MywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkw1SEoyNjAwMTAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81eGF0dDlOSmRqN21BWUU1WnhycFBvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNXhhdHQ5TkpkajdtQVlFNVp4cnBQbyIsImlkIjoiNXhhdHQ5TkpkajdtQVlFNVp4cnBQbyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBTCBNRSBMQURJRVMgKGZlYXQuIFNjYXJmYWNlKSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1eGF0dDlOSmRqN21BWUU1WnhycFBvIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82VlQyTnBpNnlHRHFuM0gwN3FJMURZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZWVDJOcGk2eUdEcW4zSDA3cUkxRFkiLCJpZCI6IjZWVDJOcGk2eUdEcW4zSDA3cUkxRFkiLCJuYW1lIjoiQURGIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZWVDJOcGk2eUdEcW4zSDA3cUkxRFkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIiwiaWQiOiI1ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIiwibmFtZSI6IlJvbm5pZSBGbGV4IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFVXNkpKdk9UMjhBRU9udTlIOWQ1bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wVVc2Skp2T1QyOEFFT251OUg5ZDVsIiwiaWQiOiIwVVc2Skp2T1QyOEFFT251OUg5ZDVsIg==", + "LCJuYW1lIjoiREogRFlMVk4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFVXNkpKdk9UMjhBRU9udTlIOWQ1bCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81cWJsZENpWkFrbjJLZnd5VWZpdGhYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVxYmxkQ2laQWtuMktmd3lVZml0aFgiLCJpZCI6IjVxYmxkQ2laQWtuMktmd3lVZml0aFgiLCJuYW1lIjoiQ2FyZWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFibGRDaVpBa24yS2Z3eVVmaXRoWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNFWllCZjN1WkI1aWxTNk9sZmFtbWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zRVpZQmYzdVpCNWlsUzZPbGZhbW1mIiwiaWQiOiIzRVpZQmYzdVpCNWlsUzZPbGZhbW1mIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2RkYzAzZDE1NGZjMmQyZmE2ZGIxZDU5ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkZGMwM2QxNTRmYzJkMmZhNmRiMWQ1OWYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWRkYzAzZDE1NGZjMmQyZmE2ZGIxZDU5ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQdW50YSBjYW5hIChmZWF0LiBBREYgQW50amUgJiBUcmFwbW9uZXliaWdnaWUpIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNC0yNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0VaWUJmM3VaQjVpbFM2T2xmYW1tZiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZWVDJOcGk2eUdEcW4zSDA3cUkxRFkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNlZUMk5waTZ5R0Rx", + "bjNIMDdxSTFEWSIsImlkIjoiNlZUMk5waTZ5R0RxbjNIMDdxSTFEWSIsIm5hbWUiOiJBREYiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlZUMk5waTZ5R0RxbjNIMDdxSTFEWSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJpZCI6IjVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJuYW1lIjoiUm9ubmllIEZsZXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wVVc2Skp2T1QyOEFFT251OUg5ZDVsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBVVzZKSnZPVDI4QUVPbnU5SDlkNWwiLCJpZCI6IjBVVzZKSnZPVDI4QUVPbnU5SDlkNWwiLCJuYW1lIjoiREogRFlMVk4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFVXNkpKdk9UMjhBRU9udTlIOWQ1bCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81cWJsZENpWkFrbjJLZnd5VWZpdGhYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVxYmxkQ2laQWtuMktmd3lVZml0aFgiLCJpZCI6IjVxYmxkQ2laQWtuMktmd3lVZml0aFgiLCJuYW1lIjoiQ2FyZWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFibGRDaVpBa24yS2Z3eVVmaXRoWCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wQ0tLN2h0Wkw0VmhnMU95Y0s4RkZQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBDS0s3aHRaTDRWaGcxT3ljSzhGRlAiLCJpZCI6IjBDS0s3aHRaTDRWaGcxT3ljSzhGRlAiLCJuYW1lIjoiQURGIEFudGplIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBDS0s3aHRaTDRWaGcxT3ljSzhGRlAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmNoa2xTcFdZYVJlMjYxR0xrdktydiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yY2hrbFNwV1lhUmUyNjFHTGt2S3J2IiwiaWQiOiIyY2hrbFNwV1lhUmUyNjFHTGt2S3J2IiwibmFtZSI6IlRyYXBtb25leWJpZw==", + "Z2llIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJjaGtsU3BXWWFSZTI2MUdMa3ZLcnYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQ4MTg1LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTDVNQjI2MDAwMDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZ6REdPUmRzaFNXcFI1bllNbkVVWkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82ekRHT1Jkc2hTV3BSNW5ZTW5FVVpIIiwiaWQiOiI2ekRHT1Jkc2hTV3BSNW5ZTW5FVVpIIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBVTlRBIENBTkEiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NnpER09SZHNoU1dwUjVuWU1uRVVaSCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xYUs0Q0FFUGRPSlMzd0JMME9uUXRzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFhSzRDQUVQZE9KUzN3QkwwT25RdHMiLCJpZCI6IjFhSzRDQUVQZE9KUzN3QkwwT25RdHMiLCJuYW1lIjoiQ2xvdXNlYXUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MWFLNENBRVBkT0pTM3dCTDBPblF0cyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFNYjMzTG16ZnBaeFdhMktyc21FOTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xTWIzM0xtemZwWnhXYTJLcnNtRTk4IiwiaWQiOiIxTWIzM0xtemZwWnhXYTJLcnNtRTk4IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE1MDM4OGI3ODgwNWZmYmRhYzljMTRlZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNTAzODhiNzg4MDVmZmJkYWM5YzE0ZWYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE1MDM4OGI3ODgwNWZmYmRhYzljMTRlZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWb25rZW4gJiBWdXVyIiwicmVsZWFzZV9kYXRlIjoiMjAwNy0wNC0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbA==", + "X3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MU1iMzNMbXpmcFp4V2EyS3JzbUU5OCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFhSzRDQUVQZE9KUzN3QkwwT25RdHMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMWFLNENBRVBkT0pTM3dCTDBPblF0cyIsImlkIjoiMWFLNENBRVBkT0pTM3dCTDBPblF0cyIsIm5hbWUiOiJDbG91c2VhdSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxYUs0Q0FFUGRPSlMzd0JMME9uUXRzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNTE0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkJFSTAxMDcwMDEyMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMDhFMUg3S1ZMSDVmd1o5Q1dLNm9rQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzA4RTFIN0tWTEg1ZndaOUNXSzZva0IiLCJpZCI6IjA4RTFIN0tWTEg1ZndaOUNXSzZva0IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9lIGxhbmciLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MDhFMUg3S1ZMSDVmd1o5Q1dLNm9rQiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xYUs0Q0FFUGRPSlMzd0JMME9uUXRzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFhSzRDQUVQZE9KUzN3QkwwT25RdHMiLCJpZCI6IjFhSzRDQUVQZE9KUzN3QkwwT25RdHMiLCJuYW1lIjoiQ2xvdXNlYXUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MWFLNENBRVBkT0pTM3dCTDBPblF0cyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzAyYzNDc0sxNmdRbGw1S2hBeFowY2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wMmMzQ3NLMTZnUWxsNUtoQXhaMGNnIiwiaWQiOiIwMmMzQ3NLMTZnUWxsNUtoQXhaMGNnIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzYzZGU3Y2UwYjNkYjFiY2YzNGMyMmVhMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsIg==", + "dXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjYzZGU3Y2UwYjNkYjFiY2YzNGMyMmVhMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjNkZTdjZTBiM2RiMWJjZjM0YzIyZWEyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkluIFN0ZXJlbyIsInJlbGVhc2VfZGF0ZSI6IjE5OTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MDJjM0NzSzE2Z1FsbDVLaEF4WjBjZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFhSzRDQUVQZE9KUzN3QkwwT25RdHMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMWFLNENBRVBkT0pTM3dCTDBPblF0cyIsImlkIjoiMWFLNENBRVBkT0pTM3dCTDBPblF0cyIsIm5hbWUiOiJDbG91c2VhdSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxYUs0Q0FFUGRPSlMzd0JMME9uUXRzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI3ODgwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkJFSTAxOTkwMDQwMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMGQxQXdSRXZucm8wM2F2c0c3ekRKQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBkMUF3UkV2bnJvMDNhdnNHN3pESkIiLCJpZCI6IjBkMUF3UkV2bnJvMDNhdnNHN3pESkIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9lIGxhbmcgbm9nPyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowZDFBd1JFdm5ybzAzYXZzRzd6REpCIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Meisje+van+16+Ronnie+Flex&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Vlinders%20S10&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Vlinders%20S10&type=track","offset":0,"previous":null,"total":13,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/79zyMxauLvJGmF96szBfLe"},"href":"https://api.spotify.com/v1/albums/79zyMxauLvJGmF96szBfLe","id":"79zyMxauLvJGmF96szBfLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c691f9d8b09e963e7935faab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c691f9d8b09e963e7935faab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c691f9d8b09e963e7935faab"}],"is_playable":true,"name":"Vlinders","release_date":"2020-11-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:79zyMxauLvJGmF96szBfLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"disc_number":1,"duration_ms":188916,"explicit":false,"external_ids":{"isrc":"NLG662000775"},"external_urls":{"spotify":"https://open.spotify.com/track/5IR2Pb8mXT1haK4TEGicx1"},"href":"https://api.spotify.com/v1/tracks/5IR2Pb8mXT1haK4TEGicx1","id":"5IR2Pb8mXT1haK4TEGicx1","is_local":false,"is_playable":true,"name":"Vleugels","track_number":13,"type":"track","uri":"spotify:track:5IR2Pb8mXT1haK4TEGicx1"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/79zyMxauLvJGmF96szBfLe"},"href":"https://api.spotify.com/v1/albums/79zyMxauLvJGmF96szBfLe","id":"79zyMxauLvJGmF96szBfLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c691f9d8b09e963e7935faab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c691f9d8b09e963e7935faab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c691f9d8b09e963e7935faab"}],"is_playable":true,"name":"Vlinders","release_date":"2020-11-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:79zyMxauLvJGmF96szBfLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/267wBt3XfmW3kdOC0JCtcO"},"href":"https://api.spotify.com/v1/artists/267wBt3XfmW3kdOC0JCtcO","id":"267wBt3XfmW3kdOC0JCtcO","name":"sor","type":"artist","uri":"spotify:artist:267wBt3XfmW3kdOC0JCtcO"}],"disc_number":1,"duration_ms":229842,"explicit":false,"external_ids":{"isrc":"NLG662000766"},"external_urls":{"spotify":"https://open.spotify.com/track/5LaljjrflwfOlDYCKzXjus"},"href":"https://api.spotify.com/v1/tracks/5LaljjrflwfOlDYCKzXjus","id":"5LaljjrflwfOlDYCKzXjus","is_local":false,"is_playable":true,"name":"For Days","track_number":2,"type":"track","uri":"spotify:track:5LaljjrflwfOlDYCKzXjus"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/79zyMxauLvJGmF96szBfLe"},"href":"https://api.spotify.com/v1/albums/79zyMxauLvJGmF96szBfLe","id":"79zyMxauLvJGmF96szBfLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c691f9d8b09e963e7935faab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c691f9d8b09e963e7935faab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c691f9d8b09e963e7935faab"}],"is_playable":true,"name":"Vlinders","release_date":"2020-11-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:79zyMxauLvJGmF96szBfLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7bbzOJyYWRp0cef7NpIClP"},"href":"https://api.spotify.com/v1/artists/7bbzOJyYWRp0cef7NpIClP","id":"7bbzOJyYWRp0cef7NpIClP","name":"Nnelg","type":"artist","uri":"spotify:artist:7bbzOJyYWRp0cef7NpIClP"}],"disc_number":1,"duration_ms":209386,"explicit":false,"external_ids":{"isrc":"NLG662000767"},"external_urls":{"spotify":"https://open.spotify.com/track/315teAdSiOTn0niPZSdLlN"},"href":"https://api.spotify.com/v1/tracks/315teAdSiOTn0niPZSdLlN","id":"315teAdSiOTn0niPZSdLlN","is_local":false,"is_playable":true,"name":"Ochtend/Avond","track_number":3,"type":"track","uri":"spotify:track:315teAdSiOTn0niPZSdLlN"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/79zyMxauLvJGmF96szBfLe"},"href":"https://api.spotify.com/v1/albums/79zyMxauLvJGmF96szBfLe","id":"79zyMxauLvJGmF96szBfLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c691f9d8b09e963e7935faab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c691f9d8b09e963e7935faab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c691f9d8b09e963e7935faab"}],"is_playable":true,"name":"Vlinders","release_date":"2020-11-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:79zyMxauLvJGmF96szBfLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Sm4rGKWBnOQhdqDy4JJh0"},"href":"https://api.spotify.com/v1/artists/2Sm4rGKWBnOQhdqDy4JJh0","id":"2Sm4rGKWBnOQhdqDy4JJh0","name":"Zwangere Guy","type":"artist","uri":"spotify:artist:2Sm4rGKWBnOQhdqDy4JJh0"}],"disc_number":1,"duration_ms":216616,"explicit":false,"external_ids":{"isrc":"NLG662000673"},"external_urls":{"spotify":"https://open.spotify.com/track/1zjdjSNExHYua3FmTAQwmY"},"href":"https://api.spotify.com/v1/tracks/1zjdjSNExHYua3FmTAQwmY","id":"1zjdjSNExHYua3FmTAQwmY","is_local":false,"is_playable":true,"name":"Achter Ramen","track_number":10,"type":"track","uri":"spotify:track:1zjdjSNExHYua3FmTAQwmY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/79zyMxauLvJGmF96szBfLe"},"href":"https://api.spotify.com/v1/albums/79zyMxauLvJGmF96szBfLe","id":"79zyMxauLvJGmF96szBfLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c691f9d8b09e963e7935faab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c691f9d8b09e963e7935faab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c691f9d8b09e963e7935faab"}],"is_playable":true,"name":"Vlinders","release_date":"2020-11-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:79zyMxauLvJGmF96szBfLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5T9IzVTXZRCWuaEZzInXP3"},"href":"https://api.spotify.com/v1/artists/5T9IzVTXZRCWuaEZzInXP3","id":"5T9IzVTXZRCWuaEZzInXP3","name":"GIAN","type":"artist","uri":"spotify:artist:5T9IzVTXZRCWuaEZzInXP3"}],"disc_number":1,"duration_ms":241875,"explicit":false,"external_ids":{"isrc":"NLG662000771"},"external_urls":{"spotify":"https://open.spotify.com/track/6treoMt7kbhbuUDMKegEty"},"href":"https://api.spotify.com/v1/tracks/6treoMt7kbhbuUDMKegEty","id":"6treoMt7kbhbuUDMKegEty","is_local":false,"is_playable":true,"name":"Wat Ze Willen","track_number":8,"type":"track","uri":"spotify:track:6treoMt7kbhbuUDMKegEty"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/79zyMxauLvJGmF96szBfLe"},"href":"https://api.spotify.com/v1/albums/79zyMxauLvJGmF96szBfLe","id":"79zyMxauLvJGmF96szBfLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c691f9d8b09e963e7935faab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c691f9d8b09e963e7935faab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c691f9d8b09e963e7935faab"}],"is_playable":true,"name":"Vlinders","release_date":"2020-11-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:79zyMxauLvJGmF96szBfLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"disc_number":1,"duration_ms":176708,"explicit":false,"external_ids":{"isrc":"NLG662000649"},"external_urls":{"spotify":"https://open.spotify.com/track/3eGrcAaHAWBpnFYZnPXYqT"},"href":"https://api.spotify.com/v1/tracks/3eGrcAaHAWBpnFYZnPXYqT","id":"3eGrcAaHAWBpnFYZnPXYqT","is_local":false,"is_playable":true,"name":"Maria","track_number":4,"type":"track","uri":"spotify:track:3eGrcAaHAWBpnFYZnPXYqT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/79zyMxauLvJGmF96szBfLe"},"href":"https://api.spotify.com/v1/albums/79zyMxauLvJGmF96szBfLe","id":"79zyMxauLvJGmF96szBfLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c691f9d8b09e963e7935faab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c691f9d8b09e963e7935faab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c691f9d8b09e963e7935faab"}],"is_playable":true,"name":"Vlinders","release_date":"2020-11-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:79zyMxauLvJGmF96szBfLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3SCB3V2d5Loauz5tfo6Y5G"},"href":"https://api.spotify.com/v1/artists/3SCB3V2d5Loauz5tfo6Y5G","id":"3SCB3V2d5Loauz5tfo6Y5G","name":"Wende","type":"artist","uri":"spotify:artist:3SCB3V2d5Loauz5tfo6Y5G"}],"disc_number":1,"duration_ms":197307,"explicit":false,"external_ids":{"isrc":"NLG662000773"},"external_urls":{"spotify":"https://open.spotify.com/track/3lAIpSW4NcfweYPau3FtwN"},"href":"https://api.spotify.com/v1/tracks/3lAIpSW4NcfweYPau3FtwN","id":"3lAIpSW4NcfweYPau3FtwN","is_local":false,"is_playable":true,"name":"Niet Bang Zijn","track_number":11,"type":"track","uri":"spotify:track:3lAIpSW4NcfweYPau3FtwN"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/79zyMxauLvJGmF96szBfLe"},"href":"https://api.spotify.com/v1/albums/79zyMxauLvJGmF96szBfLe","id":"79zyMxauLvJGmF96szBfLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c691f9d8b09e963e7935faab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c691f9d8b09e963e7935faab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c691f9d8b09e963e7935faab"}],"is_playable":true,"name":"Vlinders","release_date":"2020-11-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:79zyMxauLvJGmF96szBfLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"disc_number":1,"duration_ms":175125,"explicit":true,"external_ids":{"isrc":"NLG662000769"},"external_urls":{"spotify":"https://open.spotify.com/track/40UhtphUBCNs45F4Tum46F"},"href":"https://api.spotify.com/v1/tracks/40UhtphUBCNs45F4Tum46F","id":"40UhtphUBCNs45F4Tum46F","is_local":false,"is_playable":true,"name":"Gelogen","track_number":6,"type":"track","uri":"spotify:track:40UhtphUBCNs45F4Tum46F"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/79zyMxauLvJGmF96szBfLe"},"href":"https://api.spotify.com/v1/albums/79zyMxauLvJGmF96szBfLe","id":"79zyMxauLvJGmF96szBfLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c691f9d8b09e963e7935faab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c691f9d8b09e963e7935faab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c691f9d8b09e963e7935faab"}],"is_playable":true,"name":"Vlinders","release_date":"2020-11-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:79zyMxauLvJGmF96szBfLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"disc_number":1,"duration_ms":217250,"explicit":false,"external_ids":{"isrc":"NLG662000778"},"external_urls":{"spotify":"https://open.spotify.com/track/70jAnTv1oOfiNfeS9iUUJB"},"href":"https://api.spotify.com/v1/tracks/70jAnTv1oOfiNfeS9iUUJB","id":"70jAnTv1oOfiNfeS9iUUJB","is_local":false,"is_playable":true,"name":"Handen Van Mijn Moeder","track_number":16,"type":"track","uri":"spotify:track:70jAnTv1oOfiNfeS9iUUJB"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"external_urls":{"spotify":"https://open.spotify.com/album/630fn7jhz1GbN3pWWuR1qu"},"href":"https://api.spotify.com/v1/albums/630fn7jhz1GbN3pWWuR1qu","id":"630fn7jhz1GbN3pWWuR1qu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f3c0656b75c2a38923ad2124"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f3c0656b75c2a38923ad2124"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f3c0656b75c2a38923ad2124"}],"is_playable":true,"name":"Buut Vrij","release_date":"2025-09-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:630fn7jhz1GbN3pWWuR1qu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"disc_number":1,"duration_ms":158961,"explicit":false,"external_ids":{"isrc":"NLG662500363"},"external_urls":{"spotify":"https://open.spotify.com/track/3QPg1dEGWflIOjyFQyho8i"},"href":"https://api.spotify.com/v1/tracks/3QPg1dEGWflIOjyFQyho8i","id":"3QPg1dEGWflIOjyFQyho8i","is_local":false,"is_playable":true,"name":"Buut Vrij","track_number":1,"type":"track","uri":"spotify:track:3QPg1dEGWflIOjyFQyho8i"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1WbGluZGVycyUyMFMxMCZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvc2VhcmNoP29mZnNldD0xMCZsaW1pdD0xMCZxdWVyeT1WbGluZGVycyUyMFMxMCZ0eXBlPXRyYWNrIiwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEzLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xelQ5U1dDek40NXI3b1ZoeTBWWUxLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJpZCI6IjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJuYW1lIjoiUzEwIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83OXp5TXhhdUx2SkdtRjk2c3pCZkxlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzl6eU14YXVMdkpHbUY5NnN6QmZMZSIsImlkIjoiNzl6eU14YXVMdkpHbUY5NnN6QmZMZSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndp", + "ZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjNjkxZjlkOGIwOWU5NjNlNzkzNWZhYWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNjkxZjlkOGIwOWU5NjNlNzkzNWZhYWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVmxpbmRlcnMiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTExLTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODg5MTYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjIwMDA3NzUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVJUjJQYjhtWFQxaGFLNFRFR2ljeDEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81SVIyUGI4bVhUMWhhSzRURUdpY3gxIiwiaWQiOiI1SVIyUGI4bVhUMWhhSzRURUdpY3gxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZsZXVnZWxzIiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1SVIyUGI4bVhUMWhhSzRURUdpY3gxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIg==", + "OiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxelQ5U1dDek40NXI3b1ZoeTBWWUxLIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpZCI6Ijc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM2OTFmOWQ4YjA5ZTk2M2U3OTM1ZmFhYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZsaW5kZXJzIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0xMS0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc5enlNeGF1THZKR21GOTZzekJmTGUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xelQ5U1dDek40NXI3b1ZoeTBWWUxLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJpZCI6IjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJuYW1lIjoiUzEwIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjY3d0J0M1hmbVcza2RPQzBKQ3RjTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNjd3QnQzWGZtVzNrZE9DMEpDdGNPIiwiaWQiOiIyNjd3QnQzWGZtVzNrZE9DMEpDdGNPIiwibmFtZSI6InNvciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNjd3QnQzWGZtVzNrZE9DMEpDdGNPIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyOTg0MiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzY2MjAwMDc2NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwcw==", + "Oi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81TGFsampyZmx3Zk9sRFlDS3pYanVzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUxhbGpqcmZsd2ZPbERZQ0t6WGp1cyIsImlkIjoiNUxhbGpqcmZsd2ZPbERZQ0t6WGp1cyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGb3IgRGF5cyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1TGFsampyZmx3Zk9sRFlDS3pYanVzIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc5enlNeGF1THZKR21GOTZzekJmTGUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83OXp5TXhhdUx2SkdtRjk2c3pCZkxlIiwiaWQiOiI3OXp5TXhhdUx2SkdtRjk2c3pCZkxlIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2M2OTFmOWQ4YjA5ZTk2M2U3OTM1ZmFhYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjNjkxZjlkOGIwOWU5NjNlNzkzNWZhYWIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM2OTFmOWQ4YjA5ZTk2M2U3OTM1ZmFhYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWbGluZGVycyIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTEtMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3OXp5TXhhdUx2SkdtRjk2c3pCZkxlIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYQ==", + "cnRpc3RzLzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJpZCI6IjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJuYW1lIjoiUzEwIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN2Jiek9KeVlXUnAwY2VmN05wSUNsUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83YmJ6T0p5WVdScDBjZWY3TnBJQ2xQIiwiaWQiOiI3YmJ6T0p5WVdScDBjZWY3TnBJQ2xQIiwibmFtZSI6Ik5uZWxnIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdiYnpPSnlZV1JwMGNlZjdOcElDbFAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA5Mzg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyMDAwNzY3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zMTV0ZUFkU2lPVG4wbmlQWlNkTGxOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzE1dGVBZFNpT1RuMG5pUFpTZExsTiIsImlkIjoiMzE1dGVBZFNpT1RuMG5pUFpTZExsTiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPY2h0ZW5kL0F2b25kIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjMxNXRlQWRTaU9UbjBuaVBaU2RMbE4ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xelQ5U1dDek40NXI3b1ZoeTBWWUxLIiwiaWQiOiIxelQ5U1dDek40NXI3b1ZoeTBWWUxLIiwibmFtZSI6IlMxMCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxelQ5U1dDek40NXI3b1ZoeTBWWUxLIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpZCI6Ijc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzY5MQ==", + "ZjlkOGIwOWU5NjNlNzkzNWZhYWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNjkxZjlkOGIwOWU5NjNlNzkzNWZhYWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVmxpbmRlcnMiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTExLTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU200ckdLV0JuT1FoZHFEeTRKSmgwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTbTRyR0tXQm5PUWhkcUR5NEpKaDAiLCJpZCI6IjJTbTRyR0tXQm5PUWhkcUR5NEpKaDAiLCJuYW1lIjoiWndhbmdlcmUgR3V5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJTbTRyR0tXQm5PUWhkcUR5NEpKaDAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE2NjE2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyMDAwNjczIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xempkalNORXhIWXVhM0ZtVEFRd21ZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMXpqZGpTTkV4SFl1YTNGbVRBUXdtWSIsImlkIjoiMXpqZGpTTkV4SFl1YTNGbVRBUXdtWSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBY2h0ZXIgUmFtZW4iLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjF6amRqU05FeEhZdWEzRm1UQVF3bVkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsIg==", + "YXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xelQ5U1dDek40NXI3b1ZoeTBWWUxLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJpZCI6IjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJuYW1lIjoiUzEwIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83OXp5TXhhdUx2SkdtRjk2c3pCZkxlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzl6eU14YXVMdkpHbUY5NnN6QmZMZSIsImlkIjoiNzl6eU14YXVMdkpHbUY5NnN6QmZMZSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjNjkxZjlkOGIwOWU5NjNlNzkzNWZhYWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNjkxZjlkOGIwOWU5NjNlNzkzNWZhYWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVmxpbmRlcnMiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTExLTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81VDlJelZUWFpSQ1d1YUVaekluWFAzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVUOUl6VlRYWlJDV3VhRVp6SW5YUDMiLCJpZCI6IjVUOUl6VlRYWlJDV3VhRQ==", + "WnpJblhQMyIsIm5hbWUiOiJHSUFOIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVUOUl6VlRYWlJDV3VhRVp6SW5YUDMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQxODc1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyMDAwNzcxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82dHJlb010N2tiaGJ1VURNS2VnRXR5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNnRyZW9NdDdrYmhidVVETUtlZ0V0eSIsImlkIjoiNnRyZW9NdDdrYmhidVVETUtlZ0V0eSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYXQgWmUgV2lsbGVuIiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZ0cmVvTXQ3a2JoYnVVRE1LZWdFdHkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xelQ5U1dDek40NXI3b1ZoeTBWWUxLIiwiaWQiOiIxelQ5U1dDek40NXI3b1ZoeTBWWUxLIiwibmFtZSI6IlMxMCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxelQ5U1dDek40NXI3b1ZoeTBWWUxLIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpZCI6Ijc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM2OTFmOWQ4YjA5ZTk2M2U3OTM1ZmFhYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZsaW5kZXJzIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0xMS0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOg==", + "ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzY3MDgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjIwMDA2NDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNlR3JjQWFIQVdCcG5GWVpuUFhZcVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zZUdyY0FhSEFXQnBuRllablBYWXFUIiwiaWQiOiIzZUdyY0FhSEFXQnBuRllablBYWXFUIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1hcmlhIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNlR3JjQWFIQVdCcG5GWVpuUFhZcVQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xelQ5U1dDek40NXI3b1ZoeTBWWUxLIiwiaWQiOiIxelQ5U1dDek40NXI3b1ZoeTBWWUxLIiwibmFtZSI6IlMxMCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxelQ5U1dDek40NXI3b1ZoeTBWWUxLIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpZCI6Ijc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidQ==", + "cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNjkxZjlkOGIwOWU5NjNlNzkzNWZhYWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVmxpbmRlcnMiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTExLTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zU0NCM1YyZDVMb2F1ejV0Zm82WTVHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNTQ0IzVjJkNUxvYXV6NXRmbzZZNUciLCJpZCI6IjNTQ0IzVjJkNUxvYXV6NXRmbzZZNUciLCJuYW1lIjoiV2VuZGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1NDQjNWMmQ1TG9hdXo1dGZvNlk1RyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTczMDcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjIwMDA3NzMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNsQUlwU1c0TmNmd2VZUGF1M0Z0d04ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zbEFJcFNXNE5jZndlWVBhdTNGdHdOIiwiaWQiOiIzbEFJcFNXNE5jZndlWVBhdTNGdHdOIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5pZXQgQmFuZyBaaWpuIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozbEFJcFNXNE5jZndlWVBhdTNGdHdOIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdA==", + "aWZ5LmNvbS9hcnRpc3QvMXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xelQ5U1dDek40NXI3b1ZoeTBWWUxLIiwiaWQiOiIxelQ5U1dDek40NXI3b1ZoeTBWWUxLIiwibmFtZSI6IlMxMCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxelQ5U1dDek40NXI3b1ZoeTBWWUxLIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpZCI6Ijc5enlNeGF1THZKR21GOTZzekJmTGUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM2OTFmOWQ4YjA5ZTk2M2U3OTM1ZmFhYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzY5MWY5ZDhiMDllOTYzZTc5MzVmYWFiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZsaW5kZXJzIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0xMS0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc5enlNeGF1THZKR21GOTZzekJmTGUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xelQ5U1dDek40NXI3b1ZoeTBWWUxLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJpZCI6IjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJuYW1lIjoiUzEwIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc1MTI1LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjIwMDA3NjkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzQwVWh0cGhVQkNOczQ1RjRUdW00NkYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80MFVodHBoVUJDTg==", + "czQ1RjRUdW00NkYiLCJpZCI6IjQwVWh0cGhVQkNOczQ1RjRUdW00NkYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR2Vsb2dlbiIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0MFVodHBoVUJDTnM0NUY0VHVtNDZGIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc5enlNeGF1THZKR21GOTZzekJmTGUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83OXp5TXhhdUx2SkdtRjk2c3pCZkxlIiwiaWQiOiI3OXp5TXhhdUx2SkdtRjk2c3pCZkxlIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2M2OTFmOWQ4YjA5ZTk2M2U3OTM1ZmFhYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjNjkxZjlkOGIwOWU5NjNlNzkzNWZhYWIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM2OTFmOWQ4YjA5ZTk2M2U3OTM1ZmFhYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWbGluZGVycyIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTEtMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjo=", + "ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nzl6eU14YXVMdkpHbUY5NnN6QmZMZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTcyNTAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjIwMDA3NzgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzcwakFuVHYxb09maU5mZVM5aVVVSkIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83MGpBblR2MW9PZmlOZmVTOWlVVUpCIiwiaWQiOiI3MGpBblR2MW9PZmlOZmVTOWlVVUpCIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhhbmRlbiBWYW4gTWlqbiBNb2VkZXIiLCJ0cmFja19udW1iZXIiOjE2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjcwakFuVHYxb09maU5mZVM5aVVVSkIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsImlkIjoiMXpUOVNXQ3pONDVyN29WaHkwVllMSyIsIm5hbWUiOiJTMTAiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXpUOVNXQ3pONDVyN29WaHkwVllMSyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzYzMGZuN2poejFHYk4zcFdXdVIxcXUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82MzBmbjdqaHoxR2JOM3BXV3VSMXF1IiwiaWQiOiI2MzBmbjdqaHoxR2JOM3BXV3VSMXF1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2YzYzA2NTZiNzVjMmEzODkyM2FkMjEyNCJ9LHsiaGVpZ2h0Ig==", + "OjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmYzYzA2NTZiNzVjMmEzODkyM2FkMjEyNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjNjMDY1NmI3NWMyYTM4OTIzYWQyMTI0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJ1dXQgVnJpaiIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDktMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjYzMGZuN2poejFHYk4zcFdXdVIxcXUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xelQ5U1dDek40NXI3b1ZoeTBWWUxLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJpZCI6IjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsiLCJuYW1lIjoiUzEwIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF6VDlTV0N6TjQ1cjdvVmh5MFZZTEsifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTU4OTYxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyNTAwMzYzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zUVBnMWRFR1dmbElPanlGUXlobzhpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM1FQZzFkRUdXZmxJT2p5RlF5aG84aSIsImlkIjoiM1FQZzFkRUdXZmxJT2p5RlF5aG84aSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCdXV0IFZyaWoiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M1FQZzFkRUdXZmxJT2p5RlF5aG84aSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Vlinders+S10&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZsdWNodHN0cm9vayUyMiUyMGFydGlzdCUzQSUyMlNlZiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZsdWNodHN0cm9vayUyMiUyMGFydGlzdCUzQSUyMlNlZiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Vluchtstrook%22+artist%3A%22Sef%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Blauw%20Froukje&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63txTraopbR00KYo7mYOOj"},"href":"https://api.spotify.com/v1/artists/63txTraopbR00KYo7mYOOj","id":"63txTraopbR00KYo7mYOOj","name":"The Scene","type":"artist","uri":"spotify:artist:63txTraopbR00KYo7mYOOj"}],"external_urls":{"spotify":"https://open.spotify.com/album/0vy4gAPRStkHhT2uchvshJ"},"href":"https://api.spotify.com/v1/albums/0vy4gAPRStkHhT2uchvshJ","id":"0vy4gAPRStkHhT2uchvshJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273107af50a1a38f36eae1f8d7b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02107af50a1a38f36eae1f8d7b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851107af50a1a38f36eae1f8d7b"}],"is_playable":true,"name":"Blauw","release_date":"1990-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0vy4gAPRStkHhT2uchvshJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63txTraopbR00KYo7mYOOj"},"href":"https://api.spotify.com/v1/artists/63txTraopbR00KYo7mYOOj","id":"63txTraopbR00KYo7mYOOj","name":"The Scene","type":"artist","uri":"spotify:artist:63txTraopbR00KYo7mYOOj"}],"disc_number":1,"duration_ms":276773,"explicit":false,"external_ids":{"isrc":"NLA309000002"},"external_urls":{"spotify":"https://open.spotify.com/track/1jlphb2nyrZ76BIjSgdbcG"},"href":"https://api.spotify.com/v1/tracks/1jlphb2nyrZ76BIjSgdbcG","id":"1jlphb2nyrZ76BIjSgdbcG","is_local":false,"is_playable":true,"name":"Blauw","track_number":1,"type":"track","uri":"spotify:track:1jlphb2nyrZ76BIjSgdbcG"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63txTraopbR00KYo7mYOOj"},"href":"https://api.spotify.com/v1/artists/63txTraopbR00KYo7mYOOj","id":"63txTraopbR00KYo7mYOOj","name":"The Scene","type":"artist","uri":"spotify:artist:63txTraopbR00KYo7mYOOj"}],"external_urls":{"spotify":"https://open.spotify.com/album/6cJXVcjo6QdAOvBFugJvCV"},"href":"https://api.spotify.com/v1/albums/6cJXVcjo6QdAOvBFugJvCV","id":"6cJXVcjo6QdAOvBFugJvCV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bafcc54c62eb5b19b4672b83"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bafcc54c62eb5b19b4672b83"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bafcc54c62eb5b19b4672b83"}],"is_playable":true,"name":"2007","release_date":"2007-05-17","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6cJXVcjo6QdAOvBFugJvCV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63txTraopbR00KYo7mYOOj"},"href":"https://api.spotify.com/v1/artists/63txTraopbR00KYo7mYOOj","id":"63txTraopbR00KYo7mYOOj","name":"The Scene","type":"artist","uri":"spotify:artist:63txTraopbR00KYo7mYOOj"}],"disc_number":1,"duration_ms":236213,"explicit":false,"external_ids":{"isrc":"NLC240700015"},"external_urls":{"spotify":"https://open.spotify.com/track/2PkSvbqhGtxJHNLh8wh2wI"},"href":"https://api.spotify.com/v1/tracks/2PkSvbqhGtxJHNLh8wh2wI","id":"2PkSvbqhGtxJHNLh8wh2wI","is_local":false,"is_playable":true,"name":"Blauw","track_number":2,"type":"track","uri":"spotify:track:2PkSvbqhGtxJHNLh8wh2wI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/1fkpvvE4Y5nZh6TAM9SOmK"},"href":"https://api.spotify.com/v1/albums/1fkpvvE4Y5nZh6TAM9SOmK","id":"1fkpvvE4Y5nZh6TAM9SOmK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730d4f2931cc7bed6dc9802ae9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020d4f2931cc7bed6dc9802ae9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510d4f2931cc7bed6dc9802ae9"}],"is_playable":true,"name":"Blauwe Ruis","release_date":"2002-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1fkpvvE4Y5nZh6TAM9SOmK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":267693,"explicit":false,"external_ids":{"isrc":"NLA270100257"},"external_urls":{"spotify":"https://open.spotify.com/track/65hR9p90SF1JUv4VCRnatj"},"href":"https://api.spotify.com/v1/tracks/65hR9p90SF1JUv4VCRnatj","id":"65hR9p90SF1JUv4VCRnatj","is_local":false,"is_playable":true,"name":"Blauwe Ruis","track_number":2,"type":"track","uri":"spotify:track:65hR9p90SF1JUv4VCRnatj"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GN0wx6gsqLgDoOSPzv2vJ"},"href":"https://api.spotify.com/v1/albums/5GN0wx6gsqLgDoOSPzv2vJ","id":"5GN0wx6gsqLgDoOSPzv2vJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273606f7c82fdf36ba46221bba6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02606f7c82fdf36ba46221bba6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851606f7c82fdf36ba46221bba6"}],"is_playable":true,"name":"Gedeeld Door Ons","release_date":"2019-09-27","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:5GN0wx6gsqLgDoOSPzv2vJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"disc_number":1,"duration_ms":182694,"explicit":false,"external_ids":{"isrc":"NL1CK1900001"},"external_urls":{"spotify":"https://open.spotify.com/track/0N1sqwppd1BwhNdjcIDEG2"},"href":"https://api.spotify.com/v1/tracks/0N1sqwppd1BwhNdjcIDEG2","id":"0N1sqwppd1BwhNdjcIDEG2","is_local":false,"is_playable":true,"name":"Blauwe Dag","track_number":2,"type":"track","uri":"spotify:track:0N1sqwppd1BwhNdjcIDEG2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2onmCslqboJDdDoCo7ZPd2"},"href":"https://api.spotify.com/v1/artists/2onmCslqboJDdDoCo7ZPd2","id":"2onmCslqboJDdDoCo7ZPd2","name":"Django Wagner","type":"artist","uri":"spotify:artist:2onmCslqboJDdDoCo7ZPd2"}],"external_urls":{"spotify":"https://open.spotify.com/album/3YOglX85pvc8ip0Bdy1eA9"},"href":"https://api.spotify.com/v1/albums/3YOglX85pvc8ip0Bdy1eA9","id":"3YOglX85pvc8ip0Bdy1eA9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738e17100d217b8fccebab30b1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028e17100d217b8fccebab30b1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518e17100d217b8fccebab30b1"}],"is_playable":true,"name":"Kali","release_date":"2009-11-08","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3YOglX85pvc8ip0Bdy1eA9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2onmCslqboJDdDoCo7ZPd2"},"href":"https://api.spotify.com/v1/artists/2onmCslqboJDdDoCo7ZPd2","id":"2onmCslqboJDdDoCo7ZPd2","name":"Django Wagner","type":"artist","uri":"spotify:artist:2onmCslqboJDdDoCo7ZPd2"}],"disc_number":1,"duration_ms":201000,"explicit":false,"external_ids":{"isrc":"NLE870919601"},"external_urls":{"spotify":"https://open.spotify.com/track/3cO0vHdCjaPiuWdTrNPOc3"},"href":"https://api.spotify.com/v1/tracks/3cO0vHdCjaPiuWdTrNPOc3","id":"3cO0vHdCjaPiuWdTrNPOc3","is_local":false,"is_playable":true,"name":"Mooie Blauwe Ogen","track_number":6,"type":"track","uri":"spotify:track:3cO0vHdCjaPiuWdTrNPOc3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DOOGHZ6CXsF8bvNrnDE6W"},"href":"https://api.spotify.com/v1/artists/7DOOGHZ6CXsF8bvNrnDE6W","id":"7DOOGHZ6CXsF8bvNrnDE6W","name":"Turfy Gang","type":"artist","uri":"spotify:artist:7DOOGHZ6CXsF8bvNrnDE6W"}],"external_urls":{"spotify":"https://open.spotify.com/album/1XxGzjsU8YtWL8fWWCLIdm"},"href":"https://api.spotify.com/v1/albums/1XxGzjsU8YtWL8fWWCLIdm","id":"1XxGzjsU8YtWL8fWWCLIdm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273df957f9ba453d378c4ca8512"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02df957f9ba453d378c4ca8512"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851df957f9ba453d378c4ca8512"}],"is_playable":true,"name":"Blauwe Maandag","release_date":"2024-01-15","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1XxGzjsU8YtWL8fWWCLIdm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DOOGHZ6CXsF8bvNrnDE6W"},"href":"https://api.spotify.com/v1/artists/7DOOGHZ6CXsF8bvNrnDE6W","id":"7DOOGHZ6CXsF8bvNrnDE6W","name":"Turfy Gang","type":"artist","uri":"spotify:artist:7DOOGHZ6CXsF8bvNrnDE6W"}],"disc_number":1,"duration_ms":139737,"explicit":false,"external_ids":{"isrc":"NLS242400001"},"external_urls":{"spotify":"https://open.spotify.com/track/4USLBM1dfRMnlBqd4SHkBI"},"href":"https://api.spotify.com/v1/tracks/4USLBM1dfRMnlBqd4SHkBI","id":"4USLBM1dfRMnlBqd4SHkBI","is_local":false,"is_playable":true,"name":"Blauwe Maandag","track_number":1,"type":"track","uri":"spotify:track:4USLBM1dfRMnlBqd4SHkBI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"external_urls":{"spotify":"https://open.spotify.com/album/4eNf6WntLR94hrsKlm0Zlw"},"href":"https://api.spotify.com/v1/albums/4eNf6WntLR94hrsKlm0Zlw","id":"4eNf6WntLR94hrsKlm0Zlw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273501d83343b38d984eff8b322"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02501d83343b38d984eff8b322"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851501d83343b38d984eff8b322"}],"is_playable":true,"name":"Blauwe Dag","release_date":"2019-06-28","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:4eNf6WntLR94hrsKlm0Zlw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"disc_number":1,"duration_ms":182694,"explicit":false,"external_ids":{"isrc":"NL1CK1900001"},"external_urls":{"spotify":"https://open.spotify.com/track/6bQDOThuAyOYVFomm36lR4"},"href":"https://api.spotify.com/v1/tracks/6bQDOThuAyOYVFomm36lR4","id":"6bQDOThuAyOYVFomm36lR4","is_local":false,"is_playable":true,"name":"Blauwe Dag","track_number":1,"type":"track","uri":"spotify:track:6bQDOThuAyOYVFomm36lR4"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Blauw%20Froukje&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63txTraopbR00KYo7mYOOj"},"href":"https://api.spotify.com/v1/artists/63txTraopbR00KYo7mYOOj","id":"63txTraopbR00KYo7mYOOj","name":"The Scene","type":"artist","uri":"spotify:artist:63txTraopbR00KYo7mYOOj"}],"external_urls":{"spotify":"https://open.spotify.com/album/0vy4gAPRStkHhT2uchvshJ"},"href":"https://api.spotify.com/v1/albums/0vy4gAPRStkHhT2uchvshJ","id":"0vy4gAPRStkHhT2uchvshJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273107af50a1a38f36eae1f8d7b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02107af50a1a38f36eae1f8d7b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851107af50a1a38f36eae1f8d7b"}],"is_playable":true,"name":"Blauw","release_date":"1990-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0vy4gAPRStkHhT2uchvshJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63txTraopbR00KYo7mYOOj"},"href":"https://api.spotify.com/v1/artists/63txTraopbR00KYo7mYOOj","id":"63txTraopbR00KYo7mYOOj","name":"The Scene","type":"artist","uri":"spotify:artist:63txTraopbR00KYo7mYOOj"}],"disc_number":1,"duration_ms":276773,"explicit":false,"external_ids":{"isrc":"NLA309000002"},"external_urls":{"spotify":"https://open.spotify.com/track/1jlphb2nyrZ76BIjSgdbcG"},"href":"https://api.spotify.com/v1/tracks/1jlphb2nyrZ76BIjSgdbcG","id":"1jlphb2nyrZ76BIjSgdbcG","is_local":false,"is_playable":true,"name":"Blauw","track_number":1,"type":"track","uri":"spotify:track:1jlphb2nyrZ76BIjSgdbcG"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63txTraopbR00KYo7mYOOj"},"href":"https://api.spotify.com/v1/artists/63txTraopbR00KYo7mYOOj","id":"63txTraopbR00KYo7mYOOj","name":"The Scene","type":"artist","uri":"spotify:artist:63txTraopbR00KYo7mYOOj"}],"external_urls":{"spotify":"https://open.spotify.com/album/6cJXVcjo6QdAOvBFugJvCV"},"href":"https://api.spotify.com/v1/albums/6cJXVcjo6QdAOvBFugJvCV","id":"6cJXVcjo6QdAOvBFugJvCV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bafcc54c62eb5b19b4672b83"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bafcc54c62eb5b19b4672b83"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bafcc54c62eb5b19b4672b83"}],"is_playable":true,"name":"2007","release_date":"2007-05-17","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6cJXVcjo6QdAOvBFugJvCV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63txTraopbR00KYo7mYOOj"},"href":"https://api.spotify.com/v1/artists/63txTraopbR00KYo7mYOOj","id":"63txTraopbR00KYo7mYOOj","name":"The Scene","type":"artist","uri":"spotify:artist:63txTraopbR00KYo7mYOOj"}],"disc_number":1,"duration_ms":236213,"explicit":false,"external_ids":{"isrc":"NLC240700015"},"external_urls":{"spotify":"https://open.spotify.com/track/2PkSvbqhGtxJHNLh8wh2wI"},"href":"https://api.spotify.com/v1/tracks/2PkSvbqhGtxJHNLh8wh2wI","id":"2PkSvbqhGtxJHNLh8wh2wI","is_local":false,"is_playable":true,"name":"Blauw","track_number":2,"type":"track","uri":"spotify:track:2PkSvbqhGtxJHNLh8wh2wI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/1fkpvvE4Y5nZh6TAM9SOmK"},"href":"https://api.spotify.com/v1/albums/1fkpvvE4Y5nZh6TAM9SOmK","id":"1fkpvvE4Y5nZh6TAM9SOmK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730d4f2931cc7bed6dc9802ae9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020d4f2931cc7bed6dc9802ae9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510d4f2931cc7bed6dc9802ae9"}],"is_playable":true,"name":"Blauwe Ruis","release_date":"2002-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1fkpvvE4Y5nZh6TAM9SOmK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":267693,"explicit":false,"external_ids":{"isrc":"NLA270100257"},"external_urls":{"spotify":"https://open.spotify.com/track/65hR9p90SF1JUv4VCRnatj"},"href":"https://api.spotify.com/v1/tracks/65hR9p90SF1JUv4VCRnatj","id":"65hR9p90SF1JUv4VCRnatj","is_local":false,"is_playable":true,"name":"Blauwe Ruis","track_number":2,"type":"track","uri":"spotify:track:65hR9p90SF1JUv4VCRnatj"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GN0wx6gsqLgDoOSPzv2vJ"},"href":"https://api.spotify.com/v1/albums/5GN0wx6gsqLgDoOSPzv2vJ","id":"5GN0wx6gsqLgDoOSPzv2vJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273606f7c82fdf36ba46221bba6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02606f7c82fdf36ba46221bba6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851606f7c82fdf36ba46221bba6"}],"is_playable":true,"name":"Gedeeld Door Ons","release_date":"2019-09-27","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:5GN0wx6gsqLgDoOSPzv2vJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"disc_number":1,"duration_ms":182694,"explicit":false,"external_ids":{"isrc":"NL1CK1900001"},"external_urls":{"spotify":"https://open.spotify.com/track/0N1sqwppd1BwhNdjcIDEG2"},"href":"https://api.spotify.com/v1/tracks/0N1sqwppd1BwhNdjcIDEG2","id":"0N1sqwppd1BwhNdjcIDEG2","is_local":false,"is_playable":true,"name":"Blauwe Dag","track_number":2,"type":"track","uri":"spotify:track:0N1sqwppd1BwhNdjcIDEG2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2onmCslqboJDdDoCo7ZPd2"},"href":"https://api.spotify.com/v1/artists/2onmCslqboJDdDoCo7ZPd2","id":"2onmCslqboJDdDoCo7ZPd2","name":"Django Wagner","type":"artist","uri":"spotify:artist:2onmCslqboJDdDoCo7ZPd2"}],"external_urls":{"spotify":"https://open.spotify.com/album/3YOglX85pvc8ip0Bdy1eA9"},"href":"https://api.spotify.com/v1/albums/3YOglX85pvc8ip0Bdy1eA9","id":"3YOglX85pvc8ip0Bdy1eA9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738e17100d217b8fccebab30b1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028e17100d217b8fccebab30b1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518e17100d217b8fccebab30b1"}],"is_playable":true,"name":"Kali","release_date":"2009-11-08","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3YOglX85pvc8ip0Bdy1eA9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2onmCslqboJDdDoCo7ZPd2"},"href":"https://api.spotify.com/v1/artists/2onmCslqboJDdDoCo7ZPd2","id":"2onmCslqboJDdDoCo7ZPd2","name":"Django Wagner","type":"artist","uri":"spotify:artist:2onmCslqboJDdDoCo7ZPd2"}],"disc_number":1,"duration_ms":201000,"explicit":false,"external_ids":{"isrc":"NLE870919601"},"external_urls":{"spotify":"https://open.spotify.com/track/3cO0vHdCjaPiuWdTrNPOc3"},"href":"https://api.spotify.com/v1/tracks/3cO0vHdCjaPiuWdTrNPOc3","id":"3cO0vHdCjaPiuWdTrNPOc3","is_local":false,"is_playable":true,"name":"Mooie Blauwe Ogen","track_number":6,"type":"track","uri":"spotify:track:3cO0vHdCjaPiuWdTrNPOc3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DOOGHZ6CXsF8bvNrnDE6W"},"href":"https://api.spotify.com/v1/artists/7DOOGHZ6CXsF8bvNrnDE6W","id":"7DOOGHZ6CXsF8bvNrnDE6W","name":"Turfy Gang","type":"artist","uri":"spotify:artist:7DOOGHZ6CXsF8bvNrnDE6W"}],"external_urls":{"spotify":"https://open.spotify.com/album/1XxGzjsU8YtWL8fWWCLIdm"},"href":"https://api.spotify.com/v1/albums/1XxGzjsU8YtWL8fWWCLIdm","id":"1XxGzjsU8YtWL8fWWCLIdm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273df957f9ba453d378c4ca8512"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02df957f9ba453d378c4ca8512"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851df957f9ba453d378c4ca8512"}],"is_playable":true,"name":"Blauwe Maandag","release_date":"2024-01-15","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1XxGzjsU8YtWL8fWWCLIdm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DOOGHZ6CXsF8bvNrnDE6W"},"href":"https://api.spotify.com/v1/artists/7DOOGHZ6CXsF8bvNrnDE6W","id":"7DOOGHZ6CXsF8bvNrnDE6W","name":"Turfy Gang","type":"artist","uri":"spotify:artist:7DOOGHZ6CXsF8bvNrnDE6W"}],"disc_number":1,"duration_ms":139737,"explicit":false,"external_ids":{"isrc":"NLS242400001"},"external_urls":{"spotify":"https://open.spotify.com/track/4USLBM1dfRMnlBqd4SHkBI"},"href":"https://api.spotify.com/v1/tracks/4USLBM1dfRMnlBqd4SHkBI","id":"4USLBM1dfRMnlBqd4SHkBI","is_local":false,"is_playable":true,"name":"Blauwe Maandag","track_number":1,"type":"track","uri":"spotify:track:4USLBM1dfRMnlBqd4SHkBI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"external_urls":{"spotify":"https://open.spotify.com/album/4eNf6WntLR94hrsKlm0Zlw"},"href":"https://api.spotify.com/v1/albums/4eNf6WntLR94hrsKlm0Zlw","id":"4eNf6WntLR94hrsKlm0Zlw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273501d83343b38d984eff8b322"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02501d83343b38d984eff8b322"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851501d83343b38d984eff8b322"}],"is_playable":true,"name":"Blauwe Dag","release_date":"2019-06-28","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:4eNf6WntLR94hrsKlm0Zlw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"disc_number":1,"duration_ms":182694,"explicit":false,"external_ids":{"isrc":"NL1CK1900001"},"external_urls":{"spotify":"https://open.spotify.com/track/6bQDOThuAyOYVFomm36lR4"},"href":"https://api.spotify.com/v1/tracks/6bQDOThuAyOYVFomm36lR4","id":"6bQDOThuAyOYVFomm36lR4","is_local":false,"is_playable":true,"name":"Blauwe Dag","track_number":1,"type":"track","uri":"spotify:track:6bQDOThuAyOYVFomm36lR4"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Blauw+Froukje&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Nachtlicht%20S10&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Nachtlicht%20S10&type=track","offset":0,"previous":null,"total":11,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nhzcJeYlnU2ETnKvq83Ul"},"href":"https://api.spotify.com/v1/artists/6nhzcJeYlnU2ETnKvq83Ul","id":"6nhzcJeYlnU2ETnKvq83Ul","name":"Dirk.K Alpe d'Huez","type":"artist","uri":"spotify:artist:6nhzcJeYlnU2ETnKvq83Ul"}],"external_urls":{"spotify":"https://open.spotify.com/album/4xnYnGvw8Zen9nQwCycnUr"},"href":"https://api.spotify.com/v1/albums/4xnYnGvw8Zen9nQwCycnUr","id":"4xnYnGvw8Zen9nQwCycnUr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736518890639197b85903d7c70"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026518890639197b85903d7c70"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516518890639197b85903d7c70"}],"is_playable":true,"name":"Nachtlicht angst","release_date":"2026-06-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4xnYnGvw8Zen9nQwCycnUr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nhzcJeYlnU2ETnKvq83Ul"},"href":"https://api.spotify.com/v1/artists/6nhzcJeYlnU2ETnKvq83Ul","id":"6nhzcJeYlnU2ETnKvq83Ul","name":"Dirk.K Alpe d'Huez","type":"artist","uri":"spotify:artist:6nhzcJeYlnU2ETnKvq83Ul"}],"disc_number":1,"duration_ms":174720,"explicit":false,"external_ids":{"isrc":"QT6E82643474"},"external_urls":{"spotify":"https://open.spotify.com/track/6fP91o6vvCgqtrEYPysRK0"},"href":"https://api.spotify.com/v1/tracks/6fP91o6vvCgqtrEYPysRK0","id":"6fP91o6vvCgqtrEYPysRK0","is_local":false,"is_playable":true,"name":"Nachtlicht angst","track_number":1,"type":"track","uri":"spotify:track:6fP91o6vvCgqtrEYPysRK0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2eg9Pv9qvH6msZjGZ2ynjF"},"href":"https://api.spotify.com/v1/artists/2eg9Pv9qvH6msZjGZ2ynjF","id":"2eg9Pv9qvH6msZjGZ2ynjF","name":"Nachtlichter","type":"artist","uri":"spotify:artist:2eg9Pv9qvH6msZjGZ2ynjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/26yg93OivaSf9M78vYwX81"},"href":"https://api.spotify.com/v1/albums/26yg93OivaSf9M78vYwX81","id":"26yg93OivaSf9M78vYwX81","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734a1ffed67a32579e005778af"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024a1ffed67a32579e005778af"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514a1ffed67a32579e005778af"}],"is_playable":true,"name":"Achilles-Verse","release_date":"2025-12-04","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:26yg93OivaSf9M78vYwX81"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2eg9Pv9qvH6msZjGZ2ynjF"},"href":"https://api.spotify.com/v1/artists/2eg9Pv9qvH6msZjGZ2ynjF","id":"2eg9Pv9qvH6msZjGZ2ynjF","name":"Nachtlichter","type":"artist","uri":"spotify:artist:2eg9Pv9qvH6msZjGZ2ynjF"}],"disc_number":1,"duration_ms":202986,"explicit":false,"external_ids":{"isrc":"QT6FF2528284"},"external_urls":{"spotify":"https://open.spotify.com/track/2br3gyakFzngek6r504Wfh"},"href":"https://api.spotify.com/v1/tracks/2br3gyakFzngek6r504Wfh","id":"2br3gyakFzngek6r504Wfh","is_local":false,"is_playable":true,"name":"Schl\u00fcsselmomente","track_number":4,"type":"track","uri":"spotify:track:2br3gyakFzngek6r504Wfh"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NkzN9w1KCAKszysi08rUe"},"href":"https://api.spotify.com/v1/artists/0NkzN9w1KCAKszysi08rUe","id":"0NkzN9w1KCAKszysi08rUe","name":"B. B. Stiffers","type":"artist","uri":"spotify:artist:0NkzN9w1KCAKszysi08rUe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FBjImLv5pISHv8OgfOrWf"},"href":"https://api.spotify.com/v1/artists/0FBjImLv5pISHv8OgfOrWf","id":"0FBjImLv5pISHv8OgfOrWf","name":"Briana B. Sinners","type":"artist","uri":"spotify:artist:0FBjImLv5pISHv8OgfOrWf"}],"external_urls":{"spotify":"https://open.spotify.com/album/3qiq8fnlJgtxowy2Tgjz8h"},"href":"https://api.spotify.com/v1/albums/3qiq8fnlJgtxowy2Tgjz8h","id":"3qiq8fnlJgtxowy2Tgjz8h","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a14f2552a596d90448143ae6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a14f2552a596d90448143ae6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a14f2552a596d90448143ae6"}],"is_playable":true,"name":"The Love of a God and the Power of Fate [Nachtlicht, Band 2 (ungek\u00fcrzt)]","release_date":"2022","release_date_precision":"year","total_tracks":176,"type":"album","uri":"spotify:album:3qiq8fnlJgtxowy2Tgjz8h"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NkzN9w1KCAKszysi08rUe"},"href":"https://api.spotify.com/v1/artists/0NkzN9w1KCAKszysi08rUe","id":"0NkzN9w1KCAKszysi08rUe","name":"B. B. Stiffers","type":"artist","uri":"spotify:artist:0NkzN9w1KCAKszysi08rUe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FBjImLv5pISHv8OgfOrWf"},"href":"https://api.spotify.com/v1/artists/0FBjImLv5pISHv8OgfOrWf","id":"0FBjImLv5pISHv8OgfOrWf","name":"Briana B. Sinners","type":"artist","uri":"spotify:artist:0FBjImLv5pISHv8OgfOrWf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v7hUWp4d0ho1l5VrN6doV"},"href":"https://api.spotify.com/v1/artists/5v7hUWp4d0ho1l5VrN6doV","id":"5v7hUWp4d0ho1l5VrN6doV","name":"Julia Gruber","type":"artist","uri":"spotify:artist:5v7hUWp4d0ho1l5VrN6doV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7CmiexFzfSZKRlwFKlavk4"},"href":"https://api.spotify.com/v1/artists/7CmiexFzfSZKRlwFKlavk4","id":"7CmiexFzfSZKRlwFKlavk4","name":"Marc Winterkorn","type":"artist","uri":"spotify:artist:7CmiexFzfSZKRlwFKlavk4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/60dJ53pmoSnnvW8pUWJiem"},"href":"https://api.spotify.com/v1/artists/60dJ53pmoSnnvW8pUWJiem","id":"60dJ53pmoSnnvW8pUWJiem","name":"Nini Linnet","type":"artist","uri":"spotify:artist:60dJ53pmoSnnvW8pUWJiem"}],"disc_number":1,"duration_ms":183495,"explicit":false,"external_ids":{"isrc":"DEXN82469126"},"external_urls":{"spotify":"https://open.spotify.com/track/3IeJ6bs0pSvF0jsJTsoYDf"},"href":"https://api.spotify.com/v1/tracks/3IeJ6bs0pSvF0jsJTsoYDf","id":"3IeJ6bs0pSvF0jsJTsoYDf","is_local":false,"is_playable":true,"name":"Kapitel 106 - The Love of a God and the Power of Fate - Nachtlicht, Band 2","track_number":106,"type":"track","uri":"spotify:track:3IeJ6bs0pSvF0jsJTsoYDf"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NkzN9w1KCAKszysi08rUe"},"href":"https://api.spotify.com/v1/artists/0NkzN9w1KCAKszysi08rUe","id":"0NkzN9w1KCAKszysi08rUe","name":"B. B. Stiffers","type":"artist","uri":"spotify:artist:0NkzN9w1KCAKszysi08rUe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FBjImLv5pISHv8OgfOrWf"},"href":"https://api.spotify.com/v1/artists/0FBjImLv5pISHv8OgfOrWf","id":"0FBjImLv5pISHv8OgfOrWf","name":"Briana B. Sinners","type":"artist","uri":"spotify:artist:0FBjImLv5pISHv8OgfOrWf"}],"external_urls":{"spotify":"https://open.spotify.com/album/3qiq8fnlJgtxowy2Tgjz8h"},"href":"https://api.spotify.com/v1/albums/3qiq8fnlJgtxowy2Tgjz8h","id":"3qiq8fnlJgtxowy2Tgjz8h","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a14f2552a596d90448143ae6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a14f2552a596d90448143ae6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a14f2552a596d90448143ae6"}],"is_playable":true,"name":"The Love of a God and the Power of Fate [Nachtlicht, Band 2 (ungek\u00fcrzt)]","release_date":"2022","release_date_precision":"year","total_tracks":176,"type":"album","uri":"spotify:album:3qiq8fnlJgtxowy2Tgjz8h"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NkzN9w1KCAKszysi08rUe"},"href":"https://api.spotify.com/v1/artists/0NkzN9w1KCAKszysi08rUe","id":"0NkzN9w1KCAKszysi08rUe","name":"B. B. Stiffers","type":"artist","uri":"spotify:artist:0NkzN9w1KCAKszysi08rUe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FBjImLv5pISHv8OgfOrWf"},"href":"https://api.spotify.com/v1/artists/0FBjImLv5pISHv8OgfOrWf","id":"0FBjImLv5pISHv8OgfOrWf","name":"Briana B. Sinners","type":"artist","uri":"spotify:artist:0FBjImLv5pISHv8OgfOrWf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v7hUWp4d0ho1l5VrN6doV"},"href":"https://api.spotify.com/v1/artists/5v7hUWp4d0ho1l5VrN6doV","id":"5v7hUWp4d0ho1l5VrN6doV","name":"Julia Gruber","type":"artist","uri":"spotify:artist:5v7hUWp4d0ho1l5VrN6doV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7CmiexFzfSZKRlwFKlavk4"},"href":"https://api.spotify.com/v1/artists/7CmiexFzfSZKRlwFKlavk4","id":"7CmiexFzfSZKRlwFKlavk4","name":"Marc Winterkorn","type":"artist","uri":"spotify:artist:7CmiexFzfSZKRlwFKlavk4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/60dJ53pmoSnnvW8pUWJiem"},"href":"https://api.spotify.com/v1/artists/60dJ53pmoSnnvW8pUWJiem","id":"60dJ53pmoSnnvW8pUWJiem","name":"Nini Linnet","type":"artist","uri":"spotify:artist:60dJ53pmoSnnvW8pUWJiem"}],"disc_number":1,"duration_ms":182764,"explicit":false,"external_ids":{"isrc":"DEXN82469121"},"external_urls":{"spotify":"https://open.spotify.com/track/3PqvkqgLrSX8Qm0uIsBNgE"},"href":"https://api.spotify.com/v1/tracks/3PqvkqgLrSX8Qm0uIsBNgE","id":"3PqvkqgLrSX8Qm0uIsBNgE","is_local":false,"is_playable":true,"name":"Kapitel 101 - The Love of a God and the Power of Fate - Nachtlicht, Band 2","track_number":101,"type":"track","uri":"spotify:track:3PqvkqgLrSX8Qm0uIsBNgE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DpYMZzVNrjqw1geHziUEd"},"href":"https://api.spotify.com/v1/artists/7DpYMZzVNrjqw1geHziUEd","id":"7DpYMZzVNrjqw1geHziUEd","name":"KA","type":"artist","uri":"spotify:artist:7DpYMZzVNrjqw1geHziUEd"}],"external_urls":{"spotify":"https://open.spotify.com/album/01YPoXB22upTPnELbZ1UBw"},"href":"https://api.spotify.com/v1/albums/01YPoXB22upTPnELbZ1UBw","id":"01YPoXB22upTPnELbZ1UBw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27362715ed5ce905f5b7f397d8d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0262715ed5ce905f5b7f397d8d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485162715ed5ce905f5b7f397d8d"}],"is_playable":true,"name":"Reset","release_date":"2026-01-22","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:01YPoXB22upTPnELbZ1UBw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DpYMZzVNrjqw1geHziUEd"},"href":"https://api.spotify.com/v1/artists/7DpYMZzVNrjqw1geHziUEd","id":"7DpYMZzVNrjqw1geHziUEd","name":"KA","type":"artist","uri":"spotify:artist:7DpYMZzVNrjqw1geHziUEd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"disc_number":1,"duration_ms":173000,"explicit":true,"external_ids":{"isrc":"NLG662600074"},"external_urls":{"spotify":"https://open.spotify.com/track/0aF8AteBjXo1mh3Yrc8ge4"},"href":"https://api.spotify.com/v1/tracks/0aF8AteBjXo1mh3Yrc8ge4","id":"0aF8AteBjXo1mh3Yrc8ge4","is_local":false,"is_playable":true,"name":"Nachten Wakker","track_number":4,"type":"track","uri":"spotify:track:0aF8AteBjXo1mh3Yrc8ge4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5poiHC1329W8tyeTHHZF2o"},"href":"https://api.spotify.com/v1/artists/5poiHC1329W8tyeTHHZF2o","id":"5poiHC1329W8tyeTHHZF2o","name":"Javier Morant Barber\u00e1","type":"artist","uri":"spotify:artist:5poiHC1329W8tyeTHHZF2o"}],"external_urls":{"spotify":"https://open.spotify.com/album/4St5g9pWOJil73gtbofdw3"},"href":"https://api.spotify.com/v1/albums/4St5g9pWOJil73gtbofdw3","id":"4St5g9pWOJil73gtbofdw3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27377c620f13d87b8d892d5df7c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0277c620f13d87b8d892d5df7c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485177c620f13d87b8d892d5df7c"}],"is_playable":true,"name":"Body Beat (Industria de ritmos corporales)","release_date":"2026-02-20","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:4St5g9pWOJil73gtbofdw3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5poiHC1329W8tyeTHHZF2o"},"href":"https://api.spotify.com/v1/artists/5poiHC1329W8tyeTHHZF2o","id":"5poiHC1329W8tyeTHHZF2o","name":"Javier Morant Barber\u00e1","type":"artist","uri":"spotify:artist:5poiHC1329W8tyeTHHZF2o"}],"disc_number":1,"duration_ms":182279,"explicit":false,"external_ids":{"isrc":"QZK6N2647457"},"external_urls":{"spotify":"https://open.spotify.com/track/1BgXJj47iP2naPp69fSlCM"},"href":"https://api.spotify.com/v1/tracks/1BgXJj47iP2naPp69fSlCM","id":"1BgXJj47iP2naPp69fSlCM","is_local":false,"is_playable":true,"name":"NACHTLICHT","track_number":4,"type":"track","uri":"spotify:track:1BgXJj47iP2naPp69fSlCM"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0576OJUDm0mCF43uNANoeE"},"href":"https://api.spotify.com/v1/artists/0576OJUDm0mCF43uNANoeE","id":"0576OJUDm0mCF43uNANoeE","name":"Lunaris-SYNVOX","type":"artist","uri":"spotify:artist:0576OJUDm0mCF43uNANoeE"}],"external_urls":{"spotify":"https://open.spotify.com/album/5mv04aLL41VMUrsj4At1Q4"},"href":"https://api.spotify.com/v1/albums/5mv04aLL41VMUrsj4At1Q4","id":"5mv04aLL41VMUrsj4At1Q4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e2da5a653e10f1a7699280c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e2da5a653e10f1a7699280c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e2da5a653e10f1a7699280c"}],"is_playable":true,"name":"Asphalt & Tr\u00e4ume","release_date":"2025-11-04","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:5mv04aLL41VMUrsj4At1Q4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0576OJUDm0mCF43uNANoeE"},"href":"https://api.spotify.com/v1/artists/0576OJUDm0mCF43uNANoeE","id":"0576OJUDm0mCF43uNANoeE","name":"Lunaris-SYNVOX","type":"artist","uri":"spotify:artist:0576OJUDm0mCF43uNANoeE"}],"disc_number":1,"duration_ms":179919,"explicit":true,"external_ids":{"isrc":"QT6EE2536731"},"external_urls":{"spotify":"https://open.spotify.com/track/55oB5NJ4gvnY676lhVvSVA"},"href":"https://api.spotify.com/v1/tracks/55oB5NJ4gvnY676lhVvSVA","id":"55oB5NJ4gvnY676lhVvSVA","is_local":false,"is_playable":true,"name":"Nachtlichter","track_number":2,"type":"track","uri":"spotify:track:55oB5NJ4gvnY676lhVvSVA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5gGxOrxc0sETjLCKY4h7TO"},"href":"https://api.spotify.com/v1/artists/5gGxOrxc0sETjLCKY4h7TO","id":"5gGxOrxc0sETjLCKY4h7TO","name":"Zen Alpha Lullaby Binaural Ethereal Relax Therapy Sleep","type":"artist","uri":"spotify:artist:5gGxOrxc0sETjLCKY4h7TO"}],"external_urls":{"spotify":"https://open.spotify.com/album/1fRsVm1BjoT4cA7rgGbBjw"},"href":"https://api.spotify.com/v1/albums/1fRsVm1BjoT4cA7rgGbBjw","id":"1fRsVm1BjoT4cA7rgGbBjw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273848c06840b8b2b7d6a5cf6bf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02848c06840b8b2b7d6a5cf6bf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851848c06840b8b2b7d6a5cf6bf"}],"is_playable":true,"name":"Sanfte Baby Nacht : Spieluhr zum Schlafen, Vol. 1 (Seite B)","release_date":"2025-12-13","release_date_precision":"day","total_tracks":35,"type":"album","uri":"spotify:album:1fRsVm1BjoT4cA7rgGbBjw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5gGxOrxc0sETjLCKY4h7TO"},"href":"https://api.spotify.com/v1/artists/5gGxOrxc0sETjLCKY4h7TO","id":"5gGxOrxc0sETjLCKY4h7TO","name":"Zen Alpha Lullaby Binaural Ethereal Relax Therapy Sleep","type":"artist","uri":"spotify:artist:5gGxOrxc0sETjLCKY4h7TO"}],"disc_number":1,"duration_ms":131250,"explicit":false,"external_ids":{"isrc":"QT6FY2510651"},"external_urls":{"spotify":"https://open.spotify.com/track/3OQVr9H8SLxu6Jig0G99aN"},"href":"https://api.spotify.com/v1/tracks/3OQVr9H8SLxu6Jig0G99aN","id":"3OQVr9H8SLxu6Jig0G99aN","is_local":false,"is_playable":true,"name":"Nachtlicht (Seite B)","track_number":23,"type":"track","uri":"spotify:track:3OQVr9H8SLxu6Jig0G99aN"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5gGxOrxc0sETjLCKY4h7TO"},"href":"https://api.spotify.com/v1/artists/5gGxOrxc0sETjLCKY4h7TO","id":"5gGxOrxc0sETjLCKY4h7TO","name":"Zen Alpha Lullaby Binaural Ethereal Relax Therapy Sleep","type":"artist","uri":"spotify:artist:5gGxOrxc0sETjLCKY4h7TO"}],"external_urls":{"spotify":"https://open.spotify.com/album/6IBAgJ7fg3zl1AhFh00ZKz"},"href":"https://api.spotify.com/v1/albums/6IBAgJ7fg3zl1AhFh00ZKz","id":"6IBAgJ7fg3zl1AhFh00ZKz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27302dfc34fa4748d21d556a7a9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0202dfc34fa4748d21d556a7a9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485102dfc34fa4748d21d556a7a9"}],"is_playable":true,"name":"Sanfte Baby Nacht : Spieluhr zum Schlafen, Vol. 1 (Seite A)","release_date":"2025-12-13","release_date_precision":"day","total_tracks":35,"type":"album","uri":"spotify:album:6IBAgJ7fg3zl1AhFh00ZKz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5gGxOrxc0sETjLCKY4h7TO"},"href":"https://api.spotify.com/v1/artists/5gGxOrxc0sETjLCKY4h7TO","id":"5gGxOrxc0sETjLCKY4h7TO","name":"Zen Alpha Lullaby Binaural Ethereal Relax Therapy Sleep","type":"artist","uri":"spotify:artist:5gGxOrxc0sETjLCKY4h7TO"}],"disc_number":1,"duration_ms":127484,"explicit":false,"external_ids":{"isrc":"QT6FN2584677"},"external_urls":{"spotify":"https://open.spotify.com/track/6bpgXnEFnGh8bSGfTkoUMi"},"href":"https://api.spotify.com/v1/tracks/6bpgXnEFnGh8bSGfTkoUMi","id":"6bpgXnEFnGh8bSGfTkoUMi","is_local":false,"is_playable":true,"name":"Nachtlicht (Seite A)","track_number":23,"type":"track","uri":"spotify:track:6bpgXnEFnGh8bSGfTkoUMi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3LRhLUkhDGAWfXIrNFKPob"},"href":"https://api.spotify.com/v1/artists/3LRhLUkhDGAWfXIrNFKPob","id":"3LRhLUkhDGAWfXIrNFKPob","name":"Runenmeister","type":"artist","uri":"spotify:artist:3LRhLUkhDGAWfXIrNFKPob"}],"external_urls":{"spotify":"https://open.spotify.com/album/6mMOp5eEWWI6ePTiZ5gQA6"},"href":"https://api.spotify.com/v1/albums/6mMOp5eEWWI6ePTiZ5gQA6","id":"6mMOp5eEWWI6ePTiZ5gQA6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739f433615ffb9fa38abe2af60"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029f433615ffb9fa38abe2af60"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519f433615ffb9fa38abe2af60"}],"is_playable":true,"name":"Plattfuss 2","release_date":"2026-02-05","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6mMOp5eEWWI6ePTiZ5gQA6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3LRhLUkhDGAWfXIrNFKPob"},"href":"https://api.spotify.com/v1/artists/3LRhLUkhDGAWfXIrNFKPob","id":"3LRhLUkhDGAWfXIrNFKPob","name":"Runenmeister","type":"artist","uri":"spotify:artist:3LRhLUkhDGAWfXIrNFKPob"}],"disc_number":1,"duration_ms":126919,"explicit":false,"external_ids":{"isrc":"QZK6P2639745"},"external_urls":{"spotify":"https://open.spotify.com/track/5SphhP8JMzxvLRlNJK92Rc"},"href":"https://api.spotify.com/v1/tracks/5SphhP8JMzxvLRlNJK92Rc","id":"5SphhP8JMzxvLRlNJK92Rc","is_local":false,"is_playable":true,"name":"Nachtlichter","track_number":3,"type":"track","uri":"spotify:track:5SphhP8JMzxvLRlNJK92Rc"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Nachtlicht%20S10&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Nachtlicht%20S10&type=track","offset":0,"previous":null,"total":11,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nhzcJeYlnU2ETnKvq83Ul"},"href":"https://api.spotify.com/v1/artists/6nhzcJeYlnU2ETnKvq83Ul","id":"6nhzcJeYlnU2ETnKvq83Ul","name":"Dirk.K Alpe d'Huez","type":"artist","uri":"spotify:artist:6nhzcJeYlnU2ETnKvq83Ul"}],"external_urls":{"spotify":"https://open.spotify.com/album/4xnYnGvw8Zen9nQwCycnUr"},"href":"https://api.spotify.com/v1/albums/4xnYnGvw8Zen9nQwCycnUr","id":"4xnYnGvw8Zen9nQwCycnUr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736518890639197b85903d7c70"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026518890639197b85903d7c70"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516518890639197b85903d7c70"}],"is_playable":true,"name":"Nachtlicht angst","release_date":"2026-06-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4xnYnGvw8Zen9nQwCycnUr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nhzcJeYlnU2ETnKvq83Ul"},"href":"https://api.spotify.com/v1/artists/6nhzcJeYlnU2ETnKvq83Ul","id":"6nhzcJeYlnU2ETnKvq83Ul","name":"Dirk.K Alpe d'Huez","type":"artist","uri":"spotify:artist:6nhzcJeYlnU2ETnKvq83Ul"}],"disc_number":1,"duration_ms":174720,"explicit":false,"external_ids":{"isrc":"QT6E82643474"},"external_urls":{"spotify":"https://open.spotify.com/track/6fP91o6vvCgqtrEYPysRK0"},"href":"https://api.spotify.com/v1/tracks/6fP91o6vvCgqtrEYPysRK0","id":"6fP91o6vvCgqtrEYPysRK0","is_local":false,"is_playable":true,"name":"Nachtlicht angst","track_number":1,"type":"track","uri":"spotify:track:6fP91o6vvCgqtrEYPysRK0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2eg9Pv9qvH6msZjGZ2ynjF"},"href":"https://api.spotify.com/v1/artists/2eg9Pv9qvH6msZjGZ2ynjF","id":"2eg9Pv9qvH6msZjGZ2ynjF","name":"Nachtlichter","type":"artist","uri":"spotify:artist:2eg9Pv9qvH6msZjGZ2ynjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/26yg93OivaSf9M78vYwX81"},"href":"https://api.spotify.com/v1/albums/26yg93OivaSf9M78vYwX81","id":"26yg93OivaSf9M78vYwX81","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734a1ffed67a32579e005778af"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024a1ffed67a32579e005778af"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514a1ffed67a32579e005778af"}],"is_playable":true,"name":"Achilles-Verse","release_date":"2025-12-04","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:26yg93OivaSf9M78vYwX81"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2eg9Pv9qvH6msZjGZ2ynjF"},"href":"https://api.spotify.com/v1/artists/2eg9Pv9qvH6msZjGZ2ynjF","id":"2eg9Pv9qvH6msZjGZ2ynjF","name":"Nachtlichter","type":"artist","uri":"spotify:artist:2eg9Pv9qvH6msZjGZ2ynjF"}],"disc_number":1,"duration_ms":202986,"explicit":false,"external_ids":{"isrc":"QT6FF2528284"},"external_urls":{"spotify":"https://open.spotify.com/track/2br3gyakFzngek6r504Wfh"},"href":"https://api.spotify.com/v1/tracks/2br3gyakFzngek6r504Wfh","id":"2br3gyakFzngek6r504Wfh","is_local":false,"is_playable":true,"name":"Schl\u00fcsselmomente","track_number":4,"type":"track","uri":"spotify:track:2br3gyakFzngek6r504Wfh"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NkzN9w1KCAKszysi08rUe"},"href":"https://api.spotify.com/v1/artists/0NkzN9w1KCAKszysi08rUe","id":"0NkzN9w1KCAKszysi08rUe","name":"B. B. Stiffers","type":"artist","uri":"spotify:artist:0NkzN9w1KCAKszysi08rUe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FBjImLv5pISHv8OgfOrWf"},"href":"https://api.spotify.com/v1/artists/0FBjImLv5pISHv8OgfOrWf","id":"0FBjImLv5pISHv8OgfOrWf","name":"Briana B. Sinners","type":"artist","uri":"spotify:artist:0FBjImLv5pISHv8OgfOrWf"}],"external_urls":{"spotify":"https://open.spotify.com/album/3qiq8fnlJgtxowy2Tgjz8h"},"href":"https://api.spotify.com/v1/albums/3qiq8fnlJgtxowy2Tgjz8h","id":"3qiq8fnlJgtxowy2Tgjz8h","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a14f2552a596d90448143ae6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a14f2552a596d90448143ae6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a14f2552a596d90448143ae6"}],"is_playable":true,"name":"The Love of a God and the Power of Fate [Nachtlicht, Band 2 (ungek\u00fcrzt)]","release_date":"2022","release_date_precision":"year","total_tracks":176,"type":"album","uri":"spotify:album:3qiq8fnlJgtxowy2Tgjz8h"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NkzN9w1KCAKszysi08rUe"},"href":"https://api.spotify.com/v1/artists/0NkzN9w1KCAKszysi08rUe","id":"0NkzN9w1KCAKszysi08rUe","name":"B. B. Stiffers","type":"artist","uri":"spotify:artist:0NkzN9w1KCAKszysi08rUe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FBjImLv5pISHv8OgfOrWf"},"href":"https://api.spotify.com/v1/artists/0FBjImLv5pISHv8OgfOrWf","id":"0FBjImLv5pISHv8OgfOrWf","name":"Briana B. Sinners","type":"artist","uri":"spotify:artist:0FBjImLv5pISHv8OgfOrWf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v7hUWp4d0ho1l5VrN6doV"},"href":"https://api.spotify.com/v1/artists/5v7hUWp4d0ho1l5VrN6doV","id":"5v7hUWp4d0ho1l5VrN6doV","name":"Julia Gruber","type":"artist","uri":"spotify:artist:5v7hUWp4d0ho1l5VrN6doV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7CmiexFzfSZKRlwFKlavk4"},"href":"https://api.spotify.com/v1/artists/7CmiexFzfSZKRlwFKlavk4","id":"7CmiexFzfSZKRlwFKlavk4","name":"Marc Winterkorn","type":"artist","uri":"spotify:artist:7CmiexFzfSZKRlwFKlavk4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/60dJ53pmoSnnvW8pUWJiem"},"href":"https://api.spotify.com/v1/artists/60dJ53pmoSnnvW8pUWJiem","id":"60dJ53pmoSnnvW8pUWJiem","name":"Nini Linnet","type":"artist","uri":"spotify:artist:60dJ53pmoSnnvW8pUWJiem"}],"disc_number":1,"duration_ms":183495,"explicit":false,"external_ids":{"isrc":"DEXN82469126"},"external_urls":{"spotify":"https://open.spotify.com/track/3IeJ6bs0pSvF0jsJTsoYDf"},"href":"https://api.spotify.com/v1/tracks/3IeJ6bs0pSvF0jsJTsoYDf","id":"3IeJ6bs0pSvF0jsJTsoYDf","is_local":false,"is_playable":true,"name":"Kapitel 106 - The Love of a God and the Power of Fate - Nachtlicht, Band 2","track_number":106,"type":"track","uri":"spotify:track:3IeJ6bs0pSvF0jsJTsoYDf"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NkzN9w1KCAKszysi08rUe"},"href":"https://api.spotify.com/v1/artists/0NkzN9w1KCAKszysi08rUe","id":"0NkzN9w1KCAKszysi08rUe","name":"B. B. Stiffers","type":"artist","uri":"spotify:artist:0NkzN9w1KCAKszysi08rUe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FBjImLv5pISHv8OgfOrWf"},"href":"https://api.spotify.com/v1/artists/0FBjImLv5pISHv8OgfOrWf","id":"0FBjImLv5pISHv8OgfOrWf","name":"Briana B. Sinners","type":"artist","uri":"spotify:artist:0FBjImLv5pISHv8OgfOrWf"}],"external_urls":{"spotify":"https://open.spotify.com/album/3qiq8fnlJgtxowy2Tgjz8h"},"href":"https://api.spotify.com/v1/albums/3qiq8fnlJgtxowy2Tgjz8h","id":"3qiq8fnlJgtxowy2Tgjz8h","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a14f2552a596d90448143ae6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a14f2552a596d90448143ae6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a14f2552a596d90448143ae6"}],"is_playable":true,"name":"The Love of a God and the Power of Fate [Nachtlicht, Band 2 (ungek\u00fcrzt)]","release_date":"2022","release_date_precision":"year","total_tracks":176,"type":"album","uri":"spotify:album:3qiq8fnlJgtxowy2Tgjz8h"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NkzN9w1KCAKszysi08rUe"},"href":"https://api.spotify.com/v1/artists/0NkzN9w1KCAKszysi08rUe","id":"0NkzN9w1KCAKszysi08rUe","name":"B. B. Stiffers","type":"artist","uri":"spotify:artist:0NkzN9w1KCAKszysi08rUe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0FBjImLv5pISHv8OgfOrWf"},"href":"https://api.spotify.com/v1/artists/0FBjImLv5pISHv8OgfOrWf","id":"0FBjImLv5pISHv8OgfOrWf","name":"Briana B. Sinners","type":"artist","uri":"spotify:artist:0FBjImLv5pISHv8OgfOrWf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5v7hUWp4d0ho1l5VrN6doV"},"href":"https://api.spotify.com/v1/artists/5v7hUWp4d0ho1l5VrN6doV","id":"5v7hUWp4d0ho1l5VrN6doV","name":"Julia Gruber","type":"artist","uri":"spotify:artist:5v7hUWp4d0ho1l5VrN6doV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7CmiexFzfSZKRlwFKlavk4"},"href":"https://api.spotify.com/v1/artists/7CmiexFzfSZKRlwFKlavk4","id":"7CmiexFzfSZKRlwFKlavk4","name":"Marc Winterkorn","type":"artist","uri":"spotify:artist:7CmiexFzfSZKRlwFKlavk4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/60dJ53pmoSnnvW8pUWJiem"},"href":"https://api.spotify.com/v1/artists/60dJ53pmoSnnvW8pUWJiem","id":"60dJ53pmoSnnvW8pUWJiem","name":"Nini Linnet","type":"artist","uri":"spotify:artist:60dJ53pmoSnnvW8pUWJiem"}],"disc_number":1,"duration_ms":182764,"explicit":false,"external_ids":{"isrc":"DEXN82469121"},"external_urls":{"spotify":"https://open.spotify.com/track/3PqvkqgLrSX8Qm0uIsBNgE"},"href":"https://api.spotify.com/v1/tracks/3PqvkqgLrSX8Qm0uIsBNgE","id":"3PqvkqgLrSX8Qm0uIsBNgE","is_local":false,"is_playable":true,"name":"Kapitel 101 - The Love of a God and the Power of Fate - Nachtlicht, Band 2","track_number":101,"type":"track","uri":"spotify:track:3PqvkqgLrSX8Qm0uIsBNgE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DpYMZzVNrjqw1geHziUEd"},"href":"https://api.spotify.com/v1/artists/7DpYMZzVNrjqw1geHziUEd","id":"7DpYMZzVNrjqw1geHziUEd","name":"KA","type":"artist","uri":"spotify:artist:7DpYMZzVNrjqw1geHziUEd"}],"external_urls":{"spotify":"https://open.spotify.com/album/01YPoXB22upTPnELbZ1UBw"},"href":"https://api.spotify.com/v1/albums/01YPoXB22upTPnELbZ1UBw","id":"01YPoXB22upTPnELbZ1UBw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27362715ed5ce905f5b7f397d8d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0262715ed5ce905f5b7f397d8d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485162715ed5ce905f5b7f397d8d"}],"is_playable":true,"name":"Reset","release_date":"2026-01-22","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:01YPoXB22upTPnELbZ1UBw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DpYMZzVNrjqw1geHziUEd"},"href":"https://api.spotify.com/v1/artists/7DpYMZzVNrjqw1geHziUEd","id":"7DpYMZzVNrjqw1geHziUEd","name":"KA","type":"artist","uri":"spotify:artist:7DpYMZzVNrjqw1geHziUEd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1zT9SWCzN45r7oVhy0VYLK"},"href":"https://api.spotify.com/v1/artists/1zT9SWCzN45r7oVhy0VYLK","id":"1zT9SWCzN45r7oVhy0VYLK","name":"S10","type":"artist","uri":"spotify:artist:1zT9SWCzN45r7oVhy0VYLK"}],"disc_number":1,"duration_ms":173000,"explicit":true,"external_ids":{"isrc":"NLG662600074"},"external_urls":{"spotify":"https://open.spotify.com/track/0aF8AteBjXo1mh3Yrc8ge4"},"href":"https://api.spotify.com/v1/tracks/0aF8AteBjXo1mh3Yrc8ge4","id":"0aF8AteBjXo1mh3Yrc8ge4","is_local":false,"is_playable":true,"name":"Nachten Wakker","track_number":4,"type":"track","uri":"spotify:track:0aF8AteBjXo1mh3Yrc8ge4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5poiHC1329W8tyeTHHZF2o"},"href":"https://api.spotify.com/v1/artists/5poiHC1329W8tyeTHHZF2o","id":"5poiHC1329W8tyeTHHZF2o","name":"Javier Morant Barber\u00e1","type":"artist","uri":"spotify:artist:5poiHC1329W8tyeTHHZF2o"}],"external_urls":{"spotify":"https://open.spotify.com/album/4St5g9pWOJil73gtbofdw3"},"href":"https://api.spotify.com/v1/albums/4St5g9pWOJil73gtbofdw3","id":"4St5g9pWOJil73gtbofdw3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27377c620f13d87b8d892d5df7c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0277c620f13d87b8d892d5df7c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485177c620f13d87b8d892d5df7c"}],"is_playable":true,"name":"Body Beat (Industria de ritmos corporales)","release_date":"2026-02-20","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:4St5g9pWOJil73gtbofdw3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5poiHC1329W8tyeTHHZF2o"},"href":"https://api.spotify.com/v1/artists/5poiHC1329W8tyeTHHZF2o","id":"5poiHC1329W8tyeTHHZF2o","name":"Javier Morant Barber\u00e1","type":"artist","uri":"spotify:artist:5poiHC1329W8tyeTHHZF2o"}],"disc_number":1,"duration_ms":182279,"explicit":false,"external_ids":{"isrc":"QZK6N2647457"},"external_urls":{"spotify":"https://open.spotify.com/track/1BgXJj47iP2naPp69fSlCM"},"href":"https://api.spotify.com/v1/tracks/1BgXJj47iP2naPp69fSlCM","id":"1BgXJj47iP2naPp69fSlCM","is_local":false,"is_playable":true,"name":"NACHTLICHT","track_number":4,"type":"track","uri":"spotify:track:1BgXJj47iP2naPp69fSlCM"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0576OJUDm0mCF43uNANoeE"},"href":"https://api.spotify.com/v1/artists/0576OJUDm0mCF43uNANoeE","id":"0576OJUDm0mCF43uNANoeE","name":"Lunaris-SYNVOX","type":"artist","uri":"spotify:artist:0576OJUDm0mCF43uNANoeE"}],"external_urls":{"spotify":"https://open.spotify.com/album/5mv04aLL41VMUrsj4At1Q4"},"href":"https://api.spotify.com/v1/albums/5mv04aLL41VMUrsj4At1Q4","id":"5mv04aLL41VMUrsj4At1Q4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e2da5a653e10f1a7699280c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e2da5a653e10f1a7699280c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e2da5a653e10f1a7699280c"}],"is_playable":true,"name":"Asphalt & Tr\u00e4ume","release_date":"2025-11-04","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:5mv04aLL41VMUrsj4At1Q4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0576OJUDm0mCF43uNANoeE"},"href":"https://api.spotify.com/v1/artists/0576OJUDm0mCF43uNANoeE","id":"0576OJUDm0mCF43uNANoeE","name":"Lunaris-SYNVOX","type":"artist","uri":"spotify:artist:0576OJUDm0mCF43uNANoeE"}],"disc_number":1,"duration_ms":179919,"explicit":true,"external_ids":{"isrc":"QT6EE2536731"},"external_urls":{"spotify":"https://open.spotify.com/track/55oB5NJ4gvnY676lhVvSVA"},"href":"https://api.spotify.com/v1/tracks/55oB5NJ4gvnY676lhVvSVA","id":"55oB5NJ4gvnY676lhVvSVA","is_local":false,"is_playable":true,"name":"Nachtlichter","track_number":2,"type":"track","uri":"spotify:track:55oB5NJ4gvnY676lhVvSVA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5gGxOrxc0sETjLCKY4h7TO"},"href":"https://api.spotify.com/v1/artists/5gGxOrxc0sETjLCKY4h7TO","id":"5gGxOrxc0sETjLCKY4h7TO","name":"Zen Alpha Lullaby Binaural Ethereal Relax Therapy Sleep","type":"artist","uri":"spotify:artist:5gGxOrxc0sETjLCKY4h7TO"}],"external_urls":{"spotify":"https://open.spotify.com/album/1fRsVm1BjoT4cA7rgGbBjw"},"href":"https://api.spotify.com/v1/albums/1fRsVm1BjoT4cA7rgGbBjw","id":"1fRsVm1BjoT4cA7rgGbBjw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273848c06840b8b2b7d6a5cf6bf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02848c06840b8b2b7d6a5cf6bf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851848c06840b8b2b7d6a5cf6bf"}],"is_playable":true,"name":"Sanfte Baby Nacht : Spieluhr zum Schlafen, Vol. 1 (Seite B)","release_date":"2025-12-13","release_date_precision":"day","total_tracks":35,"type":"album","uri":"spotify:album:1fRsVm1BjoT4cA7rgGbBjw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5gGxOrxc0sETjLCKY4h7TO"},"href":"https://api.spotify.com/v1/artists/5gGxOrxc0sETjLCKY4h7TO","id":"5gGxOrxc0sETjLCKY4h7TO","name":"Zen Alpha Lullaby Binaural Ethereal Relax Therapy Sleep","type":"artist","uri":"spotify:artist:5gGxOrxc0sETjLCKY4h7TO"}],"disc_number":1,"duration_ms":131250,"explicit":false,"external_ids":{"isrc":"QT6FY2510651"},"external_urls":{"spotify":"https://open.spotify.com/track/3OQVr9H8SLxu6Jig0G99aN"},"href":"https://api.spotify.com/v1/tracks/3OQVr9H8SLxu6Jig0G99aN","id":"3OQVr9H8SLxu6Jig0G99aN","is_local":false,"is_playable":true,"name":"Nachtlicht (Seite B)","track_number":23,"type":"track","uri":"spotify:track:3OQVr9H8SLxu6Jig0G99aN"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5gGxOrxc0sETjLCKY4h7TO"},"href":"https://api.spotify.com/v1/artists/5gGxOrxc0sETjLCKY4h7TO","id":"5gGxOrxc0sETjLCKY4h7TO","name":"Zen Alpha Lullaby Binaural Ethereal Relax Therapy Sleep","type":"artist","uri":"spotify:artist:5gGxOrxc0sETjLCKY4h7TO"}],"external_urls":{"spotify":"https://open.spotify.com/album/6IBAgJ7fg3zl1AhFh00ZKz"},"href":"https://api.spotify.com/v1/albums/6IBAgJ7fg3zl1AhFh00ZKz","id":"6IBAgJ7fg3zl1AhFh00ZKz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27302dfc34fa4748d21d556a7a9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0202dfc34fa4748d21d556a7a9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485102dfc34fa4748d21d556a7a9"}],"is_playable":true,"name":"Sanfte Baby Nacht : Spieluhr zum Schlafen, Vol. 1 (Seite A)","release_date":"2025-12-13","release_date_precision":"day","total_tracks":35,"type":"album","uri":"spotify:album:6IBAgJ7fg3zl1AhFh00ZKz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5gGxOrxc0sETjLCKY4h7TO"},"href":"https://api.spotify.com/v1/artists/5gGxOrxc0sETjLCKY4h7TO","id":"5gGxOrxc0sETjLCKY4h7TO","name":"Zen Alpha Lullaby Binaural Ethereal Relax Therapy Sleep","type":"artist","uri":"spotify:artist:5gGxOrxc0sETjLCKY4h7TO"}],"disc_number":1,"duration_ms":127484,"explicit":false,"external_ids":{"isrc":"QT6FN2584677"},"external_urls":{"spotify":"https://open.spotify.com/track/6bpgXnEFnGh8bSGfTkoUMi"},"href":"https://api.spotify.com/v1/tracks/6bpgXnEFnGh8bSGfTkoUMi","id":"6bpgXnEFnGh8bSGfTkoUMi","is_local":false,"is_playable":true,"name":"Nachtlicht (Seite A)","track_number":23,"type":"track","uri":"spotify:track:6bpgXnEFnGh8bSGfTkoUMi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3LRhLUkhDGAWfXIrNFKPob"},"href":"https://api.spotify.com/v1/artists/3LRhLUkhDGAWfXIrNFKPob","id":"3LRhLUkhDGAWfXIrNFKPob","name":"Runenmeister","type":"artist","uri":"spotify:artist:3LRhLUkhDGAWfXIrNFKPob"}],"external_urls":{"spotify":"https://open.spotify.com/album/6mMOp5eEWWI6ePTiZ5gQA6"},"href":"https://api.spotify.com/v1/albums/6mMOp5eEWWI6ePTiZ5gQA6","id":"6mMOp5eEWWI6ePTiZ5gQA6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739f433615ffb9fa38abe2af60"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029f433615ffb9fa38abe2af60"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519f433615ffb9fa38abe2af60"}],"is_playable":true,"name":"Plattfuss 2","release_date":"2026-02-05","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6mMOp5eEWWI6ePTiZ5gQA6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3LRhLUkhDGAWfXIrNFKPob"},"href":"https://api.spotify.com/v1/artists/3LRhLUkhDGAWfXIrNFKPob","id":"3LRhLUkhDGAWfXIrNFKPob","name":"Runenmeister","type":"artist","uri":"spotify:artist:3LRhLUkhDGAWfXIrNFKPob"}],"disc_number":1,"duration_ms":126919,"explicit":false,"external_ids":{"isrc":"QZK6P2639745"},"external_urls":{"spotify":"https://open.spotify.com/track/5SphhP8JMzxvLRlNJK92Rc"},"href":"https://api.spotify.com/v1/tracks/5SphhP8JMzxvLRlNJK92Rc","id":"5SphhP8JMzxvLRlNJK92Rc","is_local":false,"is_playable":true,"name":"Nachtlichter","track_number":3,"type":"track","uri":"spotify:track:5SphhP8JMzxvLRlNJK92Rc"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Nachtlicht+S10&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk5hcmNvc2UlMjIlMjBhcnRpc3QlM0ElMjJTZWYlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCIsImlkIjoiNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCIsIm5hbWUiOiJTZWYiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVZHaFM2bkhwWFBiWEdoa3U5UlJCMCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzU4aEc4REhlRHR2VkUySXJLcTdJT00ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81OGhHOERIZUR0dlZFMklyS3E3SU9NIiwiaWQiOiI1OGhHOERIZUR0dlZFMklyS3E3SU9NIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mw==", + "M2E1OTQ2MDViNTE1MmU1Y2ZlNmExNGEzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjNhNTk0NjA1YjUxNTJlNWNmZTZhMTRhMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxM2E1OTQ2MDViNTE1MmU1Y2ZlNmExNGEzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6ImxpZXZlIG1vbnN0ZXJzIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wNi0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjU4aEc4REhlRHR2VkUySXJLcTdJT00ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81VkdoUzZuSHBYUGJYR2hrdTlSUkIwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJpZCI6IjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJuYW1lIjoiU2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTczODE3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyNTAwMTMwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80YW9XRFNUOU44dTJWWmJxQndsWFo5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGFvV0RTVDlOOHUyVlpicUJ3bFhaOSIsImlkIjoiNGFvV0RTVDlOOHUyVlpicUJ3bFhaOSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJuYXJjb3NlIiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRhb1dEU1Q5Tjh1MlZaYnFCd2xYWjkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81VkdoUzZuSHBYUGJYR2hrdTlSUkIwIiwiaWQiOiI1VkdoUzZuSHBYUGJYR2hrdTlSUkIwIiwibmFtZSI6IlNlZiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1VkdoUzZuSHBYUGJYR2hrdTlSUg==", + "QjAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82eE1xN0g2NUlGanV4SUo1SldMbm1yIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnhNcTdINjVJRmp1eElKNUpXTG5tciIsImlkIjoiNnhNcTdINjVJRmp1eElKNUpXTG5tciIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlMTcwNDRjNTUzZjNmZDA1YTVhYmRkYjYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTE3MDQ0YzU1M2YzZmQwNWE1YWJkZGI2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlMTcwNDRjNTUzZjNmZDA1YTVhYmRkYjYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoibGlldmUgbW9uc3RlcnM6IGVwaWxvb2ciLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA2LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NnhNcTdINjVJRmp1eElKNUpXTG5tciJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCIsImlkIjoiNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCIsIm5hbWUiOiJTZWYiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVZHaFM2bkhwWFBiWEdoa3U5UlJCMCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzM4MTcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjI1MDAxMzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFIMU12RnhHQms1ak4zSlJhNDk4OVoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xSDFNdkZ4R0JrNWpOM0pSYTQ5ODlaIiwiaWQiOiIxSDFNdkZ4R0JrNWpOM0pSYTQ5ODlaIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Im5hcmNvc2UiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUgxTXZGeEdCazVqTjNKUmE0OTg5WiJ9LHsiYWxidW0iOnsiYWxidW1fdA==", + "eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81VkdoUzZuSHBYUGJYR2hrdTlSUkIwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJpZCI6IjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJuYW1lIjoiU2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80MXB0TzBsZHRPcXJldHczWkU3UkhhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNDFwdE8wbGR0T3FyZXR3M1pFN1JIYSIsImlkIjoiNDFwdE8wbGR0T3FyZXR3M1pFN1JIYSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjZmNhZWRiMGQ1MDc5NjAzNmMwMTkwM2YifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyY2ZjYWVkYjBkNTA3OTYwMzZjMDE5MDNmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjZmNhZWRiMGQ1MDc5NjAzNmMwMTkwM2YifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoibmFyY29zZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDUtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjQxcHRPMGxkdE9xcmV0dzNaRTdSSGEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81VkdoUzZuSHBYUGJYR2hrdTlSUkIwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJpZCI6IjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJuYW1lIjoiU2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTczODE2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyNTAwMTMwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yaW03VlRFQw==", + "ejE5bUR0WUk1TmtWZzYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yaW03VlRFQ3oxOW1EdFlJNU5rVmc2IiwiaWQiOiIyaW03VlRFQ3oxOW1EdFlJNU5rVmc2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Im5hcmNvc2UiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MmltN1ZURUN6MTltRHRZSTVOa1ZnNiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Narcose%22+artist%3A%22Sef%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Slapeloze%20Nachten%20Broederliefde&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Slapeloze%20Nachten%20Broederliefde&type=track","offset":0,"previous":null,"total":15,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Gvj14YkzANT4xQEm3seh0"},"href":"https://api.spotify.com/v1/albums/4Gvj14YkzANT4xQEm3seh0","id":"4Gvj14YkzANT4xQEm3seh0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738a88897ebe35a57a838ca831"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028a88897ebe35a57a838ca831"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518a88897ebe35a57a838ca831"}],"is_playable":true,"name":"Slapeloze Nachten","release_date":"2012-01-01","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:4Gvj14YkzANT4xQEm3seh0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"disc_number":1,"duration_ms":229160,"explicit":false,"external_ids":{"isrc":"NLG661200323"},"external_urls":{"spotify":"https://open.spotify.com/track/652hWPdOUIkKv3a4HJDzBv"},"href":"https://api.spotify.com/v1/tracks/652hWPdOUIkKv3a4HJDzBv","id":"652hWPdOUIkKv3a4HJDzBv","is_local":false,"is_playable":true,"name":"Slapeloze Nachten","track_number":1,"type":"track","uri":"spotify:track:652hWPdOUIkKv3a4HJDzBv"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"external_urls":{"spotify":"https://open.spotify.com/album/1HFoz1ACfQuTwhV9xwRAgL"},"href":"https://api.spotify.com/v1/albums/1HFoz1ACfQuTwhV9xwRAgL","id":"1HFoz1ACfQuTwhV9xwRAgL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273643b5739f17ad8e638dde9e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02643b5739f17ad8e638dde9e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851643b5739f17ad8e638dde9e7"}],"is_playable":true,"name":"Slapeloze Nachten","release_date":"2013-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:1HFoz1ACfQuTwhV9xwRAgL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"disc_number":1,"duration_ms":212223,"explicit":false,"external_ids":{"isrc":"NLG661200323"},"external_urls":{"spotify":"https://open.spotify.com/track/3Ip9paW5KZ3xy1l1tpor63"},"href":"https://api.spotify.com/v1/tracks/3Ip9paW5KZ3xy1l1tpor63","id":"3Ip9paW5KZ3xy1l1tpor63","is_local":false,"is_playable":true,"name":"Slapeloze Nachten","track_number":2,"type":"track","uri":"spotify:track:3Ip9paW5KZ3xy1l1tpor63"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4kswme1Kl2NXRCJ326f14n"},"href":"https://api.spotify.com/v1/artists/4kswme1Kl2NXRCJ326f14n","id":"4kswme1Kl2NXRCJ326f14n","name":"WIES","type":"artist","uri":"spotify:artist:4kswme1Kl2NXRCJ326f14n"}],"external_urls":{"spotify":"https://open.spotify.com/album/0nODZFNixZTpRbiDh7zOnX"},"href":"https://api.spotify.com/v1/albums/0nODZFNixZTpRbiDh7zOnX","id":"0nODZFNixZTpRbiDh7zOnX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273636ce1e936fc0978c92ecac8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02636ce1e936fc0978c92ecac8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851636ce1e936fc0978c92ecac8"}],"is_playable":true,"name":"Het Is Een WIES","release_date":"2021-11-12","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0nODZFNixZTpRbiDh7zOnX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4kswme1Kl2NXRCJ326f14n"},"href":"https://api.spotify.com/v1/artists/4kswme1Kl2NXRCJ326f14n","id":"4kswme1Kl2NXRCJ326f14n","name":"WIES","type":"artist","uri":"spotify:artist:4kswme1Kl2NXRCJ326f14n"}],"disc_number":1,"duration_ms":186093,"explicit":false,"external_ids":{"isrc":"NLSB71900160"},"external_urls":{"spotify":"https://open.spotify.com/track/26LR1DyAaLRGXjq0IiVz4b"},"href":"https://api.spotify.com/v1/tracks/26LR1DyAaLRGXjq0IiVz4b","id":"26LR1DyAaLRGXjq0IiVz4b","is_local":false,"is_playable":true,"name":"Soms Is Het Te Laat","track_number":1,"type":"track","uri":"spotify:track:26LR1DyAaLRGXjq0IiVz4b"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7isSKzkNHe3Tsmht2ar6Ai"},"href":"https://api.spotify.com/v1/artists/7isSKzkNHe3Tsmht2ar6Ai","id":"7isSKzkNHe3Tsmht2ar6Ai","name":"Toontje Lager","type":"artist","uri":"spotify:artist:7isSKzkNHe3Tsmht2ar6Ai"}],"external_urls":{"spotify":"https://open.spotify.com/album/5mAosSoggHR0G5mNXYo1Ci"},"href":"https://api.spotify.com/v1/albums/5mAosSoggHR0G5mNXYo1Ci","id":"5mAosSoggHR0G5mNXYo1Ci","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730605b27ffa0b5d5a7e9ac7ae"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020605b27ffa0b5d5a7e9ac7ae"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510605b27ffa0b5d5a7e9ac7ae"}],"is_playable":true,"name":"Stiekem Dansen","release_date":"1983-09-16","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:5mAosSoggHR0G5mNXYo1Ci"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7isSKzkNHe3Tsmht2ar6Ai"},"href":"https://api.spotify.com/v1/artists/7isSKzkNHe3Tsmht2ar6Ai","id":"7isSKzkNHe3Tsmht2ar6Ai","name":"Toontje Lager","type":"artist","uri":"spotify:artist:7isSKzkNHe3Tsmht2ar6Ai"}],"disc_number":1,"duration_ms":280706,"explicit":false,"external_ids":{"isrc":"NLA349300282"},"external_urls":{"spotify":"https://open.spotify.com/track/6CGAQGexPHQa7osLrDk23R"},"href":"https://api.spotify.com/v1/tracks/6CGAQGexPHQa7osLrDk23R","id":"6CGAQGexPHQa7osLrDk23R","is_local":false,"is_playable":true,"name":"Zoveel Te Doen","track_number":7,"type":"track","uri":"spotify:track:6CGAQGexPHQa7osLrDk23R"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"external_urls":{"spotify":"https://open.spotify.com/album/1zFQTPoaf4Xua3Cjv4rRGm"},"href":"https://api.spotify.com/v1/albums/1zFQTPoaf4Xua3Cjv4rRGm","id":"1zFQTPoaf4Xua3Cjv4rRGm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27301384276095e5892cf35dd3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0201384276095e5892cf35dd3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485101384276095e5892cf35dd3c"}],"is_playable":true,"name":"Joost Klein 7","release_date":"2020-04-24","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:1zFQTPoaf4Xua3Cjv4rRGm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41X1TR6hrK8Q2ZCpp2EqCz"},"href":"https://api.spotify.com/v1/artists/41X1TR6hrK8Q2ZCpp2EqCz","id":"41X1TR6hrK8Q2ZCpp2EqCz","name":"bbno$","type":"artist","uri":"spotify:artist:41X1TR6hrK8Q2ZCpp2EqCz"}],"disc_number":1,"duration_ms":166044,"explicit":true,"external_ids":{"isrc":"QZFZ62092067"},"external_urls":{"spotify":"https://open.spotify.com/track/73zehglCf50sI0ggvUbxch"},"href":"https://api.spotify.com/v1/tracks/73zehglCf50sI0ggvUbxch","id":"73zehglCf50sI0ggvUbxch","is_local":false,"is_playable":true,"name":"Mayo, No Fries!","track_number":2,"type":"track","uri":"spotify:track:73zehglCf50sI0ggvUbxch"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5P65bxTP4Bq4f6EBhsuSMU"},"href":"https://api.spotify.com/v1/albums/5P65bxTP4Bq4f6EBhsuSMU","id":"5P65bxTP4Bq4f6EBhsuSMU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b119107aff5297e2a47f5094"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b119107aff5297e2a47f5094"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b119107aff5297e2a47f5094"}],"is_playable":true,"name":"Best Of The 10s: Party Hits","release_date":"2021-04-06","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:5P65bxTP4Bq4f6EBhsuSMU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"disc_number":1,"duration_ms":229160,"explicit":false,"external_ids":{"isrc":"NLG661200323"},"external_urls":{"spotify":"https://open.spotify.com/track/25JNDWUvZeZpvfXfarMpzJ"},"href":"https://api.spotify.com/v1/tracks/25JNDWUvZeZpvfXfarMpzJ","id":"25JNDWUvZeZpvfXfarMpzJ","is_local":false,"is_playable":true,"name":"Slapeloze Nachten","track_number":4,"type":"track","uri":"spotify:track:25JNDWUvZeZpvfXfarMpzJ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Sm4rGKWBnOQhdqDy4JJh0"},"href":"https://api.spotify.com/v1/artists/2Sm4rGKWBnOQhdqDy4JJh0","id":"2Sm4rGKWBnOQhdqDy4JJh0","name":"Zwangere Guy","type":"artist","uri":"spotify:artist:2Sm4rGKWBnOQhdqDy4JJh0"}],"external_urls":{"spotify":"https://open.spotify.com/album/5yhS5jwfvDxIKqMbc5V0vJ"},"href":"https://api.spotify.com/v1/albums/5yhS5jwfvDxIKqMbc5V0vJ","id":"5yhS5jwfvDxIKqMbc5V0vJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730212d8b88d2fc8774bde8617"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020212d8b88d2fc8774bde8617"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510212d8b88d2fc8774bde8617"}],"is_playable":true,"name":"BRUTAAL","release_date":"2019-11-13","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:5yhS5jwfvDxIKqMbc5V0vJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Sm4rGKWBnOQhdqDy4JJh0"},"href":"https://api.spotify.com/v1/artists/2Sm4rGKWBnOQhdqDy4JJh0","id":"2Sm4rGKWBnOQhdqDy4JJh0","name":"Zwangere Guy","type":"artist","uri":"spotify:artist:2Sm4rGKWBnOQhdqDy4JJh0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0DnbOatBnP7UDkeiQACgxd"},"href":"https://api.spotify.com/v1/artists/0DnbOatBnP7UDkeiQACgxd","id":"0DnbOatBnP7UDkeiQACgxd","name":"Sticks","type":"artist","uri":"spotify:artist:0DnbOatBnP7UDkeiQACgxd"}],"disc_number":1,"duration_ms":236622,"explicit":true,"external_ids":{"isrc":"BEEJ11900047"},"external_urls":{"spotify":"https://open.spotify.com/track/06wccYqnL2isGcE1tmB2n0"},"href":"https://api.spotify.com/v1/tracks/06wccYqnL2isGcE1tmB2n0","id":"06wccYqnL2isGcE1tmB2n0","is_local":false,"is_playable":true,"name":"ELLEBOGENWERK","track_number":8,"type":"track","uri":"spotify:track:06wccYqnL2isGcE1tmB2n0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DpYMZzVNrjqw1geHziUEd"},"href":"https://api.spotify.com/v1/artists/7DpYMZzVNrjqw1geHziUEd","id":"7DpYMZzVNrjqw1geHziUEd","name":"KA","type":"artist","uri":"spotify:artist:7DpYMZzVNrjqw1geHziUEd"}],"external_urls":{"spotify":"https://open.spotify.com/album/2SQP0maBlv8QZunwPVfE3P"},"href":"https://api.spotify.com/v1/albums/2SQP0maBlv8QZunwPVfE3P","id":"2SQP0maBlv8QZunwPVfE3P","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d50ab7ab769aede671e42aa2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d50ab7ab769aede671e42aa2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d50ab7ab769aede671e42aa2"}],"is_playable":true,"name":"Recklezz","release_date":"2022-11-17","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:2SQP0maBlv8QZunwPVfE3P"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7DpYMZzVNrjqw1geHziUEd"},"href":"https://api.spotify.com/v1/artists/7DpYMZzVNrjqw1geHziUEd","id":"7DpYMZzVNrjqw1geHziUEd","name":"KA","type":"artist","uri":"spotify:artist:7DpYMZzVNrjqw1geHziUEd"}],"disc_number":1,"duration_ms":223371,"explicit":true,"external_ids":{"isrc":"NLG662200487"},"external_urls":{"spotify":"https://open.spotify.com/track/7kcUTqYHWZAT99xEyHk6Ue"},"href":"https://api.spotify.com/v1/tracks/7kcUTqYHWZAT99xEyHk6Ue","id":"7kcUTqYHWZAT99xEyHk6Ue","is_local":false,"is_playable":true,"name":"Denker & Doener","track_number":5,"type":"track","uri":"spotify:track:7kcUTqYHWZAT99xEyHk6Ue"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"external_urls":{"spotify":"https://open.spotify.com/album/2yBMNZ82f4NvSJd5p9FW6Y"},"href":"https://api.spotify.com/v1/albums/2yBMNZ82f4NvSJd5p9FW6Y","id":"2yBMNZ82f4NvSJd5p9FW6Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f4fa2efffe3c0c31c2039acf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f4fa2efffe3c0c31c2039acf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f4fa2efffe3c0c31c2039acf"}],"is_playable":true,"name":"Mayo, No Fries!","release_date":"2020-03-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2yBMNZ82f4NvSJd5p9FW6Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41X1TR6hrK8Q2ZCpp2EqCz"},"href":"https://api.spotify.com/v1/artists/41X1TR6hrK8Q2ZCpp2EqCz","id":"41X1TR6hrK8Q2ZCpp2EqCz","name":"bbno$","type":"artist","uri":"spotify:artist:41X1TR6hrK8Q2ZCpp2EqCz"}],"disc_number":1,"duration_ms":166044,"explicit":true,"external_ids":{"isrc":"QZFZ62092067"},"external_urls":{"spotify":"https://open.spotify.com/track/1NXUEzNNKGfHrJK6DokdhX"},"href":"https://api.spotify.com/v1/tracks/1NXUEzNNKGfHrJK6DokdhX","id":"1NXUEzNNKGfHrJK6DokdhX","is_local":false,"is_playable":true,"name":"Mayo, No Fries!","track_number":1,"type":"track","uri":"spotify:track:1NXUEzNNKGfHrJK6DokdhX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3t5yBt6SYOtJhmMOeoBGRr"},"href":"https://api.spotify.com/v1/artists/3t5yBt6SYOtJhmMOeoBGRr","id":"3t5yBt6SYOtJhmMOeoBGRr","name":"M1TCH","type":"artist","uri":"spotify:artist:3t5yBt6SYOtJhmMOeoBGRr"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Vhja4W0S90ZHGEFPCwiVQ"},"href":"https://api.spotify.com/v1/albums/5Vhja4W0S90ZHGEFPCwiVQ","id":"5Vhja4W0S90ZHGEFPCwiVQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27344e5eb73e34450430c0395d1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0244e5eb73e34450430c0395d1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485144e5eb73e34450430c0395d1"}],"is_playable":true,"name":"DON'T KILL ME WITH A GREAT TIME","release_date":"2025-05-29","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:5Vhja4W0S90ZHGEFPCwiVQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3t5yBt6SYOtJhmMOeoBGRr"},"href":"https://api.spotify.com/v1/artists/3t5yBt6SYOtJhmMOeoBGRr","id":"3t5yBt6SYOtJhmMOeoBGRr","name":"M1TCH","type":"artist","uri":"spotify:artist:3t5yBt6SYOtJhmMOeoBGRr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1fXPNO5NmZQsyik8ELOrET"},"href":"https://api.spotify.com/v1/artists/1fXPNO5NmZQsyik8ELOrET","id":"1fXPNO5NmZQsyik8ELOrET","name":"Paleo Q","type":"artist","uri":"spotify:artist:1fXPNO5NmZQsyik8ELOrET"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4vQOtgq6k3mQoQf0MbCzzh"},"href":"https://api.spotify.com/v1/artists/4vQOtgq6k3mQoQf0MbCzzh","id":"4vQOtgq6k3mQoQf0MbCzzh","name":"Dragan","type":"artist","uri":"spotify:artist:4vQOtgq6k3mQoQf0MbCzzh"}],"disc_number":1,"duration_ms":187224,"explicit":true,"external_ids":{"isrc":"QZRP42506984"},"external_urls":{"spotify":"https://open.spotify.com/track/2jNzqfuDMtg3jDF9upf7vi"},"href":"https://api.spotify.com/v1/tracks/2jNzqfuDMtg3jDF9upf7vi","id":"2jNzqfuDMtg3jDF9upf7vi","is_local":false,"is_playable":true,"name":"#SQUADSHIT","track_number":2,"type":"track","uri":"spotify:track:2jNzqfuDMtg3jDF9upf7vi"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1TbGFwZWxvemUlMjBOYWNodGVuJTIwQnJvZWRlcmxpZWZkZSZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvc2VhcmNoP29mZnNldD0xMCZsaW1pdD0xMCZxdWVyeT1TbGFwZWxvemUlMjBOYWNodGVuJTIwQnJvZWRlcmxpZWZkZSZ0eXBlPXRyYWNrIiwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjE1LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yMzk1MVBnOVBpTEI4VXphM2sxMmc2IiwiaWQiOiIyMzk1MVBnOVBpTEI4VXphM2sxMmc2IiwibmFtZSI6IlRoZSBPcHBvc2l0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjM5NTFQZzlQaUxCOFV6YTNrMTJnNiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRHdmoxNFlrekFOVDR4UUVtM3NlaDAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80R3ZqMTRZa3pBTlQ0eFFFbTNzZWgwIiwiaWQiOiI0R3ZqMTRZa3pBTlQ0eFFFbTNzZWgwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzhhODg4OTdlYmUzNWE1N2E4MzhjYTgzMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4YTg4ODk3ZWJlMzVhNTdhODM4Y2E4MzEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MThhODg4OTdlYmUzNWE1N2E4MzhjYTgzMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbGFwZWxvemUgTmFjaHRlbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTItMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRHdmoxNFlrekFOVDR4UUVtM3NlaDAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yMzk1MVBnOVBpTEI4VXphM2sxMmc2Ig==", + "fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiIsImlkIjoiMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiIsIm5hbWUiOiJUaGUgT3Bwb3NpdGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjIzOTUxUGc5UGlMQjhVemEzazEyZzYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI5MTYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYxMjAwMzIzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82NTJoV1BkT1VJa0t2M2E0SEpEekJ2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNjUyaFdQZE9VSWtLdjNhNEhKRHpCdiIsImlkIjoiNjUyaFdQZE9VSWtLdjNhNEhKRHpCdiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbGFwZWxvemUgTmFjaHRlbiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2NTJoV1BkT1VJa0t2M2E0SEpEekJ2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzIzOTUxUGc5UGlMQjhVemEzazEyZzYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiIsImlkIjoiMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiIsIm5hbWUiOiJUaGUgT3Bwb3NpdGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjIzOTUxUGc5UGlMQjhVemEzazEyZzYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xSEZvejFBQ2ZRdVR3aFY5eHdSQWdMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUhGb3oxQUNmUXVUd2hWOXh3UkFnTCIsImlkIjoiMUhGb3oxQUNmUXVUd2hWOXh3UkFnTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2NDNiNTczOWYxN2FkOGU2MzhkZGU5ZTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNjQzYjU3MzlmMTdhZDhlNjM4ZGRlOWU3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2NDNiNQ==", + "NzM5ZjE3YWQ4ZTYzOGRkZTllNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbGFwZWxvemUgTmFjaHRlbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxSEZvejFBQ2ZRdVR3aFY5eHdSQWdMIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yMzk1MVBnOVBpTEI4VXphM2sxMmc2IiwiaWQiOiIyMzk1MVBnOVBpTEI4VXphM2sxMmc2IiwibmFtZSI6IlRoZSBPcHBvc2l0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjM5NTFQZzlQaUxCOFV6YTNrMTJnNiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTIyMjMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjEyMDAzMjMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNJcDlwYVc1S1ozeHkxbDF0cG9yNjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zSXA5cGFXNUtaM3h5MWwxdHBvcjYzIiwiaWQiOiIzSXA5cGFXNUtaM3h5MWwxdHBvcjYzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNsYXBlbG96ZSBOYWNodGVuIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNJcDlwYVc1S1ozeHkxbDF0cG9yNjMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGtzd21lMUtsMk5YUkNKMzI2ZjE0biJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80a3N3bWUxS2wyTlhSQ0ozMjZmMTRuIiwiaWQiOiI0a3N3bWUxS2wyTlhSQ0ozMjZmMTRuIiwibmFtZSI6IldJRVMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGtzd21lMUtsMk5YUkNKMzI2ZjE0biJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBuT0RaRk5peFpUcFJiaURoN3pPblgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wbk9EWkZOaXhaVHBSYmlEaDd6T25YIiwiaWQiOiIwbk9EWkZOaXhaVHBSYmlEaA==", + "N3pPblgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNjM2Y2UxZTkzNmZjMDk3OGM5MmVjYWM4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjYzNmNlMWU5MzZmYzA5NzhjOTJlY2FjOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjM2Y2UxZTkzNmZjMDk3OGM5MmVjYWM4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBJcyBFZW4gV0lFUyIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMTEtMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowbk9EWkZOaXhaVHBSYmlEaDd6T25YIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGtzd21lMUtsMk5YUkNKMzI2ZjE0biJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80a3N3bWUxS2wyTlhSQ0ozMjZmMTRuIiwiaWQiOiI0a3N3bWUxS2wyTlhSQ0ozMjZmMTRuIiwibmFtZSI6IldJRVMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGtzd21lMUtsMk5YUkNKMzI2ZjE0biJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODYwOTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFNCNzE5MDAxNjAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzI2TFIxRHlBYUxSR1hqcTBJaVZ6NGIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yNkxSMUR5QWFMUkdYanEwSWlWejRiIiwiaWQiOiIyNkxSMUR5QWFMUkdYanEwSWlWejRiIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvbXMgSXMgSGV0IFRlIExhYXQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MjZMUjFEeUFhTFJHWGpxMElpVno0YiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83aXNTS3prTkhlM1RzbWh0MmFyNkFpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdpc1NLemtOSGUzVHNtaHQyYXI2QQ==", + "aSIsImlkIjoiN2lzU0t6a05IZTNUc21odDJhcjZBaSIsIm5hbWUiOiJUb29udGplIExhZ2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojdpc1NLemtOSGUzVHNtaHQyYXI2QWkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81bUFvc1NvZ2dIUjBHNW1OWFlvMUNpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNW1Bb3NTb2dnSFIwRzVtTlhZbzFDaSIsImlkIjoiNW1Bb3NTb2dnSFIwRzVtTlhZbzFDaSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwNjA1YjI3ZmZhMGI1ZDVhN2U5YWM3YWUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDYwNWIyN2ZmYTBiNWQ1YTdlOWFjN2FlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwNjA1YjI3ZmZhMGI1ZDVhN2U5YWM3YWUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3RpZWtlbSBEYW5zZW4iLCJyZWxlYXNlX2RhdGUiOiIxOTgzLTA5LTE2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NW1Bb3NTb2dnSFIwRzVtTlhZbzFDaSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzdpc1NLemtOSGUzVHNtaHQyYXI2QWkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2lzU0t6a05IZTNUc21odDJhcjZBaSIsImlkIjoiN2lzU0t6a05IZTNUc21odDJhcjZBaSIsIm5hbWUiOiJUb29udGplIExhZ2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojdpc1NLemtOSGUzVHNtaHQyYXI2QWkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjgwNzA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxBMzQ5MzAwMjgyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82Q0dBUUdleFBIUWE3b3NMckRrMjNSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNkNHQVFHZXhQSFFhN29zTHJEazIzUiIsImlkIjoiNkNHQVFHZXhQSFFhN29zTHJEazIzUiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydQ==", + "ZSwibmFtZSI6IlpvdmVlbCBUZSBEb2VuIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZDR0FRR2V4UEhRYTdvc0xyRGsyM1IifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnM1dWJBcDY1d1hvVFplZkUwMVJOUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82czV1YkFwNjV3WG9UWmVmRTAxUk5SIiwiaWQiOiI2czV1YkFwNjV3WG9UWmVmRTAxUk5SIiwibmFtZSI6Ikpvb3N0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZzNXViQXA2NXdYb1RaZWZFMDFSTlIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xekZRVFBvYWY0WHVhM0NqdjRyUkdtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMXpGUVRQb2FmNFh1YTNDanY0clJHbSIsImlkIjoiMXpGUVRQb2FmNFh1YTNDanY0clJHbSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwMTM4NDI3NjA5NWU1ODkyY2YzNWRkM2MifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDEzODQyNzYwOTVlNTg5MmNmMzVkZDNjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwMTM4NDI3NjA5NWU1ODkyY2YzNWRkM2MifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSm9vc3QgS2xlaW4gNyIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDQtMjQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjF6RlFUUG9hZjRYdWEzQ2p2NHJSR20ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82czV1YkFwNjV3WG9UWmVmRTAxUk5SIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZzNXViQXA2NXdYb1RaZWZFMDFSTlIiLCJpZCI6IjZzNXViQXA2NXdYb1RaZWZFMDFSTlIiLCJuYW1lIjoiSm9vc3QiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnM1dWJBcDY1d1hvVFplZkUwMVJOUiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaA==", + "dHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzQxWDFUUjZocks4UTJaQ3BwMkVxQ3oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNDFYMVRSNmhySzhRMlpDcHAyRXFDeiIsImlkIjoiNDFYMVRSNmhySzhRMlpDcHAyRXFDeiIsIm5hbWUiOiJiYm5vJCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0MVgxVFI2aHJLOFEyWkNwcDJFcUN6In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2NjA0NCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUVpGWjYyMDkyMDY3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83M3plaGdsQ2Y1MHNJMGdndlVieGNoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNzN6ZWhnbENmNTBzSTBnZ3ZVYnhjaCIsImlkIjoiNzN6ZWhnbENmNTBzSTBnZ3ZVYnhjaCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNYXlvLCBObyBGcmllcyEiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NzN6ZWhnbENmNTBzSTBnZ3ZVYnhjaCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81UDY1YnhUUDRCcTRmNkVCaHN1U01VIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNVA2NWJ4VFA0QnE0ZjZFQmhzdVNNVSIsImlkIjoiNVA2NWJ4VFA0QnE0ZjZFQmhzdVNNVSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiMTE5MTA3YWZmNTI5N2UyYTQ3ZjUwOTQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjExOTEwN2FmZjUyOTdlMmE0N2Y1MDk0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsIg==", + "dXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWIxMTkxMDdhZmY1Mjk3ZTJhNDdmNTA5NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCZXN0IE9mIFRoZSAxMHM6IFBhcnR5IEhpdHMiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTA0LTA2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVA2NWJ4VFA0QnE0ZjZFQmhzdVNNVSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzIzOTUxUGc5UGlMQjhVemEzazEyZzYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiIsImlkIjoiMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiIsIm5hbWUiOiJUaGUgT3Bwb3NpdGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjIzOTUxUGc5UGlMQjhVemEzazEyZzYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI5MTYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYxMjAwMzIzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yNUpORFdVdlplWnB2ZlhmYXJNcHpKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMjVKTkRXVXZaZVpwdmZYZmFyTXB6SiIsImlkIjoiMjVKTkRXVXZaZVpwdmZYZmFyTXB6SiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbGFwZWxvemUgTmFjaHRlbiIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyNUpORFdVdlplWnB2ZlhmYXJNcHpKIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTbTRyR0tXQm5PUWhkcUR5NEpKaDAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNtNHJHS1dCbk9RaGRxRHk0SkpoMCIsImlkIjoiMlNtNHJHS1dCbk9RaGRxRHk0SkpoMCIsIm5hbWUiOiJad2FuZ2VyZSBHdXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNtNHJHS1dCbk9RaGRxRHk0SkpoMCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzV5aFM1andmdkR4SUtxTWJjNVYwdkoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLg==", + "c3BvdGlmeS5jb20vdjEvYWxidW1zLzV5aFM1andmdkR4SUtxTWJjNVYwdkoiLCJpZCI6IjV5aFM1andmdkR4SUtxTWJjNVYwdkoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDIxMmQ4Yjg4ZDJmYzg3NzRiZGU4NjE3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjAyMTJkOGI4OGQyZmM4Nzc0YmRlODYxNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDIxMmQ4Yjg4ZDJmYzg3NzRiZGU4NjE3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJSVVRBQUwiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTExLTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NXloUzVqd2Z2RHhJS3FNYmM1VjB2SiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJTbTRyR0tXQm5PUWhkcUR5NEpKaDAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlNtNHJHS1dCbk9RaGRxRHk0SkpoMCIsImlkIjoiMlNtNHJHS1dCbk9RaGRxRHk0SkpoMCIsIm5hbWUiOiJad2FuZ2VyZSBHdXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNtNHJHS1dCbk9RaGRxRHk0SkpoMCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wRG5iT2F0Qm5QN1VEa2VpUUFDZ3hkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBEbmJPYXRCblA3VURrZWlRQUNneGQiLCJpZCI6IjBEbmJPYXRCblA3VURrZWlRQUNneGQiLCJuYW1lIjoiU3RpY2tzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBEbmJPYXRCblA3VURrZWlRQUNneGQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjM2NjIyLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJCRUVKMTE5MDAwNDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzA2d2NjWXFuTDJpc0djRTF0bUIybjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wNndjY1lxbkwyaXNHY0UxdG1CMm4wIiwiaWQiOiIwNndjY1lxbkwyaXNHY0UxdG1CMm4wIiwiaXNfbA==", + "b2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRUxMRUJPR0VOV0VSSyIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowNndjY1lxbkwyaXNHY0UxdG1CMm4wIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdEcFlNWnpWTnJqcXcxZ2VIemlVRWQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0RwWU1aelZOcmpxdzFnZUh6aVVFZCIsImlkIjoiN0RwWU1aelZOcmpxdzFnZUh6aVVFZCIsIm5hbWUiOiJLQSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3RHBZTVp6Vk5yanF3MWdlSHppVUVkIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlNRUDBtYUJsdjhRWnVud1BWZkUzUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJTUVAwbWFCbHY4UVp1bndQVmZFM1AiLCJpZCI6IjJTUVAwbWFCbHY4UVp1bndQVmZFM1AiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDUwYWI3YWI3NjlhZWRlNjcxZTQyYWEyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQ1MGFiN2FiNzY5YWVkZTY3MWU0MmFhMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDUwYWI3YWI3NjlhZWRlNjcxZTQyYWEyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlY2tsZXp6IiwicmVsZWFzZV9kYXRlIjoiMjAyMi0xMS0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJTUVAwbWFCbHY4UVp1bndQVmZFM1AifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83RHBZTVp6Vk5yanF3MWdlSHppVUVkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdEcFlNWnpWTnJqcXcxZ2VIemlVRWQiLCJpZCI6IjdEcFlNWnpWTnJqcXcxZ2VIemlVRWQiLCJuYW1lIjoiS0EiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0RwWU1aelZOcmpxdzFnZUh6aVVFZCJ9XSwiZGlzY19udW1iZQ==", + "ciI6MSwiZHVyYXRpb25fbXMiOjIyMzM3MSwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyMjAwNDg3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83a2NVVHFZSFdaQVQ5OXhFeUhrNlVlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2tjVVRxWUhXWkFUOTl4RXlIazZVZSIsImlkIjoiN2tjVVRxWUhXWkFUOTl4RXlIazZVZSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZW5rZXIgJiBEb2VuZXIiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2tjVVRxWUhXWkFUOTl4RXlIazZVZSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnM1dWJBcDY1d1hvVFplZkUwMVJOUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82czV1YkFwNjV3WG9UWmVmRTAxUk5SIiwiaWQiOiI2czV1YkFwNjV3WG9UWmVmRTAxUk5SIiwibmFtZSI6Ikpvb3N0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZzNXViQXA2NXdYb1RaZWZFMDFSTlIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yeUJNTlo4MmY0TnZTSmQ1cDlGVzZZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMnlCTU5aODJmNE52U0pkNXA5Rlc2WSIsImlkIjoiMnlCTU5aODJmNE52U0pkNXA5Rlc2WSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmNGZhMmVmZmZlM2MwYzMxYzIwMzlhY2YifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjRmYTJlZmZmZTNjMGMzMWMyMDM5YWNmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmNGZhMmVmZmZlM2MwYzMxYzIwMzlhY2YifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWF5bywgTm8gRnJpZXMhIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wMy0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MnlCTU5aODJmNE52U0pkNXA5Rlc2WSJ9LCJhcg==", + "dGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnM1dWJBcDY1d1hvVFplZkUwMVJOUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82czV1YkFwNjV3WG9UWmVmRTAxUk5SIiwiaWQiOiI2czV1YkFwNjV3WG9UWmVmRTAxUk5SIiwibmFtZSI6Ikpvb3N0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZzNXViQXA2NXdYb1RaZWZFMDFSTlIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDFYMVRSNmhySzhRMlpDcHAyRXFDeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80MVgxVFI2aHJLOFEyWkNwcDJFcUN6IiwiaWQiOiI0MVgxVFI2aHJLOFEyWkNwcDJFcUN6IiwibmFtZSI6ImJibm8kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjQxWDFUUjZocks4UTJaQ3BwMkVxQ3oifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTY2MDQ0LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWkZaNjIwOTIwNjcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFOWFVFek5OS0dmSHJKSzZEb2tkaFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xTlhVRXpOTktHZkhySks2RG9rZGhYIiwiaWQiOiIxTlhVRXpOTktHZkhySks2RG9rZGhYIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1heW8sIE5vIEZyaWVzISIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxTlhVRXpOTktHZkhySks2RG9rZGhYIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN0NXlCdDZTWU90SmhtTU9lb0JHUnIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3Q1eUJ0NlNZT3RKaG1NT2VvQkdSciIsImlkIjoiM3Q1eUJ0NlNZT3RKaG1NT2VvQkdSciIsIm5hbWUiOiJNMVRDSCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdDV5QnQ2U1lPdEpobU1PZW9CR1JyIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVZoamE0VzBTOTBaSEdFRlBDd2lWUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVWaGphNA==", + "VzBTOTBaSEdFRlBDd2lWUSIsImlkIjoiNVZoamE0VzBTOTBaSEdFRlBDd2lWUSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0NGU1ZWI3M2UzNDQ1MDQzMGMwMzk1ZDEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDRlNWViNzNlMzQ0NTA0MzBjMDM5NWQxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0NGU1ZWI3M2UzNDQ1MDQzMGMwMzk1ZDEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRE9OJ1QgS0lMTCBNRSBXSVRIIEEgR1JFQVQgVElNRSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDUtMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVWaGphNFcwUzkwWkhHRUZQQ3dpVlEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdDV5QnQ2U1lPdEpobU1PZW9CR1JyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN0NXlCdDZTWU90SmhtTU9lb0JHUnIiLCJpZCI6IjN0NXlCdDZTWU90SmhtTU9lb0JHUnIiLCJuYW1lIjoiTTFUQ0giLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3Q1eUJ0NlNZT3RKaG1NT2VvQkdSciJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xZlhQTk81Tm1aUXN5aWs4RUxPckVUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFmWFBOTzVObVpRc3lpazhFTE9yRVQiLCJpZCI6IjFmWFBOTzVObVpRc3lpazhFTE9yRVQiLCJuYW1lIjoiUGFsZW8gUSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxZlhQTk81Tm1aUXN5aWs4RUxPckVUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzR2UU90Z3E2azNtUW9RZjBNYkN6emgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHZRT3RncTZrM21Rb1FmME1iQ3p6aCIsImlkIjoiNHZRT3RncTZrM21Rb1FmME1iQ3p6aCIsIm5hbWUiOiJEcmFnYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHZRT3RncTZrM21Rb1FmME1iQ3p6aCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uXw==", + "bXMiOjE4NzIyNCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUVpSUDQyNTA2OTg0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yak56cWZ1RE10ZzNqREY5dXBmN3ZpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMmpOenFmdURNdGczakRGOXVwZjd2aSIsImlkIjoiMmpOenFmdURNdGczakRGOXVwZjd2aSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiIjU1FVQURTSElUIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJqTnpxZnVETXRnM2pERjl1cGY3dmkifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Slapeloze+Nachten+Broederliefde&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZhYXJ3ZWwlMjIlMjBhcnRpc3QlM0ElMjJLcmlzJTIwS3Jvc3MlMjBBbXN0ZXJkYW0lMkMlMjBFbW1hJTIwSGVlc3RlcnMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZhYXJ3ZWwlMjIlMjBhcnRpc3QlM0ElMjJLcmlzJTIwS3Jvc3MlMjBBbXN0ZXJkYW0lMkMlMjBFbW1hJTIwSGVlc3RlcnMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Vaarwel%22+artist%3A%22Kris+Kross+Amsterdam%2C+Emma+Heesters%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJsaWp2ZW4lMjBTbGFwZW4lMjIlMjBhcnRpc3QlM0ElMjJMaWwlMjBLbGVpbmUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJsaWp2ZW4lMjBTbGFwZW4lMjIlMjBhcnRpc3QlM0ElMjJMaWwlMjBLbGVpbmUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Blijven+Slapen%22+artist%3A%22Lil+Kleine%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Als%20Het%20Avond%20Is%20Ronnie%20Flex&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Als%20Het%20Avond%20Is%20Ronnie%20Flex&type=track","offset":0,"previous":null,"total":15,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GN0wx6gsqLgDoOSPzv2vJ"},"href":"https://api.spotify.com/v1/albums/5GN0wx6gsqLgDoOSPzv2vJ","id":"5GN0wx6gsqLgDoOSPzv2vJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273606f7c82fdf36ba46221bba6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02606f7c82fdf36ba46221bba6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851606f7c82fdf36ba46221bba6"}],"is_playable":true,"name":"Gedeeld Door Ons","release_date":"2019-09-27","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:5GN0wx6gsqLgDoOSPzv2vJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"disc_number":1,"duration_ms":205714,"explicit":false,"external_ids":{"isrc":"NL1CK1800001"},"external_urls":{"spotify":"https://open.spotify.com/track/1MWpdDDf3Yk0w6o4oviMFY"},"href":"https://api.spotify.com/v1/tracks/1MWpdDDf3Yk0w6o4oviMFY","id":"1MWpdDDf3Yk0w6o4oviMFY","is_local":false,"is_playable":true,"name":"Als Het Avond Is","track_number":6,"type":"track","uri":"spotify:track:1MWpdDDf3Yk0w6o4oviMFY"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"external_urls":{"spotify":"https://open.spotify.com/album/5LlrRTvslzI8fo2WsRcRkc"},"href":"https://api.spotify.com/v1/albums/5LlrRTvslzI8fo2WsRcRkc","id":"5LlrRTvslzI8fo2WsRcRkc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eee43624bf8addf4a50f2e7f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eee43624bf8addf4a50f2e7f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eee43624bf8addf4a50f2e7f"}],"is_playable":true,"name":"Als Het Avond Is","release_date":"2018-11-02","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:5LlrRTvslzI8fo2WsRcRkc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"disc_number":1,"duration_ms":205714,"explicit":false,"external_ids":{"isrc":"NL1CK1800001"},"external_urls":{"spotify":"https://open.spotify.com/track/3ciQQMSy1lKDqJbwU9l1LT"},"href":"https://api.spotify.com/v1/tracks/3ciQQMSy1lKDqJbwU9l1LT","id":"3ciQQMSy1lKDqJbwU9l1LT","is_local":false,"is_playable":true,"name":"Als Het Avond Is","track_number":1,"type":"track","uri":"spotify:track:3ciQQMSy1lKDqJbwU9l1LT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/11YiKYULtpVKbNGdpKjaj0"},"href":"https://api.spotify.com/v1/albums/11YiKYULtpVKbNGdpKjaj0","id":"11YiKYULtpVKbNGdpKjaj0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273566d303809ace090f10101c9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02566d303809ace090f10101c9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851566d303809ace090f10101c9"}],"is_playable":true,"name":"New Wave","release_date":"2015-04-07","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:11YiKYULtpVKbNGdpKjaj0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"disc_number":1,"duration_ms":145978,"explicit":true,"external_ids":{"isrc":"NLG661500224"},"external_urls":{"spotify":"https://open.spotify.com/track/0ya4rRxJIIF1B0bLpbJrNP"},"href":"https://api.spotify.com/v1/tracks/0ya4rRxJIIF1B0bLpbJrNP","id":"0ya4rRxJIIF1B0bLpbJrNP","is_local":false,"is_playable":true,"name":"Drank & Drugs","track_number":11,"type":"track","uri":"spotify:track:0ya4rRxJIIF1B0bLpbJrNP"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YznhKZUZFVr418x7OUi3z"},"href":"https://api.spotify.com/v1/artists/6YznhKZUZFVr418x7OUi3z","id":"6YznhKZUZFVr418x7OUi3z","name":"Roxy Dekker","type":"artist","uri":"spotify:artist:6YznhKZUZFVr418x7OUi3z"}],"external_urls":{"spotify":"https://open.spotify.com/album/0mKjLg4PFqhXdBMKCoGQm0"},"href":"https://api.spotify.com/v1/albums/0mKjLg4PFqhXdBMKCoGQm0","id":"0mKjLg4PFqhXdBMKCoGQm0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c5aa46b4711e3bcc526cd9f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c5aa46b4711e3bcc526cd9f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c5aa46b4711e3bcc526cd9f5"}],"is_playable":true,"name":"SUPERSTAR","release_date":"2026-06-26","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0mKjLg4PFqhXdBMKCoGQm0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YznhKZUZFVr418x7OUi3z"},"href":"https://api.spotify.com/v1/artists/6YznhKZUZFVr418x7OUi3z","id":"6YznhKZUZFVr418x7OUi3z","name":"Roxy Dekker","type":"artist","uri":"spotify:artist:6YznhKZUZFVr418x7OUi3z"}],"disc_number":1,"duration_ms":149589,"explicit":true,"external_ids":{"isrc":"NLA802600090"},"external_urls":{"spotify":"https://open.spotify.com/track/0isizAo7CkD7DhZm3C1DaY"},"href":"https://api.spotify.com/v1/tracks/0isizAo7CkD7DhZm3C1DaY","id":"0isizAo7CkD7DhZm3C1DaY","is_local":false,"is_playable":true,"name":"SUPERSTAR","track_number":1,"type":"track","uri":"spotify:track:0isizAo7CkD7DhZm3C1DaY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"external_urls":{"spotify":"https://open.spotify.com/album/4yBgb4hMBVvVUzheMlAewP"},"href":"https://api.spotify.com/v1/albums/4yBgb4hMBVvVUzheMlAewP","id":"4yBgb4hMBVvVUzheMlAewP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732fa5fa0eb3eef07298579c42"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022fa5fa0eb3eef07298579c42"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512fa5fa0eb3eef07298579c42"}],"is_playable":true,"name":"Gedeeld Door Ons","release_date":"2019-09-27","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4yBgb4hMBVvVUzheMlAewP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"disc_number":1,"duration_ms":205714,"explicit":false,"external_ids":{"isrc":"NL1CK1800001"},"external_urls":{"spotify":"https://open.spotify.com/track/1v3TlOzwX7TLDyNDnYL0fT"},"href":"https://api.spotify.com/v1/tracks/1v3TlOzwX7TLDyNDnYL0fT","id":"1v3TlOzwX7TLDyNDnYL0fT","is_local":false,"is_playable":true,"name":"Als Het Avond Is","track_number":7,"type":"track","uri":"spotify:track:1v3TlOzwX7TLDyNDnYL0fT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4NEThNYJ3WyNcJWcmpjq88"},"href":"https://api.spotify.com/v1/artists/4NEThNYJ3WyNcJWcmpjq88","id":"4NEThNYJ3WyNcJWcmpjq88","name":"Ir Sais","type":"artist","uri":"spotify:artist:4NEThNYJ3WyNcJWcmpjq88"}],"external_urls":{"spotify":"https://open.spotify.com/album/4L4n4M1pfCbAjp1p2KLGS2"},"href":"https://api.spotify.com/v1/albums/4L4n4M1pfCbAjp1p2KLGS2","id":"4L4n4M1pfCbAjp1p2KLGS2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27395bc15a6f313664d1fe49f5d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0295bc15a6f313664d1fe49f5d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485195bc15a6f313664d1fe49f5d"}],"is_playable":true,"name":"Caribbean Girl","release_date":"2026-07-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4L4n4M1pfCbAjp1p2KLGS2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4NEThNYJ3WyNcJWcmpjq88"},"href":"https://api.spotify.com/v1/artists/4NEThNYJ3WyNcJWcmpjq88","id":"4NEThNYJ3WyNcJWcmpjq88","name":"Ir Sais","type":"artist","uri":"spotify:artist:4NEThNYJ3WyNcJWcmpjq88"}],"disc_number":1,"duration_ms":158613,"explicit":false,"external_ids":{"isrc":"NL5MB2600004"},"external_urls":{"spotify":"https://open.spotify.com/track/4VskUdh8Hn1STK1OpqEUKo"},"href":"https://api.spotify.com/v1/tracks/4VskUdh8Hn1STK1OpqEUKo","id":"4VskUdh8Hn1STK1OpqEUKo","is_local":false,"is_playable":true,"name":"Caribbean Girl","track_number":1,"type":"track","uri":"spotify:track:4VskUdh8Hn1STK1OpqEUKo"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6VT2Npi6yGDqn3H07qI1DY"},"href":"https://api.spotify.com/v1/artists/6VT2Npi6yGDqn3H07qI1DY","id":"6VT2Npi6yGDqn3H07qI1DY","name":"ADF","type":"artist","uri":"spotify:artist:6VT2Npi6yGDqn3H07qI1DY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qeFPM2PZUCzcpkY4e4RC8"},"href":"https://api.spotify.com/v1/artists/5qeFPM2PZUCzcpkY4e4RC8","id":"5qeFPM2PZUCzcpkY4e4RC8","name":"ADF Samski","type":"artist","uri":"spotify:artist:5qeFPM2PZUCzcpkY4e4RC8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qbldCiZAkn2KfwyUfithX"},"href":"https://api.spotify.com/v1/artists/5qbldCiZAkn2KfwyUfithX","id":"5qbldCiZAkn2KfwyUfithX","name":"Carel","type":"artist","uri":"spotify:artist:5qbldCiZAkn2KfwyUfithX"}],"external_urls":{"spotify":"https://open.spotify.com/album/3TuIkrTo6MZGWQLkchWExB"},"href":"https://api.spotify.com/v1/albums/3TuIkrTo6MZGWQLkchWExB","id":"3TuIkrTo6MZGWQLkchWExB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273789394176534477c50fdfebb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02789394176534477c50fdfebb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851789394176534477c50fdfebb"}],"is_playable":true,"name":"AL ME LADIES (feat. Scarface)","release_date":"2026-07-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3TuIkrTo6MZGWQLkchWExB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6VT2Npi6yGDqn3H07qI1DY"},"href":"https://api.spotify.com/v1/artists/6VT2Npi6yGDqn3H07qI1DY","id":"6VT2Npi6yGDqn3H07qI1DY","name":"ADF","type":"artist","uri":"spotify:artist:6VT2Npi6yGDqn3H07qI1DY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qeFPM2PZUCzcpkY4e4RC8"},"href":"https://api.spotify.com/v1/artists/5qeFPM2PZUCzcpkY4e4RC8","id":"5qeFPM2PZUCzcpkY4e4RC8","name":"ADF Samski","type":"artist","uri":"spotify:artist:5qeFPM2PZUCzcpkY4e4RC8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5qbldCiZAkn2KfwyUfithX"},"href":"https://api.spotify.com/v1/artists/5qbldCiZAkn2KfwyUfithX","id":"5qbldCiZAkn2KfwyUfithX","name":"Carel","type":"artist","uri":"spotify:artist:5qbldCiZAkn2KfwyUfithX"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0AKfGRIDWDiLB8EHORfP8J"},"href":"https://api.spotify.com/v1/artists/0AKfGRIDWDiLB8EHORfP8J","id":"0AKfGRIDWDiLB8EHORfP8J","name":"Scarface","type":"artist","uri":"spotify:artist:0AKfGRIDWDiLB8EHORfP8J"}],"disc_number":1,"duration_ms":127493,"explicit":true,"external_ids":{"isrc":"NL5HJ2600103"},"external_urls":{"spotify":"https://open.spotify.com/track/5xatt9NJdj7mAYE5ZxrpPo"},"href":"https://api.spotify.com/v1/tracks/5xatt9NJdj7mAYE5ZxrpPo","id":"5xatt9NJdj7mAYE5ZxrpPo","is_local":false,"is_playable":true,"name":"AL ME LADIES (feat. Scarface)","track_number":1,"type":"track","uri":"spotify:track:5xatt9NJdj7mAYE5ZxrpPo"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0DnbOatBnP7UDkeiQACgxd"},"href":"https://api.spotify.com/v1/artists/0DnbOatBnP7UDkeiQACgxd","id":"0DnbOatBnP7UDkeiQACgxd","name":"Sticks","type":"artist","uri":"spotify:artist:0DnbOatBnP7UDkeiQACgxd"}],"external_urls":{"spotify":"https://open.spotify.com/album/66PEAXKKSWoXEZynQBvsTo"},"href":"https://api.spotify.com/v1/albums/66PEAXKKSWoXEZynQBvsTo","id":"66PEAXKKSWoXEZynQBvsTo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273048a6cbce69d2145be322e6a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02048a6cbce69d2145be322e6a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851048a6cbce69d2145be322e6a"}],"is_playable":true,"name":"En Door","release_date":"2023-10-19","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:66PEAXKKSWoXEZynQBvsTo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0DnbOatBnP7UDkeiQACgxd"},"href":"https://api.spotify.com/v1/artists/0DnbOatBnP7UDkeiQACgxd","id":"0DnbOatBnP7UDkeiQACgxd","name":"Sticks","type":"artist","uri":"spotify:artist:0DnbOatBnP7UDkeiQACgxd"}],"disc_number":1,"duration_ms":216000,"explicit":true,"external_ids":{"isrc":"NLG662300598"},"external_urls":{"spotify":"https://open.spotify.com/track/7F69lmAn9t49WkPPu7bUE3"},"href":"https://api.spotify.com/v1/tracks/7F69lmAn9t49WkPPu7bUE3","id":"7F69lmAn9t49WkPPu7bUE3","is_local":false,"is_playable":true,"name":"Dit Is Leven!","track_number":11,"type":"track","uri":"spotify:track:7F69lmAn9t49WkPPu7bUE3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1EYdbYpGAuJy6uZo4sVMoM"},"href":"https://api.spotify.com/v1/artists/1EYdbYpGAuJy6uZo4sVMoM","id":"1EYdbYpGAuJy6uZo4sVMoM","name":"Idaly","type":"artist","uri":"spotify:artist:1EYdbYpGAuJy6uZo4sVMoM"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m1LYS5NQonxjOcQFPQOb5"},"href":"https://api.spotify.com/v1/artists/6m1LYS5NQonxjOcQFPQOb5","id":"6m1LYS5NQonxjOcQFPQOb5","name":"Frenna","type":"artist","uri":"spotify:artist:6m1LYS5NQonxjOcQFPQOb5"}],"external_urls":{"spotify":"https://open.spotify.com/album/5XIEGdAU9LWEL8Nqjos6bj"},"href":"https://api.spotify.com/v1/albums/5XIEGdAU9LWEL8Nqjos6bj","id":"5XIEGdAU9LWEL8Nqjos6bj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c13ca00e1f5f89f783963a0d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c13ca00e1f5f89f783963a0d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c13ca00e1f5f89f783963a0d"}],"is_playable":true,"name":"POPULAIR","release_date":"2026-05-28","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5XIEGdAU9LWEL8Nqjos6bj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1EYdbYpGAuJy6uZo4sVMoM"},"href":"https://api.spotify.com/v1/artists/1EYdbYpGAuJy6uZo4sVMoM","id":"1EYdbYpGAuJy6uZo4sVMoM","name":"Idaly","type":"artist","uri":"spotify:artist:1EYdbYpGAuJy6uZo4sVMoM"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m1LYS5NQonxjOcQFPQOb5"},"href":"https://api.spotify.com/v1/artists/6m1LYS5NQonxjOcQFPQOb5","id":"6m1LYS5NQonxjOcQFPQOb5","name":"Frenna","type":"artist","uri":"spotify:artist:6m1LYS5NQonxjOcQFPQOb5"}],"disc_number":1,"duration_ms":192786,"explicit":false,"external_ids":{"isrc":"NLG662600281"},"external_urls":{"spotify":"https://open.spotify.com/track/4y31VcNe2CESLzUZ7vQN7f"},"href":"https://api.spotify.com/v1/tracks/4y31VcNe2CESLzUZ7vQN7f","id":"4y31VcNe2CESLzUZ7vQN7f","is_local":false,"is_playable":true,"name":"POPULAIR","track_number":1,"type":"track","uri":"spotify:track:4y31VcNe2CESLzUZ7vQN7f"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1i7EPWPpiJn18wBTNfgmsY"},"href":"https://api.spotify.com/v1/artists/1i7EPWPpiJn18wBTNfgmsY","id":"1i7EPWPpiJn18wBTNfgmsY","name":"STIKSTOF","type":"artist","uri":"spotify:artist:1i7EPWPpiJn18wBTNfgmsY"}],"external_urls":{"spotify":"https://open.spotify.com/album/4M7GhXCMNlA6lyiml4bmFo"},"href":"https://api.spotify.com/v1/albums/4M7GhXCMNlA6lyiml4bmFo","id":"4M7GhXCMNlA6lyiml4bmFo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f96944a73a8213467b6ca993"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f96944a73a8213467b6ca993"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f96944a73a8213467b6ca993"}],"is_playable":true,"name":"FAMILIE BOVEN ALLES","release_date":"2021-10-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:4M7GhXCMNlA6lyiml4bmFo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1i7EPWPpiJn18wBTNfgmsY"},"href":"https://api.spotify.com/v1/artists/1i7EPWPpiJn18wBTNfgmsY","id":"1i7EPWPpiJn18wBTNfgmsY","name":"STIKSTOF","type":"artist","uri":"spotify:artist:1i7EPWPpiJn18wBTNfgmsY"}],"disc_number":1,"duration_ms":259933,"explicit":true,"external_ids":{"isrc":"BEEJ12100004"},"external_urls":{"spotify":"https://open.spotify.com/track/5Wo2brChO41tN7KTZGC9h6"},"href":"https://api.spotify.com/v1/tracks/5Wo2brChO41tN7KTZGC9h6","id":"5Wo2brChO41tN7KTZGC9h6","is_local":false,"is_playable":true,"name":"DRIEDUBBELDIK","track_number":4,"type":"track","uri":"spotify:track:5Wo2brChO41tN7KTZGC9h6"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1BbHMlMjBIZXQlMjBBdm9uZCUyMElzJTIwUm9ubmllJTIwRmxleCZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvc2VhcmNoP29mZnNldD0xMCZsaW1pdD0xMCZxdWVyeT1BbHMlMjBIZXQlMjBBdm9uZCUyMElzJTIwUm9ubmllJTIwRmxleCZ0eXBlPXRyYWNrIiwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjE1LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc3SVc1Wksxc21EUVlZS0RDUXVnWGgiLCJpZCI6Ijc3SVc1Wksxc21EUVlZS0RDUXVnWGgiLCJuYW1lIjoiU3V6YW4gJiBGcmVlayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUdOMHd4NmdzcUxnRG9PU1B6djJ2SiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVHTjB3eDZnc3FMZ0RvT1NQenYydkoi", + "LCJpZCI6IjVHTjB3eDZnc3FMZ0RvT1NQenYydkoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNjA2ZjdjODJmZGYzNmJhNDYyMjFiYmE2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjYwNmY3YzgyZmRmMzZiYTQ2MjIxYmJhNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjA2ZjdjODJmZGYzNmJhNDYyMjFiYmE2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdlZGVlbGQgRG9vciBPbnMiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA5LTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUdOMHd4NmdzcUxnRG9PU1B6djJ2SiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3SVc1Wksxc21EUVlZS0RDUXVnWGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdJVzVaSzFzbURRWVlLRENRdWdYaCIsImlkIjoiNzdJVzVaSzFzbURRWVlLRENRdWdYaCIsIm5hbWUiOiJTdXphbiAmIEZyZWVrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3SVc1Wksxc21EUVlZS0RDUXVnWGgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA1NzE0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkwxQ0sxODAwMDAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xTVdwZEREZjNZazB3Nm80b3ZpTUZZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMU1XcGRERGYzWWswdzZvNG92aU1GWSIsImlkIjoiMU1XcGRERGYzWWswdzZvNG92aU1GWSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbHMgSGV0IEF2b25kIElzIiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFNV3BkRERmM1lrMHc2bzRvdmlNRlkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3SVc1Wksxc21EUVlZS0RDUXVnWGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tLw==", + "djEvYXJ0aXN0cy83N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIiwiaWQiOiI3N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIiwibmFtZSI6IlN1emFuICYgRnJlZWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzdJVzVaSzFzbURRWVlLRENRdWdYaCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVMbHJSVHZzbHpJOGZvMldzUmNSa2MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81TGxyUlR2c2x6SThmbzJXc1JjUmtjIiwiaWQiOiI1TGxyUlR2c2x6SThmbzJXc1JjUmtjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2VlZTQzNjI0YmY4YWRkZjRhNTBmMmU3ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlZWU0MzYyNGJmOGFkZGY0YTUwZjJlN2YifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVlZTQzNjI0YmY4YWRkZjRhNTBmMmU3ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbHMgSGV0IEF2b25kIElzIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0xMS0wMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUxsclJUdnNsekk4Zm8yV3NSY1JrYyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3SVc1Wksxc21EUVlZS0RDUXVnWGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdJVzVaSzFzbURRWVlLRENRdWdYaCIsImlkIjoiNzdJVzVaSzFzbURRWVlLRENRdWdYaCIsIm5hbWUiOiJTdXphbiAmIEZyZWVrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3SVc1Wksxc21EUVlZS0RDUXVnWGgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA1NzE0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkwxQ0sxODAwMDAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zY2lRUU1TeTFsS0RxSmJ3VTlsMUxUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM2NpUVFNU3kxbEtEcUpid1U5bDFMVCIsImlkIjoiM2NpUVFNU3kxbEtEcUpid1U5bDFMVCIsIg==", + "aXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFscyBIZXQgQXZvbmQgSXMiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2NpUVFNU3kxbEtEcUpid1U5bDFMVCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xMVlpS1lVTHRwVktiTkdkcEtqYWowIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTFZaUtZVUx0cFZLYk5HZHBLamFqMCIsImlkIjoiMTFZaUtZVUx0cFZLYk5HZHBLamFqMCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1NjZkMzAzODA5YWNlMDkwZjEwMTAxYzkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTY2ZDMwMzgwOWFjZTA5MGYxMDEwMWM5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1NjZkMzAzODA5YWNlMDkwZjEwMTAxYzkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmV3IFdhdmUiLCJyZWxlYXNlX2RhdGUiOiIyMDE1LTA0LTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MTFZaUtZVUx0cFZLYk5HZHBLamFqMCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNBbFJpeWpNeXdUVk56VGNIYmY5UVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0FsUml5ak15d1RWTnpUY0hiZjlRVCIsImlkIjoiM0FsUml5ak15d1RWTnpUY0hiZjlRVCIsIm5hbWUiOiJMaWwgS2xlaW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNBbA==", + "Uml5ak15d1RWTnpUY0hiZjlRVCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJpZCI6IjVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJuYW1lIjoiUm9ubmllIEZsZXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDU5NzgsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzY2MTUwMDIyNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHlhNHJSeEpJSUYxQjBiTHBiSnJOUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzB5YTRyUnhKSUlGMUIwYkxwYkpyTlAiLCJpZCI6IjB5YTRyUnhKSUlGMUIwYkxwYkpyTlAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRHJhbmsgJiBEcnVncyIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHlhNHJSeEpJSUYxQjBiTHBiSnJOUCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNll6bmhLWlVaRlZyNDE4eDdPVWkzeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82WXpuaEtaVVpGVnI0MTh4N09VaTN6IiwiaWQiOiI2WXpuaEtaVVpGVnI0MTh4N09VaTN6IiwibmFtZSI6IlJveHkgRGVra2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZZem5oS1pVWkZWcjQxOHg3T1VpM3oifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wbUtqTGc0UEZxaFhkQk1LQ29HUW0wIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMG1LakxnNFBGcWhYZEJNS0NvR1FtMCIsImlkIjoiMG1LakxnNFBGcWhYZEJNS0NvR1FtMCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjNWFhNDZiNDcxMWUzYmNjNTI2Y2Q5ZjUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzVhYQ==", + "NDZiNDcxMWUzYmNjNTI2Y2Q5ZjUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM1YWE0NmI0NzExZTNiY2M1MjZjZDlmNSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTVVBFUlNUQVIiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA2LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowbUtqTGc0UEZxaFhkQk1LQ29HUW0wIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNll6bmhLWlVaRlZyNDE4eDdPVWkzeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82WXpuaEtaVVpGVnI0MTh4N09VaTN6IiwiaWQiOiI2WXpuaEtaVVpGVnI0MTh4N09VaTN6IiwibmFtZSI6IlJveHkgRGVra2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZZem5oS1pVWkZWcjQxOHg3T1VpM3oifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQ5NTg5LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEE4MDI2MDAwOTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBpc2l6QW83Q2tEN0RoWm0zQzFEYVkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8waXNpekFvN0NrRDdEaFptM0MxRGFZIiwiaWQiOiIwaXNpekFvN0NrRDdEaFptM0MxRGFZIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNVUEVSU1RBUiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowaXNpekFvN0NrRDdEaFptM0MxRGFZIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3SVc1Wksxc21EUVlZS0RDUXVnWGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdJVzVaSzFzbURRWVlLRENRdWdYaCIsImlkIjoiNzdJVzVaSzFzbURRWVlLRENRdWdYaCIsIm5hbWUiOiJTdXphbiAmIEZyZWVrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3SVc1Wksxc21EUVlZS0RDUXVnWGgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80eUJnYjRoTUJWdlZVemhlTWxBZXdQIn0sIg==", + "aHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80eUJnYjRoTUJWdlZVemhlTWxBZXdQIiwiaWQiOiI0eUJnYjRoTUJWdlZVemhlTWxBZXdQIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzJmYTVmYTBlYjNlZWYwNzI5ODU3OWM0MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyZmE1ZmEwZWIzZWVmMDcyOTg1NzljNDIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJmYTVmYTBlYjNlZWYwNzI5ODU3OWM0MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHZWRlZWxkIERvb3IgT25zIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wOS0yNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjR5QmdiNGhNQlZ2VlV6aGVNbEFld1AifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc3SVc1Wksxc21EUVlZS0RDUXVnWGgiLCJpZCI6Ijc3SVc1Wksxc21EUVlZS0RDUXVnWGgiLCJuYW1lIjoiU3V6YW4gJiBGcmVlayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNTcxNCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MMUNLMTgwMDAwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXYzVGxPendYN1RMRHlORG5ZTDBmVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzF2M1RsT3p3WDdUTER5TkRuWUwwZlQiLCJpZCI6IjF2M1RsT3p3WDdUTER5TkRuWUwwZlQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWxzIEhldCBBdm9uZCBJcyIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxdjNUbE96d1g3VExEeU5EbllMMGZUIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tLw==", + "YXJ0aXN0LzVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCIsImlkIjoiNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCIsIm5hbWUiOiJSb25uaWUgRmxleCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRORVRoTllKM1d5TmNKV2NtcGpxODgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNE5FVGhOWUozV3lOY0pXY21wanE4OCIsImlkIjoiNE5FVGhOWUozV3lOY0pXY21wanE4OCIsIm5hbWUiOiJJciBTYWlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRORVRoTllKM1d5TmNKV2NtcGpxODgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80TDRuNE0xcGZDYkFqcDFwMktMR1MyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNEw0bjRNMXBmQ2JBanAxcDJLTEdTMiIsImlkIjoiNEw0bjRNMXBmQ2JBanAxcDJLTEdTMiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5NWJjMTVhNmYzMTM2NjRkMWZlNDlmNWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTViYzE1YTZmMzEzNjY0ZDFmZTQ5ZjVkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5NWJjMTVhNmYzMTM2NjRkMWZlNDlmNWQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2FyaWJiZWFuIEdpcmwiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA3LTE3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0TDRuNE0xcGZDYkFqcDFwMktMR1MyIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIiwiaWQiOiI1ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIiwibmFtZSI6IlJvbm5pZSBGbGV4IiwidHlwZSI6ImFydGlzdCIsIg==", + "dXJpIjoic3BvdGlmeTphcnRpc3Q6NWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80TkVUaE5ZSjNXeU5jSldjbXBqcTg4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRORVRoTllKM1d5TmNKV2NtcGpxODgiLCJpZCI6IjRORVRoTllKM1d5TmNKV2NtcGpxODgiLCJuYW1lIjoiSXIgU2FpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0TkVUaE5ZSjNXeU5jSldjbXBqcTg4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE1ODYxMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MNU1CMjYwMDAwNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFZza1VkaDhIbjFTVEsxT3BxRVVLbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRWc2tVZGg4SG4xU1RLMU9wcUVVS28iLCJpZCI6IjRWc2tVZGg4SG4xU1RLMU9wcUVVS28iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2FyaWJiZWFuIEdpcmwiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFZza1VkaDhIbjFTVEsxT3BxRVVLbyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlZUMk5waTZ5R0RxbjNIMDdxSTFEWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82VlQyTnBpNnlHRHFuM0gwN3FJMURZIiwiaWQiOiI2VlQyTnBpNnlHRHFuM0gwN3FJMURZIiwibmFtZSI6IkFERiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2VlQyTnBpNnlHRHFuM0gwN3FJMURZIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCIsImlkIjoiNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCIsIm5hbWUiOiJSb25uaWUgRmxleCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVxZUZQTTJQWlVDemNwa1k0ZTRSQzgifSwiaA==", + "cmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81cWVGUE0yUFpVQ3pjcGtZNGU0UkM4IiwiaWQiOiI1cWVGUE0yUFpVQ3pjcGtZNGU0UkM4IiwibmFtZSI6IkFERiBTYW1za2kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFlRlBNMlBaVUN6Y3BrWTRlNFJDOCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81cWJsZENpWkFrbjJLZnd5VWZpdGhYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVxYmxkQ2laQWtuMktmd3lVZml0aFgiLCJpZCI6IjVxYmxkQ2laQWtuMktmd3lVZml0aFgiLCJuYW1lIjoiQ2FyZWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFibGRDaVpBa24yS2Z3eVVmaXRoWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNUdUlrclRvNk1aR1dRTGtjaFdFeEIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zVHVJa3JUbzZNWkdXUUxrY2hXRXhCIiwiaWQiOiIzVHVJa3JUbzZNWkdXUUxrY2hXRXhCIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzc4OTM5NDE3NjUzNDQ3N2M1MGZkZmViYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3ODkzOTQxNzY1MzQ0NzdjNTBmZGZlYmIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTc4OTM5NDE3NjUzNDQ3N2M1MGZkZmViYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBTCBNRSBMQURJRVMgKGZlYXQuIFNjYXJmYWNlKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDctMDMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNUdUlrclRvNk1aR1dRTGtjaFdFeEIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82VlQyTnBpNnlHRHFuM0gwN3FJMURZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZWVDJOcGk2eUdEcW4zSDA3cUkxRFkiLCJpZCI6IjZWVDJOcGk2eUdEcW4zSDA3cUkxRFkiLCJuYW1lIjoiQURGIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZWVDJOcGk2eQ==", + "R0RxbjNIMDdxSTFEWSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJpZCI6IjVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJuYW1lIjoiUm9ubmllIEZsZXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81cWVGUE0yUFpVQ3pjcGtZNGU0UkM4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVxZUZQTTJQWlVDemNwa1k0ZTRSQzgiLCJpZCI6IjVxZUZQTTJQWlVDemNwa1k0ZTRSQzgiLCJuYW1lIjoiQURGIFNhbXNraSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1cWVGUE0yUFpVQ3pjcGtZNGU0UkM4In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVxYmxkQ2laQWtuMktmd3lVZml0aFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXFibGRDaVpBa24yS2Z3eVVmaXRoWCIsImlkIjoiNXFibGRDaVpBa24yS2Z3eVVmaXRoWCIsIm5hbWUiOiJDYXJlbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1cWJsZENpWkFrbjJLZnd5VWZpdGhYIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBBS2ZHUklEV0RpTEI4RUhPUmZQOEoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEFLZkdSSURXRGlMQjhFSE9SZlA4SiIsImlkIjoiMEFLZkdSSURXRGlMQjhFSE9SZlA4SiIsIm5hbWUiOiJTY2FyZmFjZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowQUtmR1JJRFdEaUxCOEVIT1JmUDhKIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEyNzQ5MywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkw1SEoyNjAwMTAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81eGF0dDlOSmRqN21BWUU1WnhycFBvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNXhhdHQ5TkpkajdtQVlFNVp4cnBQbyIsImlkIjoiNXhhdHQ5TkpkajdtQVlFNVp4cnBQbyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOg==", + "dHJ1ZSwibmFtZSI6IkFMIE1FIExBRElFUyAoZmVhdC4gU2NhcmZhY2UpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjV4YXR0OU5KZGo3bUFZRTVaeHJwUG8ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMERuYk9hdEJuUDdVRGtlaVFBQ2d4ZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wRG5iT2F0Qm5QN1VEa2VpUUFDZ3hkIiwiaWQiOiIwRG5iT2F0Qm5QN1VEa2VpUUFDZ3hkIiwibmFtZSI6IlN0aWNrcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowRG5iT2F0Qm5QN1VEa2VpUUFDZ3hkIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNjZQRUFYS0tTV29YRVp5blFCdnNUbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzY2UEVBWEtLU1dvWEVaeW5RQnZzVG8iLCJpZCI6IjY2UEVBWEtLU1dvWEVaeW5RQnZzVG8iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDQ4YTZjYmNlNjlkMjE0NWJlMzIyZTZhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA0OGE2Y2JjZTY5ZDIxNDViZTMyMmU2YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDQ4YTZjYmNlNjlkMjE0NWJlMzIyZTZhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVuIERvb3IiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTEwLTE5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NjZQRUFYS0tTV29YRVp5blFCdnNUbyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBEbmJPYXRCblA3VURrZWlRQUNneGQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMERuYk9hdEJuUDdVRGtlaVFBQ2d4ZCIsImlkIjoiMERuYk9hdEJuUDdVRGtlaVFBQ2d4ZCIsIm5hbWUiOiJTdGlja3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MERuYk9hdEJuUDdVRGtlaVFBQ2d4ZCJ9XSwiZGlzY19udW1iZXIiOg==", + "MSwiZHVyYXRpb25fbXMiOjIxNjAwMCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyMzAwNTk4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83RjY5bG1Bbjl0NDlXa1BQdTdiVUUzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN0Y2OWxtQW45dDQ5V2tQUHU3YlVFMyIsImlkIjoiN0Y2OWxtQW45dDQ5V2tQUHU3YlVFMyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaXQgSXMgTGV2ZW4hIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3RjY5bG1Bbjl0NDlXa1BQdTdiVUUzIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xRVlkYllwR0F1Snk2dVpvNHNWTW9NIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFFWWRiWXBHQXVKeTZ1Wm80c1ZNb00iLCJpZCI6IjFFWWRiWXBHQXVKeTZ1Wm80c1ZNb00iLCJuYW1lIjoiSWRhbHkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUVZZGJZcEdBdUp5NnVabzRzVk1vTSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJpZCI6IjVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJuYW1lIjoiUm9ubmllIEZsZXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bTFMWVM1TlFvbnhqT2NRRlBRT2I1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZtMUxZUzVOUW9ueGpPY1FGUFFPYjUiLCJpZCI6IjZtMUxZUzVOUW9ueGpPY1FGUFFPYjUiLCJuYW1lIjoiRnJlbm5hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZtMUxZUzVOUW9ueGpPY1FGUFFPYjUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81WElFR2RBVTlMV0VMOE5xam9zNmJqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNVhJRUdkQVU5TFdFTDhOcWpvczZiag==", + "IiwiaWQiOiI1WElFR2RBVTlMV0VMOE5xam9zNmJqIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2MxM2NhMDBlMWY1Zjg5Zjc4Mzk2M2EwZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjMTNjYTAwZTFmNWY4OWY3ODM5NjNhMGQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWMxM2NhMDBlMWY1Zjg5Zjc4Mzk2M2EwZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQT1BVTEFJUiIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDUtMjgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVYSUVHZEFVOUxXRUw4TnFqb3M2YmoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xRVlkYllwR0F1Snk2dVpvNHNWTW9NIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFFWWRiWXBHQXVKeTZ1Wm80c1ZNb00iLCJpZCI6IjFFWWRiWXBHQXVKeTZ1Wm80c1ZNb00iLCJuYW1lIjoiSWRhbHkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUVZZGJZcEdBdUp5NnVabzRzVk1vTSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJpZCI6IjVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwiLCJuYW1lIjoiUm9ubmllIEZsZXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bTFMWVM1TlFvbnhqT2NRRlBRT2I1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZtMUxZUzVOUW9ueGpPY1FGUFFPYjUiLCJpZCI6IjZtMUxZUzVOUW9ueGpPY1FGUFFPYjUiLCJuYW1lIjoiRnJlbm5hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZtMUxZUzVOUW9ueGpPY1FGUFFPYjUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTkyNzg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybg==", + "YWxfaWRzIjp7ImlzcmMiOiJOTEc2NjI2MDAyODEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzR5MzFWY05lMkNFU0x6VVo3dlFON2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80eTMxVmNOZTJDRVNMelVaN3ZRTjdmIiwiaWQiOiI0eTMxVmNOZTJDRVNMelVaN3ZRTjdmIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBPUFVMQUlSIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjR5MzFWY05lMkNFU0x6VVo3dlFON2YifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMWk3RVBXUHBpSm4xOHdCVE5mZ21zWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xaTdFUFdQcGlKbjE4d0JUTmZnbXNZIiwiaWQiOiIxaTdFUFdQcGlKbjE4d0JUTmZnbXNZIiwibmFtZSI6IlNUSUtTVE9GIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFpN0VQV1BwaUpuMTh3QlROZmdtc1kifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80TTdHaFhDTU5sQTZseWltbDRibUZvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNE03R2hYQ01ObEE2bHlpbWw0Ym1GbyIsImlkIjoiNE03R2hYQ01ObEE2bHlpbWw0Ym1GbyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmOTY5NDRhNzNhODIxMzQ2N2I2Y2E5OTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjk2OTQ0YTczYTgyMTM0NjdiNmNhOTkzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmOTY5NDRhNzNhODIxMzQ2N2I2Y2E5OTMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRkFNSUxJRSBCT1ZFTiBBTExFUyIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMTAtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0TTdHaFhDTU5sQTZseWltbDRibUZvIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbg==", + "LnNwb3RpZnkuY29tL2FydGlzdC8xaTdFUFdQcGlKbjE4d0JUTmZnbXNZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFpN0VQV1BwaUpuMTh3QlROZmdtc1kiLCJpZCI6IjFpN0VQV1BwaUpuMTh3QlROZmdtc1kiLCJuYW1lIjoiU1RJS1NUT0YiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MWk3RVBXUHBpSm4xOHdCVE5mZ21zWSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTk5MzMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkJFRUoxMjEwMDAwNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVdvMmJyQ2hPNDF0TjdLVFpHQzloNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVXbzJickNoTzQxdE43S1RaR0M5aDYiLCJpZCI6IjVXbzJickNoTzQxdE43S1RaR0M5aDYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRFJJRURVQkJFTERJSyIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1V28yYnJDaE80MXRON0tUWkdDOWg2In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Als+Het+Avond+Is+Ronnie+Flex&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMjFPcDElMjIlMjBhcnRpc3QlM0ElMjJCb2VmJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMjFPcDElMjIlMjBhcnRpc3QlM0ElMjJCb2VmJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%221Op1%22+artist%3A%22Boef%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Hel%22%20artist%3A%22Sef%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"external_urls":{"spotify":"https://open.spotify.com/album/1HFoz1ACfQuTwhV9xwRAgL"},"href":"https://api.spotify.com/v1/albums/1HFoz1ACfQuTwhV9xwRAgL","id":"1HFoz1ACfQuTwhV9xwRAgL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273643b5739f17ad8e638dde9e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02643b5739f17ad8e638dde9e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851643b5739f17ad8e638dde9e7"}],"is_playable":true,"name":"Slapeloze Nachten","release_date":"2013-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:1HFoz1ACfQuTwhV9xwRAgL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5VGhS6nHpXPbXGhku9RRB0"},"href":"https://api.spotify.com/v1/artists/5VGhS6nHpXPbXGhku9RRB0","id":"5VGhS6nHpXPbXGhku9RRB0","name":"Sef","type":"artist","uri":"spotify:artist:5VGhS6nHpXPbXGhku9RRB0"}],"disc_number":1,"duration_ms":274901,"explicit":false,"external_ids":{"isrc":"NLG661300174"},"external_urls":{"spotify":"https://open.spotify.com/track/0HtrUtMgHt2EKlhDtt1rOa"},"href":"https://api.spotify.com/v1/tracks/0HtrUtMgHt2EKlhDtt1rOa","id":"0HtrUtMgHt2EKlhDtt1rOa","is_local":false,"is_playable":true,"name":"Held","track_number":11,"type":"track","uri":"spotify:track:0HtrUtMgHt2EKlhDtt1rOa"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5VGhS6nHpXPbXGhku9RRB0"},"href":"https://api.spotify.com/v1/artists/5VGhS6nHpXPbXGhku9RRB0","id":"5VGhS6nHpXPbXGhku9RRB0","name":"Sef","type":"artist","uri":"spotify:artist:5VGhS6nHpXPbXGhku9RRB0"}],"external_urls":{"spotify":"https://open.spotify.com/album/58hG8DHeDtvVE2IrKq7IOM"},"href":"https://api.spotify.com/v1/albums/58hG8DHeDtvVE2IrKq7IOM","id":"58hG8DHeDtvVE2IrKq7IOM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733a594605b5152e5cfe6a14a3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023a594605b5152e5cfe6a14a3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513a594605b5152e5cfe6a14a3"}],"is_playable":true,"name":"lieve monsters","release_date":"2025-06-26","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:58hG8DHeDtvVE2IrKq7IOM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5VGhS6nHpXPbXGhku9RRB0"},"href":"https://api.spotify.com/v1/artists/5VGhS6nHpXPbXGhku9RRB0","id":"5VGhS6nHpXPbXGhku9RRB0","name":"Sef","type":"artist","uri":"spotify:artist:5VGhS6nHpXPbXGhku9RRB0"}],"disc_number":1,"duration_ms":192945,"explicit":false,"external_ids":{"isrc":"NLG662500127"},"external_urls":{"spotify":"https://open.spotify.com/track/25zMR1oVxUx16YZiEaPdiq"},"href":"https://api.spotify.com/v1/tracks/25zMR1oVxUx16YZiEaPdiq","id":"25zMR1oVxUx16YZiEaPdiq","is_local":false,"is_playable":true,"name":"hel","track_number":4,"type":"track","uri":"spotify:track:25zMR1oVxUx16YZiEaPdiq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5VGhS6nHpXPbXGhku9RRB0"},"href":"https://api.spotify.com/v1/artists/5VGhS6nHpXPbXGhku9RRB0","id":"5VGhS6nHpXPbXGhku9RRB0","name":"Sef","type":"artist","uri":"spotify:artist:5VGhS6nHpXPbXGhku9RRB0"}],"external_urls":{"spotify":"https://open.spotify.com/album/6xMq7H65IFjuxIJ5JWLnmr"},"href":"https://api.spotify.com/v1/albums/6xMq7H65IFjuxIJ5JWLnmr","id":"6xMq7H65IFjuxIJ5JWLnmr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e17044c553f3fd05a5abddb6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e17044c553f3fd05a5abddb6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e17044c553f3fd05a5abddb6"}],"is_playable":true,"name":"lieve monsters: epiloog","release_date":"2026-06-25","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:6xMq7H65IFjuxIJ5JWLnmr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5VGhS6nHpXPbXGhku9RRB0"},"href":"https://api.spotify.com/v1/artists/5VGhS6nHpXPbXGhku9RRB0","id":"5VGhS6nHpXPbXGhku9RRB0","name":"Sef","type":"artist","uri":"spotify:artist:5VGhS6nHpXPbXGhku9RRB0"}],"disc_number":1,"duration_ms":192945,"explicit":false,"external_ids":{"isrc":"NLG662500127"},"external_urls":{"spotify":"https://open.spotify.com/track/3JiaP7u03MyxyayzMJkLIo"},"href":"https://api.spotify.com/v1/tracks/3JiaP7u03MyxyayzMJkLIo","id":"3JiaP7u03MyxyayzMJkLIo","is_local":false,"is_playable":true,"name":"hel","track_number":4,"type":"track","uri":"spotify:track:3JiaP7u03MyxyayzMJkLIo"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0caJEGgVuXuSHhhrMCmlkI"},"href":"https://api.spotify.com/v1/artists/0caJEGgVuXuSHhhrMCmlkI","id":"0caJEGgVuXuSHhhrMCmlkI","name":"Sefa","type":"artist","uri":"spotify:artist:0caJEGgVuXuSHhhrMCmlkI"}],"external_urls":{"spotify":"https://open.spotify.com/album/4e8qeRn6hayzXt7moP00Op"},"href":"https://api.spotify.com/v1/albums/4e8qeRn6hayzXt7moP00Op","id":"4e8qeRn6hayzXt7moP00Op","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27378f38fd56069775a23169585"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0278f38fd56069775a23169585"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485178f38fd56069775a23169585"}],"is_playable":true,"name":"Het Ergste Moet Nog Komen","release_date":"2024-09-13","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:4e8qeRn6hayzXt7moP00Op"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0caJEGgVuXuSHhhrMCmlkI"},"href":"https://api.spotify.com/v1/artists/0caJEGgVuXuSHhhrMCmlkI","id":"0caJEGgVuXuSHhhrMCmlkI","name":"Sefa","type":"artist","uri":"spotify:artist:0caJEGgVuXuSHhhrMCmlkI"}],"disc_number":1,"duration_ms":68400,"explicit":false,"external_ids":{"isrc":"NLE802400349"},"external_urls":{"spotify":"https://open.spotify.com/track/4Vl1bBpMjCMHAarMScd2Gi"},"href":"https://api.spotify.com/v1/tracks/4Vl1bBpMjCMHAarMScd2Gi","id":"4Vl1bBpMjCMHAarMScd2Gi","is_local":false,"is_playable":true,"name":"Help Me","track_number":8,"type":"track","uri":"spotify:track:4Vl1bBpMjCMHAarMScd2Gi"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"external_urls":{"spotify":"https://open.spotify.com/album/1ZIWau5smvEnTUo0MVMH82"},"href":"https://api.spotify.com/v1/albums/1ZIWau5smvEnTUo0MVMH82","id":"1ZIWau5smvEnTUo0MVMH82","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d3d08f988671a1cfa24ad867"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d3d08f988671a1cfa24ad867"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d3d08f988671a1cfa24ad867"}],"is_playable":true,"name":"Sukkel Voor De Liefde","release_date":"2013-01-01","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:1ZIWau5smvEnTUo0MVMH82"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5VGhS6nHpXPbXGhku9RRB0"},"href":"https://api.spotify.com/v1/artists/5VGhS6nHpXPbXGhku9RRB0","id":"5VGhS6nHpXPbXGhku9RRB0","name":"Sef","type":"artist","uri":"spotify:artist:5VGhS6nHpXPbXGhku9RRB0"}],"disc_number":1,"duration_ms":274901,"explicit":false,"external_ids":{"isrc":"NLG661300174"},"external_urls":{"spotify":"https://open.spotify.com/track/3Ij1gaoXKYPwPquY8V2CkY"},"href":"https://api.spotify.com/v1/tracks/3Ij1gaoXKYPwPquY8V2CkY","id":"3Ij1gaoXKYPwPquY8V2CkY","is_local":false,"is_playable":true,"name":"Held","track_number":3,"type":"track","uri":"spotify:track:3Ij1gaoXKYPwPquY8V2CkY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2rYxEnHjY4kAGMy2muATL0"},"href":"https://api.spotify.com/v1/artists/2rYxEnHjY4kAGMy2muATL0","id":"2rYxEnHjY4kAGMy2muATL0","name":"Seffelinie","type":"artist","uri":"spotify:artist:2rYxEnHjY4kAGMy2muATL0"}],"external_urls":{"spotify":"https://open.spotify.com/album/7Fphjw41C6hJfkhcPOb4Yq"},"href":"https://api.spotify.com/v1/albums/7Fphjw41C6hJfkhcPOb4Yq","id":"7Fphjw41C6hJfkhcPOb4Yq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734d02477bc9047f4801680e6c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024d02477bc9047f4801680e6c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514d02477bc9047f4801680e6c"}],"is_playable":true,"name":"Paranoia","release_date":"2017-01-31","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:7Fphjw41C6hJfkhcPOb4Yq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2rYxEnHjY4kAGMy2muATL0"},"href":"https://api.spotify.com/v1/artists/2rYxEnHjY4kAGMy2muATL0","id":"2rYxEnHjY4kAGMy2muATL0","name":"Seffelinie","type":"artist","uri":"spotify:artist:2rYxEnHjY4kAGMy2muATL0"}],"disc_number":1,"duration_ms":212375,"explicit":true,"external_ids":{"isrc":"TCACW1790961"},"external_urls":{"spotify":"https://open.spotify.com/track/7MiNk2ysd4vefKdEAVFNUY"},"href":"https://api.spotify.com/v1/tracks/7MiNk2ysd4vefKdEAVFNUY","id":"7MiNk2ysd4vefKdEAVFNUY","is_local":false,"is_playable":true,"name":"Helemaal Geflipt","track_number":8,"type":"track","uri":"spotify:track:7MiNk2ysd4vefKdEAVFNUY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2qqZbV6smvvtohQOUgZqKa"},"href":"https://api.spotify.com/v1/artists/2qqZbV6smvvtohQOUgZqKa","id":"2qqZbV6smvvtohQOUgZqKa","name":"Alexandra Savior","type":"artist","uri":"spotify:artist:2qqZbV6smvvtohQOUgZqKa"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QHdGQFzgpIvvSFA83bqyh"},"href":"https://api.spotify.com/v1/albums/3QHdGQFzgpIvvSFA83bqyh","id":"3QHdGQFzgpIvvSFA83bqyh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27386e1d809ad483a6f471d5fc4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0286e1d809ad483a6f471d5fc4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485186e1d809ad483a6f471d5fc4"}],"is_playable":true,"name":"The Archer","release_date":"2020-01-10","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:3QHdGQFzgpIvvSFA83bqyh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2qqZbV6smvvtohQOUgZqKa"},"href":"https://api.spotify.com/v1/artists/2qqZbV6smvvtohQOUgZqKa","id":"2qqZbV6smvvtohQOUgZqKa","name":"Alexandra Savior","type":"artist","uri":"spotify:artist:2qqZbV6smvvtohQOUgZqKa"}],"disc_number":1,"duration_ms":162944,"explicit":false,"external_ids":{"isrc":"GBKPL1969965"},"external_urls":{"spotify":"https://open.spotify.com/track/7gsgDKsnLvCRZdtaEmYE0K"},"href":"https://api.spotify.com/v1/tracks/7gsgDKsnLvCRZdtaEmYE0K","id":"7gsgDKsnLvCRZdtaEmYE0K","is_local":false,"is_playable":true,"name":"Can't Help Myself","track_number":6,"type":"track","uri":"spotify:track:7gsgDKsnLvCRZdtaEmYE0K"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MXzeG7zoG8pKpqKCOqcZL"},"href":"https://api.spotify.com/v1/artists/7MXzeG7zoG8pKpqKCOqcZL","id":"7MXzeG7zoG8pKpqKCOqcZL","name":"Sephyx","type":"artist","uri":"spotify:artist:7MXzeG7zoG8pKpqKCOqcZL"}],"external_urls":{"spotify":"https://open.spotify.com/album/3GjAfEGNESBmplkoIthagt"},"href":"https://api.spotify.com/v1/albums/3GjAfEGNESBmplkoIthagt","id":"3GjAfEGNESBmplkoIthagt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273862957f4effd80ee034a8175"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02862957f4effd80ee034a8175"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851862957f4effd80ee034a8175"}],"is_playable":true,"name":"When Hell Freezes Over","release_date":"2023-11-09","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3GjAfEGNESBmplkoIthagt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MXzeG7zoG8pKpqKCOqcZL"},"href":"https://api.spotify.com/v1/artists/7MXzeG7zoG8pKpqKCOqcZL","id":"7MXzeG7zoG8pKpqKCOqcZL","name":"Sephyx","type":"artist","uri":"spotify:artist:7MXzeG7zoG8pKpqKCOqcZL"}],"disc_number":1,"duration_ms":157997,"explicit":false,"external_ids":{"isrc":"NLE802300509"},"external_urls":{"spotify":"https://open.spotify.com/track/2tAFRn0ezKL7J9nriUN3wR"},"href":"https://api.spotify.com/v1/tracks/2tAFRn0ezKL7J9nriUN3wR","id":"2tAFRn0ezKL7J9nriUN3wR","is_local":false,"is_playable":true,"name":"When Hell Freezes Over","track_number":1,"type":"track","uri":"spotify:track:2tAFRn0ezKL7J9nriUN3wR"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkhlbCUyMiUyMGFydGlzdCUzQSUyMlNlZiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yMzk1MVBnOVBpTEI4VXphM2sxMmc2IiwiaWQiOiIyMzk1MVBnOVBpTEI4VXphM2sxMmc2IiwibmFtZSI6IlRoZSBPcHBvc2l0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjM5NTFQZzlQaUxCOFV6YTNrMTJnNiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFIRm96MUFDZlF1VHdoVjl4d1JBZ0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xSEZvejFBQ2ZRdVR3aFY5eHdSQWdMIiwiaWQiOiIxSEZvejFBQ2ZRdVR3aFY5eHdSQWdMIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQw", + "MDAwYjI3MzY0M2I1NzM5ZjE3YWQ4ZTYzOGRkZTllNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2NDNiNTczOWYxN2FkOGU2MzhkZGU5ZTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTY0M2I1NzM5ZjE3YWQ4ZTYzOGRkZTllNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbGFwZWxvemUgTmFjaHRlbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxSEZvejFBQ2ZRdVR3aFY5eHdSQWdMIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yMzk1MVBnOVBpTEI4VXphM2sxMmc2IiwiaWQiOiIyMzk1MVBnOVBpTEI4VXphM2sxMmc2IiwibmFtZSI6IlRoZSBPcHBvc2l0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjM5NTFQZzlQaUxCOFV6YTNrMTJnNiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81VkdoUzZuSHBYUGJYR2hrdTlSUkIwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJpZCI6IjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJuYW1lIjoiU2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjc0OTAxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYxMzAwMTc0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wSHRyVXRNZ0h0MkVLbGhEdHQxck9hIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMEh0clV0TWdIdDJFS2xoRHR0MXJPYSIsImlkIjoiMEh0clV0TWdIdDJFS2xoRHR0MXJPYSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZWxkIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowSHRyVXRNZ0h0MkVLbGhEdHQxck9hIn0seyJhbGJ1bSI6eyJhbGJ1bV90eQ==", + "cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81VkdoUzZuSHBYUGJYR2hrdTlSUkIwIiwiaWQiOiI1VkdoUzZuSHBYUGJYR2hrdTlSUkIwIiwibmFtZSI6IlNlZiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1VkdoUzZuSHBYUGJYR2hrdTlSUkIwIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNThoRzhESGVEdHZWRTJJcktxN0lPTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzU4aEc4REhlRHR2VkUySXJLcTdJT00iLCJpZCI6IjU4aEc4REhlRHR2VkUySXJLcTdJT00iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczM2E1OTQ2MDViNTE1MmU1Y2ZlNmExNGEzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjNhNTk0NjA1YjUxNTJlNWNmZTZhMTRhMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxM2E1OTQ2MDViNTE1MmU1Y2ZlNmExNGEzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6ImxpZXZlIG1vbnN0ZXJzIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wNi0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjU4aEc4REhlRHR2VkUySXJLcTdJT00ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81VkdoUzZuSHBYUGJYR2hrdTlSUkIwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJpZCI6IjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJuYW1lIjoiU2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTkyOTQ1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyNTAwMTI3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yNQ==", + "ek1SMW9WeFV4MTZZWmlFYVBkaXEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yNXpNUjFvVnhVeDE2WVppRWFQZGlxIiwiaWQiOiIyNXpNUjFvVnhVeDE2WVppRWFQZGlxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6ImhlbCIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyNXpNUjFvVnhVeDE2WVppRWFQZGlxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCIsImlkIjoiNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCIsIm5hbWUiOiJTZWYiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVZHaFM2bkhwWFBiWEdoa3U5UlJCMCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ4TXE3SDY1SUZqdXhJSjVKV0xubXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82eE1xN0g2NUlGanV4SUo1SldMbm1yIiwiaWQiOiI2eE1xN0g2NUlGanV4SUo1SldMbm1yIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2UxNzA0NGM1NTNmM2ZkMDVhNWFiZGRiNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlMTcwNDRjNTUzZjNmZDA1YTVhYmRkYjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWUxNzA0NGM1NTNmM2ZkMDVhNWFiZGRiNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJsaWV2ZSBtb25zdGVyczogZXBpbG9vZyIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDYtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2eE1xN0g2NUlGanV4SUo1SldMbm1yIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81VkdoUzZuSHBYUA==", + "YlhHaGt1OVJSQjAiLCJpZCI6IjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJuYW1lIjoiU2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTkyOTQ1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyNTAwMTI3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zSmlhUDd1MDNNeXh5YXl6TUprTElvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0ppYVA3dTAzTXl4eWF5ek1Ka0xJbyIsImlkIjoiM0ppYVA3dTAzTXl4eWF5ek1Ka0xJbyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJoZWwiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0ppYVA3dTAzTXl4eWF5ek1Ka0xJbyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wY2FKRUdnVnVYdVNIaGhyTUNtbGtJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBjYUpFR2dWdVh1U0hoaHJNQ21sa0kiLCJpZCI6IjBjYUpFR2dWdVh1U0hoaHJNQ21sa0kiLCJuYW1lIjoiU2VmYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowY2FKRUdnVnVYdVNIaGhyTUNtbGtJIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNGU4cWVSbjZoYXl6WHQ3bW9QMDBPcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRlOHFlUm42aGF5elh0N21vUDAwT3AiLCJpZCI6IjRlOHFlUm42aGF5elh0N21vUDAwT3AiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzhmMzhmZDU2MDY5Nzc1YTIzMTY5NTg1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjc4ZjM4ZmQ1NjA2OTc3NWEyMzE2OTU4NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzhmMzhmZDU2MDY5Nzc1YTIzMTY5NTg1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBFcmdzdGUgTW9ldCBOb2cgS29tZW4iLCJyZWxlYXNlX2RhdA==", + "ZSI6IjIwMjQtMDktMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0ZThxZVJuNmhheXpYdDdtb1AwME9wIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGNhSkVHZ1Z1WHVTSGhock1DbWxrSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wY2FKRUdnVnVYdVNIaGhyTUNtbGtJIiwiaWQiOiIwY2FKRUdnVnVYdVNIaGhyTUNtbGtJIiwibmFtZSI6IlNlZmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGNhSkVHZ1Z1WHVTSGhock1DbWxrSSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo2ODQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRTgwMjQwMDM0OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFZsMWJCcE1qQ01IQWFyTVNjZDJHaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRWbDFiQnBNakNNSEFhck1TY2QyR2kiLCJpZCI6IjRWbDFiQnBNakNNSEFhck1TY2QyR2kiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGVscCBNZSIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0VmwxYkJwTWpDTUhBYXJNU2NkMkdpIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yMzk1MVBnOVBpTEI4VXphM2sxMmc2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzIzOTUxUGc5UGlMQjhVemEzazEyZzYiLCJpZCI6IjIzOTUxUGc5UGlMQjhVemEzazEyZzYiLCJuYW1lIjoiVGhlIE9wcG9zaXRlcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyMzk1MVBnOVBpTEI4VXphM2sxMmc2In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMVpJV2F1NXNtdkVuVFVvME1WTUg4MiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFaSVdhdTVzbXZFblRVbzBNVk1IODIiLCJpZCI6IjFaSVdhdTVzbXZFblRVbzBNVk1IODIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZA==", + "M2QwOGY5ODg2NzFhMWNmYTI0YWQ4NjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZDNkMDhmOTg4NjcxYTFjZmEyNGFkODY3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkM2QwOGY5ODg2NzFhMWNmYTI0YWQ4NjcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3Vra2VsIFZvb3IgRGUgTGllZmRlIiwicmVsZWFzZV9kYXRlIjoiMjAxMy0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVpJV2F1NXNtdkVuVFVvME1WTUg4MiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzIzOTUxUGc5UGlMQjhVemEzazEyZzYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiIsImlkIjoiMjM5NTFQZzlQaUxCOFV6YTNrMTJnNiIsIm5hbWUiOiJUaGUgT3Bwb3NpdGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjIzOTUxUGc5UGlMQjhVemEzazEyZzYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81VkdoUzZuSHBYUGJYR2hrdTlSUkIwIiwiaWQiOiI1VkdoUzZuSHBYUGJYR2hrdTlSUkIwIiwibmFtZSI6IlNlZiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1VkdoUzZuSHBYUGJYR2hrdTlSUkIwIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI3NDkwMSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzY2MTMwMDE3NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0lqMWdhb1hLWVB3UHF1WThWMkNrWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNJajFnYW9YS1lQd1BxdVk4VjJDa1kiLCJpZCI6IjNJajFnYW9YS1lQd1BxdVk4VjJDa1kiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGVsZCIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozSWoxZ2FvWEtZUHdQcXVZOFYyQ2tZIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYQ==", + "bGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMnJZeEVuSGpZNGtBR015Mm11QVRMMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8ycll4RW5Ialk0a0FHTXkybXVBVEwwIiwiaWQiOiIycll4RW5Ialk0a0FHTXkybXVBVEwwIiwibmFtZSI6IlNlZmZlbGluaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MnJZeEVuSGpZNGtBR015Mm11QVRMMCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdGcGhqdzQxQzZoSmZraGNQT2I0WXEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83RnBoanc0MUM2aEpma2hjUE9iNFlxIiwiaWQiOiI3RnBoanc0MUM2aEpma2hjUE9iNFlxIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRkMDI0NzdiYzkwNDdmNDgwMTY4MGU2YyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0ZDAyNDc3YmM5MDQ3ZjQ4MDE2ODBlNmMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRkMDI0NzdiYzkwNDdmNDgwMTY4MGU2YyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQYXJhbm9pYSIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDEtMzEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3RnBoanc0MUM2aEpma2hjUE9iNFlxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMnJZeEVuSGpZNGtBR015Mm11QVRMMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8ycll4RW5Ialk0a0FHTXkybXVBVEwwIiwiaWQiOiIycll4RW5Ialk0a0FHTXkybXVBVEwwIiwibmFtZSI6IlNlZmZlbGluaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MnJZeEVuSGpZNGtBR015Mm11QVRMMCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTIzNzUsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlRDQUNXMTc5MDk2MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNw==", + "TWlOazJ5c2Q0dmVmS2RFQVZGTlVZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN01pTmsyeXNkNHZlZktkRUFWRk5VWSIsImlkIjoiN01pTmsyeXNkNHZlZktkRUFWRk5VWSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZWxlbWFhbCBHZWZsaXB0IiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdNaU5rMnlzZDR2ZWZLZEVBVkZOVVkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMnFxWmJWNnNtdnZ0b2hRT1VnWnFLYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8ycXFaYlY2c212dnRvaFFPVWdacUthIiwiaWQiOiIycXFaYlY2c212dnRvaFFPVWdacUthIiwibmFtZSI6IkFsZXhhbmRyYSBTYXZpb3IiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MnFxWmJWNnNtdnZ0b2hRT1VnWnFLYSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNRSGRHUUZ6Z3BJdnZTRkE4M2JxeWgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zUUhkR1FGemdwSXZ2U0ZBODNicXloIiwiaWQiOiIzUUhkR1FGemdwSXZ2U0ZBODNicXloIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzg2ZTFkODA5YWQ0ODNhNmY0NzFkNWZjNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4NmUxZDgwOWFkNDgzYTZmNDcxZDVmYzQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTg2ZTFkODA5YWQ0ODNhNmY0NzFkNWZjNCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgQXJjaGVyIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wMS0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNRSGRHUUZ6Z3BJdnZTRkE4M2JxeWgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8ycXFaYlY2c212dnRvaFFPVWdacUthIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpcw==", + "dHMvMnFxWmJWNnNtdnZ0b2hRT1VnWnFLYSIsImlkIjoiMnFxWmJWNnNtdnZ0b2hRT1VnWnFLYSIsIm5hbWUiOiJBbGV4YW5kcmEgU2F2aW9yIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJxcVpiVjZzbXZ2dG9oUU9VZ1pxS2EifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTYyOTQ0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JLUEwxOTY5OTY1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83Z3NnREtzbkx2Q1JaZHRhRW1ZRTBLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2dzZ0RLc25MdkNSWmR0YUVtWUUwSyIsImlkIjoiN2dzZ0RLc25MdkNSWmR0YUVtWUUwSyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYW4ndCBIZWxwIE15c2VsZiIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3Z3NnREtzbkx2Q1JaZHRhRW1ZRTBLIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TVh6ZUc3em9HOHBLcHFLQ09xY1pMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNWHplRzd6b0c4cEtwcUtDT3FjWkwiLCJpZCI6IjdNWHplRzd6b0c4cEtwcUtDT3FjWkwiLCJuYW1lIjoiU2VwaHl4IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNWHplRzd6b0c4cEtwcUtDT3FjWkwifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zR2pBZkVHTkVTQm1wbGtvSXRoYWd0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0dqQWZFR05FU0JtcGxrb0l0aGFndCIsImlkIjoiM0dqQWZFR05FU0JtcGxrb0l0aGFndCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4NjI5NTdmNGVmZmQ4MGVlMDM0YTgxNzUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODYyOTU3ZjRlZmZkODBlZTAzNGE4MTc1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4NjI5NTdmNGVmZmQ4MGVlMDM0YTgxNzUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYQ==", + "bWUiOiJXaGVuIEhlbGwgRnJlZXplcyBPdmVyIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0xMS0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0dqQWZFR05FU0JtcGxrb0l0aGFndCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdNWHplRzd6b0c4cEtwcUtDT3FjWkwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN01YemVHN3pvRzhwS3BxS0NPcWNaTCIsImlkIjoiN01YemVHN3pvRzhwS3BxS0NPcWNaTCIsIm5hbWUiOiJTZXBoeXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01YemVHN3pvRzhwS3BxS0NPcWNaTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTc5OTcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEU4MDIzMDA1MDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJ0QUZSbjBlektMN0o5bnJpVU4zd1IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8ydEFGUm4wZXpLTDdKOW5yaVVOM3dSIiwiaWQiOiIydEFGUm4wZXpLTDdKOW5yaVVOM3dSIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldoZW4gSGVsbCBGcmVlemVzIE92ZXIiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MnRBRlJuMGV6S0w3SjlucmlVTjN3UiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Hel%22+artist%3A%22Sef%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1WbHVjaHRzdHJvb2slMjBTZWYmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCIsImlkIjoiNVZHaFM2bkhwWFBiWEdoa3U5UlJCMCIsIm5hbWUiOiJTZWYiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVZHaFM2bkhwWFBiWEdoa3U5UlJCMCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJuQ2dPeFliYVhnTGxublBBVndwOW8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8ybkNnT3hZYmFYZ0xsbm5QQVZ3cDlvIiwiaWQiOiIybkNnT3hZYmFYZ0xsbm5QQVZ3cDlvIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FhYjBjODQ3ZmRjNzdlYWQwNDI3MzI0NA==", + "In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmFhYjBjODQ3ZmRjNzdlYWQwNDI3MzI0NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYWFiMGM4NDdmZGM3N2VhZDA0MjczMjQ0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlIExldmVuIiwicmVsZWFzZV9kYXRlIjoiMjAxMS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJuQ2dPeFliYVhnTGxublBBVndwOW8ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81VkdoUzZuSHBYUGJYR2hrdTlSUkIwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJpZCI6IjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAiLCJuYW1lIjoiU2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVWR2hTNm5IcFhQYlhHaGt1OVJSQjAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMzNTQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYxMTAwNDc3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82Yk8zQmRjbmEwUm9CVElkbTVqM1dtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmJPM0JkY25hMFJvQlRJZG01ajNXbSIsImlkIjoiNmJPM0JkY25hMFJvQlRJZG01ajNXbSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZSBMZXZlbiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2Yk8zQmRjbmEwUm9CVElkbTVqM1dtIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Vluchtstrook+Sef&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlpvdXRlbGFuZGUlMjIlMjBhcnRpc3QlM0ElMjJCbCVDMyVCOGYlMkMlMjBHZWlrZSUyMEFybmFlcnQlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlpvdXRlbGFuZGUlMjIlMjBhcnRpc3QlM0ElMjJCbCVDMyVCOGYlMkMlMjBHZWlrZSUyMEFybmFlcnQlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Zoutelande%22+artist%3A%22Bl%C3%B8f%2C+Geike+Arnaert%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZsdWNodGVuJTIwS2FuJTIwTmlldCUyME1lZXIlMjIlMjBhcnRpc3QlM0ElMjJCbCVDMyVCNmYlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZsdWNodGVuJTIwS2FuJTIwTmlldCUyME1lZXIlMjIlMjBhcnRpc3QlM0ElMjJCbCVDMyVCNmYlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Vluchten+Kan+Niet+Meer%22+artist%3A%22Bl%C3%B6f%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1WYWFyd2VsJTIwS3JpcyUyMEtyb3NzJTIwQW1zdGVyZGFtJTJDJTIwRW1tYSUyMEhlZXN0ZXJzJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1WYWFyd2VsJTIwS3JpcyUyMEtyb3NzJTIwQW1zdGVyZGFtJTJDJTIwRW1tYSUyMEhlZXN0ZXJzJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Vaarwel+Kris+Kross+Amsterdam%2C+Emma+Heesters&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Zoutelande%22%20artist%3A%22Bl%C3%B8f%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tTV2cKaA2TXTUOE642C59"},"href":"https://api.spotify.com/v1/albums/0tTV2cKaA2TXTUOE642C59","id":"0tTV2cKaA2TXTUOE642C59","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfe2c03bb1a14bf176c19833"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfe2c03bb1a14bf176c19833"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfe2c03bb1a14bf176c19833"}],"is_playable":true,"name":"Aan","release_date":"2017-05-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0tTV2cKaA2TXTUOE642C59"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":219546,"explicit":false,"external_ids":{"isrc":"NLR4H1700009"},"external_urls":{"spotify":"https://open.spotify.com/track/6aAJY5FYW0TMLsUe2T7x4p"},"href":"https://api.spotify.com/v1/tracks/6aAJY5FYW0TMLsUe2T7x4p","id":"6aAJY5FYW0TMLsUe2T7x4p","is_local":false,"is_playable":true,"name":"Zoutelande","track_number":9,"type":"track","uri":"spotify:track:6aAJY5FYW0TMLsUe2T7x4p"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0lijSwwkPwnIv3NOnwL5O0"},"href":"https://api.spotify.com/v1/albums/0lijSwwkPwnIv3NOnwL5O0","id":"0lijSwwkPwnIv3NOnwL5O0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ca25d639c8cdce5cf930b79d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ca25d639c8cdce5cf930b79d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ca25d639c8cdce5cf930b79d"}],"is_playable":true,"name":"Zoutelande (feat. Geike)","release_date":"2017-10-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0lijSwwkPwnIv3NOnwL5O0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":223266,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/0le8EcVp4x1JjMhwRKIOVi"},"href":"https://api.spotify.com/v1/tracks/0le8EcVp4x1JjMhwRKIOVi","id":"0le8EcVp4x1JjMhwRKIOVi","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":1,"type":"track","uri":"spotify:track:0le8EcVp4x1JjMhwRKIOVi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tTV2cKaA2TXTUOE642C59"},"href":"https://api.spotify.com/v1/albums/0tTV2cKaA2TXTUOE642C59","id":"0tTV2cKaA2TXTUOE642C59","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfe2c03bb1a14bf176c19833"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfe2c03bb1a14bf176c19833"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfe2c03bb1a14bf176c19833"}],"is_playable":true,"name":"Aan","release_date":"2017-05-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0tTV2cKaA2TXTUOE642C59"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":223266,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/7MOX3ibncypw3xGb4HZVFA"},"href":"https://api.spotify.com/v1/tracks/7MOX3ibncypw3xGb4HZVFA","id":"7MOX3ibncypw3xGb4HZVFA","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":15,"type":"track","uri":"spotify:track:7MOX3ibncypw3xGb4HZVFA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2o19Ls84H4haIAYaO65a1S"},"href":"https://api.spotify.com/v1/albums/2o19Ls84H4haIAYaO65a1S","id":"2o19Ls84H4haIAYaO65a1S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee25d2079e9a78e72278db56"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee25d2079e9a78e72278db56"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee25d2079e9a78e72278db56"}],"is_playable":true,"name":"Live Op Concert At Sea 2023","release_date":"2023-11-17","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:2o19Ls84H4haIAYaO65a1S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":287733,"explicit":false,"external_ids":{"isrc":"NLR4H2300010"},"external_urls":{"spotify":"https://open.spotify.com/track/0r9NmUxxEXjiH2gBas6182"},"href":"https://api.spotify.com/v1/tracks/0r9NmUxxEXjiH2gBas6182","id":"0r9NmUxxEXjiH2gBas6182","is_local":false,"is_playable":true,"name":"Zoutelande (Live op Concert at SEA 2023)","track_number":10,"type":"track","uri":"spotify:track:0r9NmUxxEXjiH2gBas6182"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2EfNgd1mkKg9kk8arShMRW"},"href":"https://api.spotify.com/v1/albums/2EfNgd1mkKg9kk8arShMRW","id":"2EfNgd1mkKg9kk8arShMRW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2280da6e6ad35e798fd1254"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2280da6e6ad35e798fd1254"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2280da6e6ad35e798fd1254"}],"is_playable":true,"name":"Aan (Live op CAS 2017)","release_date":"2017-12-21","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:2EfNgd1mkKg9kk8arShMRW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":224706,"explicit":false,"external_ids":{"isrc":"NLR4H1700020"},"external_urls":{"spotify":"https://open.spotify.com/track/0PeckNl9t4TmTdo1yxjvLI"},"href":"https://api.spotify.com/v1/tracks/0PeckNl9t4TmTdo1yxjvLI","id":"0PeckNl9t4TmTdo1yxjvLI","is_local":false,"is_playable":true,"name":"Zoutelande - Live op CAS 2017","track_number":5,"type":"track","uri":"spotify:track:0PeckNl9t4TmTdo1yxjvLI"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6JFOiKKI5qZ5OWve4GXCRV"},"href":"https://api.spotify.com/v1/albums/6JFOiKKI5qZ5OWve4GXCRV","id":"6JFOiKKI5qZ5OWve4GXCRV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738ce8238c93bb0ef0a08dde5d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028ce8238c93bb0ef0a08dde5d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518ce8238c93bb0ef0a08dde5d"}],"is_playable":true,"name":"TOP 40 HITDOSSIER - Zomer (Summer Top 100)","release_date":"2020-06-19","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:6JFOiKKI5qZ5OWve4GXCRV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":219053,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/3kVgTVpGlRdSaw5v0gLkJM"},"href":"https://api.spotify.com/v1/tracks/3kVgTVpGlRdSaw5v0gLkJM","id":"3kVgTVpGlRdSaw5v0gLkJM","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":19,"type":"track","uri":"spotify:track:3kVgTVpGlRdSaw5v0gLkJM"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6F41L5AXF6IgP0ch4y8qaq"},"href":"https://api.spotify.com/v1/albums/6F41L5AXF6IgP0ch4y8qaq","id":"6F41L5AXF6IgP0ch4y8qaq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27395d66e2e22b356a355186fb6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0295d66e2e22b356a355186fb6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485195d66e2e22b356a355186fb6"}],"is_playable":true,"name":"TOP 40 HITDOSSIER - #1 Hits","release_date":"2022-12-02","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:6F41L5AXF6IgP0ch4y8qaq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":219065,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/3qDpNSecolwVw09YW0WbEP"},"href":"https://api.spotify.com/v1/tracks/3qDpNSecolwVw09YW0WbEP","id":"3qDpNSecolwVw09YW0WbEP","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":5,"type":"track","uri":"spotify:track:3qDpNSecolwVw09YW0WbEP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/470mml6vgfwataGIptg09u"},"href":"https://api.spotify.com/v1/albums/470mml6vgfwataGIptg09u","id":"470mml6vgfwataGIptg09u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734da80e978d04d2fc588c784c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024da80e978d04d2fc588c784c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514da80e978d04d2fc588c784c"}],"is_playable":true,"name":"Zomerhits Allertijden 2025","release_date":"2024-07-19","release_date_precision":"day","total_tracks":122,"type":"album","uri":"spotify:album:470mml6vgfwataGIptg09u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":219065,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/6WCDVHADOZJORYeLbmJqh8"},"href":"https://api.spotify.com/v1/tracks/6WCDVHADOZJORYeLbmJqh8","id":"6WCDVHADOZJORYeLbmJqh8","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":22,"type":"track","uri":"spotify:track:6WCDVHADOZJORYeLbmJqh8"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Zoutelande%22%20artist%3A%22Bl%C3%B8f%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tTV2cKaA2TXTUOE642C59"},"href":"https://api.spotify.com/v1/albums/0tTV2cKaA2TXTUOE642C59","id":"0tTV2cKaA2TXTUOE642C59","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfe2c03bb1a14bf176c19833"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfe2c03bb1a14bf176c19833"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfe2c03bb1a14bf176c19833"}],"is_playable":true,"name":"Aan","release_date":"2017-05-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0tTV2cKaA2TXTUOE642C59"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":219546,"explicit":false,"external_ids":{"isrc":"NLR4H1700009"},"external_urls":{"spotify":"https://open.spotify.com/track/6aAJY5FYW0TMLsUe2T7x4p"},"href":"https://api.spotify.com/v1/tracks/6aAJY5FYW0TMLsUe2T7x4p","id":"6aAJY5FYW0TMLsUe2T7x4p","is_local":false,"is_playable":true,"name":"Zoutelande","track_number":9,"type":"track","uri":"spotify:track:6aAJY5FYW0TMLsUe2T7x4p"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0lijSwwkPwnIv3NOnwL5O0"},"href":"https://api.spotify.com/v1/albums/0lijSwwkPwnIv3NOnwL5O0","id":"0lijSwwkPwnIv3NOnwL5O0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ca25d639c8cdce5cf930b79d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ca25d639c8cdce5cf930b79d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ca25d639c8cdce5cf930b79d"}],"is_playable":true,"name":"Zoutelande (feat. Geike)","release_date":"2017-10-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0lijSwwkPwnIv3NOnwL5O0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":223266,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/0le8EcVp4x1JjMhwRKIOVi"},"href":"https://api.spotify.com/v1/tracks/0le8EcVp4x1JjMhwRKIOVi","id":"0le8EcVp4x1JjMhwRKIOVi","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":1,"type":"track","uri":"spotify:track:0le8EcVp4x1JjMhwRKIOVi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tTV2cKaA2TXTUOE642C59"},"href":"https://api.spotify.com/v1/albums/0tTV2cKaA2TXTUOE642C59","id":"0tTV2cKaA2TXTUOE642C59","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfe2c03bb1a14bf176c19833"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfe2c03bb1a14bf176c19833"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfe2c03bb1a14bf176c19833"}],"is_playable":true,"name":"Aan","release_date":"2017-05-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0tTV2cKaA2TXTUOE642C59"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":223266,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/7MOX3ibncypw3xGb4HZVFA"},"href":"https://api.spotify.com/v1/tracks/7MOX3ibncypw3xGb4HZVFA","id":"7MOX3ibncypw3xGb4HZVFA","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":15,"type":"track","uri":"spotify:track:7MOX3ibncypw3xGb4HZVFA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2o19Ls84H4haIAYaO65a1S"},"href":"https://api.spotify.com/v1/albums/2o19Ls84H4haIAYaO65a1S","id":"2o19Ls84H4haIAYaO65a1S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee25d2079e9a78e72278db56"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee25d2079e9a78e72278db56"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee25d2079e9a78e72278db56"}],"is_playable":true,"name":"Live Op Concert At Sea 2023","release_date":"2023-11-17","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:2o19Ls84H4haIAYaO65a1S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":287733,"explicit":false,"external_ids":{"isrc":"NLR4H2300010"},"external_urls":{"spotify":"https://open.spotify.com/track/0r9NmUxxEXjiH2gBas6182"},"href":"https://api.spotify.com/v1/tracks/0r9NmUxxEXjiH2gBas6182","id":"0r9NmUxxEXjiH2gBas6182","is_local":false,"is_playable":true,"name":"Zoutelande (Live op Concert at SEA 2023)","track_number":10,"type":"track","uri":"spotify:track:0r9NmUxxEXjiH2gBas6182"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2EfNgd1mkKg9kk8arShMRW"},"href":"https://api.spotify.com/v1/albums/2EfNgd1mkKg9kk8arShMRW","id":"2EfNgd1mkKg9kk8arShMRW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2280da6e6ad35e798fd1254"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2280da6e6ad35e798fd1254"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2280da6e6ad35e798fd1254"}],"is_playable":true,"name":"Aan (Live op CAS 2017)","release_date":"2017-12-21","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:2EfNgd1mkKg9kk8arShMRW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":224706,"explicit":false,"external_ids":{"isrc":"NLR4H1700020"},"external_urls":{"spotify":"https://open.spotify.com/track/0PeckNl9t4TmTdo1yxjvLI"},"href":"https://api.spotify.com/v1/tracks/0PeckNl9t4TmTdo1yxjvLI","id":"0PeckNl9t4TmTdo1yxjvLI","is_local":false,"is_playable":true,"name":"Zoutelande - Live op CAS 2017","track_number":5,"type":"track","uri":"spotify:track:0PeckNl9t4TmTdo1yxjvLI"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6JFOiKKI5qZ5OWve4GXCRV"},"href":"https://api.spotify.com/v1/albums/6JFOiKKI5qZ5OWve4GXCRV","id":"6JFOiKKI5qZ5OWve4GXCRV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738ce8238c93bb0ef0a08dde5d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028ce8238c93bb0ef0a08dde5d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518ce8238c93bb0ef0a08dde5d"}],"is_playable":true,"name":"TOP 40 HITDOSSIER - Zomer (Summer Top 100)","release_date":"2020-06-19","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:6JFOiKKI5qZ5OWve4GXCRV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":219053,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/3kVgTVpGlRdSaw5v0gLkJM"},"href":"https://api.spotify.com/v1/tracks/3kVgTVpGlRdSaw5v0gLkJM","id":"3kVgTVpGlRdSaw5v0gLkJM","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":19,"type":"track","uri":"spotify:track:3kVgTVpGlRdSaw5v0gLkJM"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6F41L5AXF6IgP0ch4y8qaq"},"href":"https://api.spotify.com/v1/albums/6F41L5AXF6IgP0ch4y8qaq","id":"6F41L5AXF6IgP0ch4y8qaq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27395d66e2e22b356a355186fb6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0295d66e2e22b356a355186fb6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485195d66e2e22b356a355186fb6"}],"is_playable":true,"name":"TOP 40 HITDOSSIER - #1 Hits","release_date":"2022-12-02","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:6F41L5AXF6IgP0ch4y8qaq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":219065,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/3qDpNSecolwVw09YW0WbEP"},"href":"https://api.spotify.com/v1/tracks/3qDpNSecolwVw09YW0WbEP","id":"3qDpNSecolwVw09YW0WbEP","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":5,"type":"track","uri":"spotify:track:3qDpNSecolwVw09YW0WbEP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/470mml6vgfwataGIptg09u"},"href":"https://api.spotify.com/v1/albums/470mml6vgfwataGIptg09u","id":"470mml6vgfwataGIptg09u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734da80e978d04d2fc588c784c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024da80e978d04d2fc588c784c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514da80e978d04d2fc588c784c"}],"is_playable":true,"name":"Zomerhits Allertijden 2025","release_date":"2024-07-19","release_date_precision":"day","total_tracks":122,"type":"album","uri":"spotify:album:470mml6vgfwataGIptg09u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":219065,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/6WCDVHADOZJORYeLbmJqh8"},"href":"https://api.spotify.com/v1/tracks/6WCDVHADOZJORYeLbmJqh8","id":"6WCDVHADOZJORYeLbmJqh8","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":22,"type":"track","uri":"spotify:track:6WCDVHADOZJORYeLbmJqh8"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Zoutelande%22+artist%3A%22Bl%C3%B8f%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlpvJTIwVmVyJTIwV2VnJTIyJTIwYXJ0aXN0JTNBJTIyTWFyY28lMjBCb3JzYXRvJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlpvJTIwVmVyJTIwV2VnJTIyJTIwYXJ0aXN0JTNBJTIyTWFyY28lMjBCb3JzYXRvJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Zo+Ver+Weg%22+artist%3A%22Marco+Borsato%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Blijven%20Slapen%20Lil%20Kleine&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Blijven%20Slapen%20Lil%20Kleine&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/4dhjoNEwjKzRFE4AuRYFSV"},"href":"https://api.spotify.com/v1/albums/4dhjoNEwjKzRFE4AuRYFSV","id":"4dhjoNEwjKzRFE4AuRYFSV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335a30b58634baf0a81a0ede4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235a30b58634baf0a81a0ede4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135a30b58634baf0a81a0ede4"}],"is_playable":true,"name":"Alleen","release_date":"2017-06-23","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4dhjoNEwjKzRFE4AuRYFSV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":139748,"explicit":true,"external_ids":{"isrc":"NLG661700443"},"external_urls":{"spotify":"https://open.spotify.com/track/3hj0Rahf7SOplXTxfGjUu3"},"href":"https://api.spotify.com/v1/tracks/3hj0Rahf7SOplXTxfGjUu3","id":"3hj0Rahf7SOplXTxfGjUu3","is_local":false,"is_playable":true,"name":"Volume","track_number":1,"type":"track","uri":"spotify:track:3hj0Rahf7SOplXTxfGjUu3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/4dhjoNEwjKzRFE4AuRYFSV"},"href":"https://api.spotify.com/v1/albums/4dhjoNEwjKzRFE4AuRYFSV","id":"4dhjoNEwjKzRFE4AuRYFSV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335a30b58634baf0a81a0ede4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235a30b58634baf0a81a0ede4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135a30b58634baf0a81a0ede4"}],"is_playable":true,"name":"Alleen","release_date":"2017-06-23","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4dhjoNEwjKzRFE4AuRYFSV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":327851,"explicit":true,"external_ids":{"isrc":"NLG661700472"},"external_urls":{"spotify":"https://open.spotify.com/track/1wOLYsMBvJ2NOYSudRMTSo"},"href":"https://api.spotify.com/v1/tracks/1wOLYsMBvJ2NOYSudRMTSo","id":"1wOLYsMBvJ2NOYSudRMTSo","is_local":false,"is_playable":true,"name":"Gemaakt Voor Dit","track_number":16,"type":"track","uri":"spotify:track:1wOLYsMBvJ2NOYSudRMTSo"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6OL2KDr0EilFLoiuOrrC4G"},"href":"https://api.spotify.com/v1/albums/6OL2KDr0EilFLoiuOrrC4G","id":"6OL2KDr0EilFLoiuOrrC4G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e61ab3a6d9706cd68ae144e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e61ab3a6d9706cd68ae144e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e61ab3a6d9706cd68ae144e"}],"is_playable":true,"name":"F*CK KLEINE","release_date":"2026-04-02","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6OL2KDr0EilFLoiuOrrC4G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"disc_number":1,"duration_ms":187727,"explicit":true,"external_ids":{"isrc":"QMFME2505108"},"external_urls":{"spotify":"https://open.spotify.com/track/6Zr6hpVYyIPXgKS5aArRcO"},"href":"https://api.spotify.com/v1/tracks/6Zr6hpVYyIPXgKS5aArRcO","id":"6Zr6hpVYyIPXgKS5aArRcO","is_local":false,"is_playable":true,"name":"Boccaccio","track_number":17,"type":"track","uri":"spotify:track:6Zr6hpVYyIPXgKS5aArRcO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6OL2KDr0EilFLoiuOrrC4G"},"href":"https://api.spotify.com/v1/albums/6OL2KDr0EilFLoiuOrrC4G","id":"6OL2KDr0EilFLoiuOrrC4G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e61ab3a6d9706cd68ae144e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e61ab3a6d9706cd68ae144e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e61ab3a6d9706cd68ae144e"}],"is_playable":true,"name":"F*CK KLEINE","release_date":"2026-04-02","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6OL2KDr0EilFLoiuOrrC4G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":194221,"explicit":true,"external_ids":{"isrc":"QM4TX2653114"},"external_urls":{"spotify":"https://open.spotify.com/track/1DjVNyYZexRFY1tjzREqA0"},"href":"https://api.spotify.com/v1/tracks/1DjVNyYZexRFY1tjzREqA0","id":"1DjVNyYZexRFY1tjzREqA0","is_local":false,"is_playable":true,"name":"Psycholoog","track_number":5,"type":"track","uri":"spotify:track:1DjVNyYZexRFY1tjzREqA0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/3UaHayBJyD8YtRiJyQmAZd"},"href":"https://api.spotify.com/v1/albums/3UaHayBJyD8YtRiJyQmAZd","id":"3UaHayBJyD8YtRiJyQmAZd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731f509af5b07375b72da7cc06"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021f509af5b07375b72da7cc06"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511f509af5b07375b72da7cc06"}],"is_playable":true,"name":"WOP","release_date":"2016-02-12","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:3UaHayBJyD8YtRiJyQmAZd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"disc_number":1,"duration_ms":159600,"explicit":true,"external_ids":{"isrc":"NLG661600170"},"external_urls":{"spotify":"https://open.spotify.com/track/44PzVNxBDs0JaF2bSwNevo"},"href":"https://api.spotify.com/v1/tracks/44PzVNxBDs0JaF2bSwNevo","id":"44PzVNxBDs0JaF2bSwNevo","is_local":false,"is_playable":true,"name":"Niet Omdat Het Moet","track_number":6,"type":"track","uri":"spotify:track:44PzVNxBDs0JaF2bSwNevo"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"external_urls":{"spotify":"https://open.spotify.com/album/4mHejjXRui2KYLcgxX6lds"},"href":"https://api.spotify.com/v1/albums/4mHejjXRui2KYLcgxX6lds","id":"4mHejjXRui2KYLcgxX6lds","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27334378190dbe63db56d9c8099"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0234378190dbe63db56d9c8099"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485134378190dbe63db56d9c8099"}],"is_playable":true,"name":"Boccaccio","release_date":"2025-09-05","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:4mHejjXRui2KYLcgxX6lds"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"disc_number":1,"duration_ms":187727,"explicit":true,"external_ids":{"isrc":"QMFME2505108"},"external_urls":{"spotify":"https://open.spotify.com/track/5gmCeHtNMCGZvcxkoVD8JP"},"href":"https://api.spotify.com/v1/tracks/5gmCeHtNMCGZvcxkoVD8JP","id":"5gmCeHtNMCGZvcxkoVD8JP","is_local":false,"is_playable":true,"name":"Boccaccio","track_number":1,"type":"track","uri":"spotify:track:5gmCeHtNMCGZvcxkoVD8JP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"external_urls":{"spotify":"https://open.spotify.com/album/547F3ujAdycIX2OVnI7tkx"},"href":"https://api.spotify.com/v1/albums/547F3ujAdycIX2OVnI7tkx","id":"547F3ujAdycIX2OVnI7tkx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f14fc6b8ece75de45f5b0acb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f14fc6b8ece75de45f5b0acb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f14fc6b8ece75de45f5b0acb"}],"is_playable":true,"name":"R\u00e9mi","release_date":"2017-06-30","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:547F3ujAdycIX2OVnI7tkx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m1LYS5NQonxjOcQFPQOb5"},"href":"https://api.spotify.com/v1/artists/6m1LYS5NQonxjOcQFPQOb5","id":"6m1LYS5NQonxjOcQFPQOb5","name":"Frenna","type":"artist","uri":"spotify:artist:6m1LYS5NQonxjOcQFPQOb5"}],"disc_number":1,"duration_ms":165534,"explicit":false,"external_ids":{"isrc":"NLG661600769"},"external_urls":{"spotify":"https://open.spotify.com/track/1riPE3NCV1OBmSXqpYiMJY"},"href":"https://api.spotify.com/v1/tracks/1riPE3NCV1OBmSXqpYiMJY","id":"1riPE3NCV1OBmSXqpYiMJY","is_local":false,"is_playable":true,"name":"Energie","track_number":9,"type":"track","uri":"spotify:track:1riPE3NCV1OBmSXqpYiMJY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6OL2KDr0EilFLoiuOrrC4G"},"href":"https://api.spotify.com/v1/albums/6OL2KDr0EilFLoiuOrrC4G","id":"6OL2KDr0EilFLoiuOrrC4G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e61ab3a6d9706cd68ae144e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e61ab3a6d9706cd68ae144e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e61ab3a6d9706cd68ae144e"}],"is_playable":true,"name":"F*CK KLEINE","release_date":"2026-04-02","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6OL2KDr0EilFLoiuOrrC4G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1uUuCEXmWpKN2YLl5xSoT2"},"href":"https://api.spotify.com/v1/artists/1uUuCEXmWpKN2YLl5xSoT2","id":"1uUuCEXmWpKN2YLl5xSoT2","name":"$hirak","type":"artist","uri":"spotify:artist:1uUuCEXmWpKN2YLl5xSoT2"}],"disc_number":1,"duration_ms":134634,"explicit":true,"external_ids":{"isrc":"QMFMG2504754"},"external_urls":{"spotify":"https://open.spotify.com/track/2aRBX6c8bxydOK0hruE4NB"},"href":"https://api.spotify.com/v1/tracks/2aRBX6c8bxydOK0hruE4NB","id":"2aRBX6c8bxydOK0hruE4NB","is_local":false,"is_playable":true,"name":"Puinhoop","track_number":21,"type":"track","uri":"spotify:track:2aRBX6c8bxydOK0hruE4NB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"external_urls":{"spotify":"https://open.spotify.com/album/1zFQTPoaf4Xua3Cjv4rRGm"},"href":"https://api.spotify.com/v1/albums/1zFQTPoaf4Xua3Cjv4rRGm","id":"1zFQTPoaf4Xua3Cjv4rRGm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27301384276095e5892cf35dd3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0201384276095e5892cf35dd3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485101384276095e5892cf35dd3c"}],"is_playable":true,"name":"Joost Klein 7","release_date":"2020-04-24","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:1zFQTPoaf4Xua3Cjv4rRGm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"disc_number":1,"duration_ms":82857,"explicit":true,"external_ids":{"isrc":"QZDA82048493"},"external_urls":{"spotify":"https://open.spotify.com/track/11uimHI4Ppbkpk4ZYMmpxR"},"href":"https://api.spotify.com/v1/tracks/11uimHI4Ppbkpk4ZYMmpxR","id":"11uimHI4Ppbkpk4ZYMmpxR","is_local":false,"is_playable":true,"name":"Bee The Movie","track_number":3,"type":"track","uri":"spotify:track:11uimHI4Ppbkpk4ZYMmpxR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5P65bxTP4Bq4f6EBhsuSMU"},"href":"https://api.spotify.com/v1/albums/5P65bxTP4Bq4f6EBhsuSMU","id":"5P65bxTP4Bq4f6EBhsuSMU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b119107aff5297e2a47f5094"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b119107aff5297e2a47f5094"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b119107aff5297e2a47f5094"}],"is_playable":true,"name":"Best Of The 10s: Party Hits","release_date":"2021-04-06","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:5P65bxTP4Bq4f6EBhsuSMU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m1LYS5NQonxjOcQFPQOb5"},"href":"https://api.spotify.com/v1/artists/6m1LYS5NQonxjOcQFPQOb5","id":"6m1LYS5NQonxjOcQFPQOb5","name":"Frenna","type":"artist","uri":"spotify:artist:6m1LYS5NQonxjOcQFPQOb5"}],"disc_number":1,"duration_ms":165534,"explicit":false,"external_ids":{"isrc":"NLG661600769"},"external_urls":{"spotify":"https://open.spotify.com/track/1M8ZjEMLnaWfX4FGtvwBDx"},"href":"https://api.spotify.com/v1/tracks/1M8ZjEMLnaWfX4FGtvwBDx","id":"1M8ZjEMLnaWfX4FGtvwBDx","is_local":false,"is_playable":true,"name":"Energie","track_number":12,"type":"track","uri":"spotify:track:1M8ZjEMLnaWfX4FGtvwBDx"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Blijven%20Slapen%20Lil%20Kleine&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Blijven%20Slapen%20Lil%20Kleine&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/4dhjoNEwjKzRFE4AuRYFSV"},"href":"https://api.spotify.com/v1/albums/4dhjoNEwjKzRFE4AuRYFSV","id":"4dhjoNEwjKzRFE4AuRYFSV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335a30b58634baf0a81a0ede4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235a30b58634baf0a81a0ede4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135a30b58634baf0a81a0ede4"}],"is_playable":true,"name":"Alleen","release_date":"2017-06-23","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4dhjoNEwjKzRFE4AuRYFSV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":139748,"explicit":true,"external_ids":{"isrc":"NLG661700443"},"external_urls":{"spotify":"https://open.spotify.com/track/3hj0Rahf7SOplXTxfGjUu3"},"href":"https://api.spotify.com/v1/tracks/3hj0Rahf7SOplXTxfGjUu3","id":"3hj0Rahf7SOplXTxfGjUu3","is_local":false,"is_playable":true,"name":"Volume","track_number":1,"type":"track","uri":"spotify:track:3hj0Rahf7SOplXTxfGjUu3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/4dhjoNEwjKzRFE4AuRYFSV"},"href":"https://api.spotify.com/v1/albums/4dhjoNEwjKzRFE4AuRYFSV","id":"4dhjoNEwjKzRFE4AuRYFSV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335a30b58634baf0a81a0ede4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235a30b58634baf0a81a0ede4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135a30b58634baf0a81a0ede4"}],"is_playable":true,"name":"Alleen","release_date":"2017-06-23","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4dhjoNEwjKzRFE4AuRYFSV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":327851,"explicit":true,"external_ids":{"isrc":"NLG661700472"},"external_urls":{"spotify":"https://open.spotify.com/track/1wOLYsMBvJ2NOYSudRMTSo"},"href":"https://api.spotify.com/v1/tracks/1wOLYsMBvJ2NOYSudRMTSo","id":"1wOLYsMBvJ2NOYSudRMTSo","is_local":false,"is_playable":true,"name":"Gemaakt Voor Dit","track_number":16,"type":"track","uri":"spotify:track:1wOLYsMBvJ2NOYSudRMTSo"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6OL2KDr0EilFLoiuOrrC4G"},"href":"https://api.spotify.com/v1/albums/6OL2KDr0EilFLoiuOrrC4G","id":"6OL2KDr0EilFLoiuOrrC4G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e61ab3a6d9706cd68ae144e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e61ab3a6d9706cd68ae144e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e61ab3a6d9706cd68ae144e"}],"is_playable":true,"name":"F*CK KLEINE","release_date":"2026-04-02","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6OL2KDr0EilFLoiuOrrC4G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"disc_number":1,"duration_ms":187727,"explicit":true,"external_ids":{"isrc":"QMFME2505108"},"external_urls":{"spotify":"https://open.spotify.com/track/6Zr6hpVYyIPXgKS5aArRcO"},"href":"https://api.spotify.com/v1/tracks/6Zr6hpVYyIPXgKS5aArRcO","id":"6Zr6hpVYyIPXgKS5aArRcO","is_local":false,"is_playable":true,"name":"Boccaccio","track_number":17,"type":"track","uri":"spotify:track:6Zr6hpVYyIPXgKS5aArRcO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6OL2KDr0EilFLoiuOrrC4G"},"href":"https://api.spotify.com/v1/albums/6OL2KDr0EilFLoiuOrrC4G","id":"6OL2KDr0EilFLoiuOrrC4G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e61ab3a6d9706cd68ae144e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e61ab3a6d9706cd68ae144e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e61ab3a6d9706cd68ae144e"}],"is_playable":true,"name":"F*CK KLEINE","release_date":"2026-04-02","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6OL2KDr0EilFLoiuOrrC4G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":194221,"explicit":true,"external_ids":{"isrc":"QM4TX2653114"},"external_urls":{"spotify":"https://open.spotify.com/track/1DjVNyYZexRFY1tjzREqA0"},"href":"https://api.spotify.com/v1/tracks/1DjVNyYZexRFY1tjzREqA0","id":"1DjVNyYZexRFY1tjzREqA0","is_local":false,"is_playable":true,"name":"Psycholoog","track_number":5,"type":"track","uri":"spotify:track:1DjVNyYZexRFY1tjzREqA0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/3UaHayBJyD8YtRiJyQmAZd"},"href":"https://api.spotify.com/v1/albums/3UaHayBJyD8YtRiJyQmAZd","id":"3UaHayBJyD8YtRiJyQmAZd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731f509af5b07375b72da7cc06"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021f509af5b07375b72da7cc06"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511f509af5b07375b72da7cc06"}],"is_playable":true,"name":"WOP","release_date":"2016-02-12","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:3UaHayBJyD8YtRiJyQmAZd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"disc_number":1,"duration_ms":159600,"explicit":true,"external_ids":{"isrc":"NLG661600170"},"external_urls":{"spotify":"https://open.spotify.com/track/44PzVNxBDs0JaF2bSwNevo"},"href":"https://api.spotify.com/v1/tracks/44PzVNxBDs0JaF2bSwNevo","id":"44PzVNxBDs0JaF2bSwNevo","is_local":false,"is_playable":true,"name":"Niet Omdat Het Moet","track_number":6,"type":"track","uri":"spotify:track:44PzVNxBDs0JaF2bSwNevo"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"external_urls":{"spotify":"https://open.spotify.com/album/4mHejjXRui2KYLcgxX6lds"},"href":"https://api.spotify.com/v1/albums/4mHejjXRui2KYLcgxX6lds","id":"4mHejjXRui2KYLcgxX6lds","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27334378190dbe63db56d9c8099"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0234378190dbe63db56d9c8099"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485134378190dbe63db56d9c8099"}],"is_playable":true,"name":"Boccaccio","release_date":"2025-09-05","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:4mHejjXRui2KYLcgxX6lds"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"disc_number":1,"duration_ms":187727,"explicit":true,"external_ids":{"isrc":"QMFME2505108"},"external_urls":{"spotify":"https://open.spotify.com/track/5gmCeHtNMCGZvcxkoVD8JP"},"href":"https://api.spotify.com/v1/tracks/5gmCeHtNMCGZvcxkoVD8JP","id":"5gmCeHtNMCGZvcxkoVD8JP","is_local":false,"is_playable":true,"name":"Boccaccio","track_number":1,"type":"track","uri":"spotify:track:5gmCeHtNMCGZvcxkoVD8JP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"external_urls":{"spotify":"https://open.spotify.com/album/547F3ujAdycIX2OVnI7tkx"},"href":"https://api.spotify.com/v1/albums/547F3ujAdycIX2OVnI7tkx","id":"547F3ujAdycIX2OVnI7tkx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f14fc6b8ece75de45f5b0acb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f14fc6b8ece75de45f5b0acb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f14fc6b8ece75de45f5b0acb"}],"is_playable":true,"name":"R\u00e9mi","release_date":"2017-06-30","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:547F3ujAdycIX2OVnI7tkx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m1LYS5NQonxjOcQFPQOb5"},"href":"https://api.spotify.com/v1/artists/6m1LYS5NQonxjOcQFPQOb5","id":"6m1LYS5NQonxjOcQFPQOb5","name":"Frenna","type":"artist","uri":"spotify:artist:6m1LYS5NQonxjOcQFPQOb5"}],"disc_number":1,"duration_ms":165534,"explicit":false,"external_ids":{"isrc":"NLG661600769"},"external_urls":{"spotify":"https://open.spotify.com/track/1riPE3NCV1OBmSXqpYiMJY"},"href":"https://api.spotify.com/v1/tracks/1riPE3NCV1OBmSXqpYiMJY","id":"1riPE3NCV1OBmSXqpYiMJY","is_local":false,"is_playable":true,"name":"Energie","track_number":9,"type":"track","uri":"spotify:track:1riPE3NCV1OBmSXqpYiMJY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6OL2KDr0EilFLoiuOrrC4G"},"href":"https://api.spotify.com/v1/albums/6OL2KDr0EilFLoiuOrrC4G","id":"6OL2KDr0EilFLoiuOrrC4G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e61ab3a6d9706cd68ae144e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e61ab3a6d9706cd68ae144e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e61ab3a6d9706cd68ae144e"}],"is_playable":true,"name":"F*CK KLEINE","release_date":"2026-04-02","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6OL2KDr0EilFLoiuOrrC4G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1uUuCEXmWpKN2YLl5xSoT2"},"href":"https://api.spotify.com/v1/artists/1uUuCEXmWpKN2YLl5xSoT2","id":"1uUuCEXmWpKN2YLl5xSoT2","name":"$hirak","type":"artist","uri":"spotify:artist:1uUuCEXmWpKN2YLl5xSoT2"}],"disc_number":1,"duration_ms":134634,"explicit":true,"external_ids":{"isrc":"QMFMG2504754"},"external_urls":{"spotify":"https://open.spotify.com/track/2aRBX6c8bxydOK0hruE4NB"},"href":"https://api.spotify.com/v1/tracks/2aRBX6c8bxydOK0hruE4NB","id":"2aRBX6c8bxydOK0hruE4NB","is_local":false,"is_playable":true,"name":"Puinhoop","track_number":21,"type":"track","uri":"spotify:track:2aRBX6c8bxydOK0hruE4NB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"external_urls":{"spotify":"https://open.spotify.com/album/1zFQTPoaf4Xua3Cjv4rRGm"},"href":"https://api.spotify.com/v1/albums/1zFQTPoaf4Xua3Cjv4rRGm","id":"1zFQTPoaf4Xua3Cjv4rRGm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27301384276095e5892cf35dd3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0201384276095e5892cf35dd3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485101384276095e5892cf35dd3c"}],"is_playable":true,"name":"Joost Klein 7","release_date":"2020-04-24","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:1zFQTPoaf4Xua3Cjv4rRGm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"disc_number":1,"duration_ms":82857,"explicit":true,"external_ids":{"isrc":"QZDA82048493"},"external_urls":{"spotify":"https://open.spotify.com/track/11uimHI4Ppbkpk4ZYMmpxR"},"href":"https://api.spotify.com/v1/tracks/11uimHI4Ppbkpk4ZYMmpxR","id":"11uimHI4Ppbkpk4ZYMmpxR","is_local":false,"is_playable":true,"name":"Bee The Movie","track_number":3,"type":"track","uri":"spotify:track:11uimHI4Ppbkpk4ZYMmpxR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5P65bxTP4Bq4f6EBhsuSMU"},"href":"https://api.spotify.com/v1/albums/5P65bxTP4Bq4f6EBhsuSMU","id":"5P65bxTP4Bq4f6EBhsuSMU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b119107aff5297e2a47f5094"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b119107aff5297e2a47f5094"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b119107aff5297e2a47f5094"}],"is_playable":true,"name":"Best Of The 10s: Party Hits","release_date":"2021-04-06","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:5P65bxTP4Bq4f6EBhsuSMU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m1LYS5NQonxjOcQFPQOb5"},"href":"https://api.spotify.com/v1/artists/6m1LYS5NQonxjOcQFPQOb5","id":"6m1LYS5NQonxjOcQFPQOb5","name":"Frenna","type":"artist","uri":"spotify:artist:6m1LYS5NQonxjOcQFPQOb5"}],"disc_number":1,"duration_ms":165534,"explicit":false,"external_ids":{"isrc":"NLG661600769"},"external_urls":{"spotify":"https://open.spotify.com/track/1M8ZjEMLnaWfX4FGtvwBDx"},"href":"https://api.spotify.com/v1/tracks/1M8ZjEMLnaWfX4FGtvwBDx","id":"1M8ZjEMLnaWfX4FGtvwBDx","is_local":false,"is_playable":true,"name":"Energie","track_number":12,"type":"track","uri":"spotify:track:1M8ZjEMLnaWfX4FGtvwBDx"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Blijven+Slapen+Lil+Kleine&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=1Op1%20Boef&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Jsk5iYMr5aNjHury7blm1"},"href":"https://api.spotify.com/v1/artists/0Jsk5iYMr5aNjHury7blm1","id":"0Jsk5iYMr5aNjHury7blm1","name":"Boef","type":"artist","uri":"spotify:artist:0Jsk5iYMr5aNjHury7blm1"}],"external_urls":{"spotify":"https://open.spotify.com/album/1T0JEcvh5galHqAeaiHXWN"},"href":"https://api.spotify.com/v1/albums/1T0JEcvh5galHqAeaiHXWN","id":"1T0JEcvh5galHqAeaiHXWN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e90e2b58ac869b5671117acd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e90e2b58ac869b5671117acd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e90e2b58ac869b5671117acd"}],"is_playable":true,"name":"Paperchase","release_date":"2016-11-06","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1T0JEcvh5galHqAeaiHXWN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Jsk5iYMr5aNjHury7blm1"},"href":"https://api.spotify.com/v1/artists/0Jsk5iYMr5aNjHury7blm1","id":"0Jsk5iYMr5aNjHury7blm1","name":"Boef","type":"artist","uri":"spotify:artist:0Jsk5iYMr5aNjHury7blm1"}],"disc_number":1,"duration_ms":180000,"explicit":true,"external_ids":{"isrc":"NLRU91650095"},"external_urls":{"spotify":"https://open.spotify.com/track/2VmBW1QwluqhUKTJdHWM6m"},"href":"https://api.spotify.com/v1/tracks/2VmBW1QwluqhUKTJdHWM6m","id":"2VmBW1QwluqhUKTJdHWM6m","is_local":false,"is_playable":true,"name":"Paperchase","track_number":1,"type":"track","uri":"spotify:track:2VmBW1QwluqhUKTJdHWM6m"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Jsk5iYMr5aNjHury7blm1"},"href":"https://api.spotify.com/v1/artists/0Jsk5iYMr5aNjHury7blm1","id":"0Jsk5iYMr5aNjHury7blm1","name":"Boef","type":"artist","uri":"spotify:artist:0Jsk5iYMr5aNjHury7blm1"}],"external_urls":{"spotify":"https://open.spotify.com/album/62mwenWca7ZVvsUFaHYNwu"},"href":"https://api.spotify.com/v1/albums/62mwenWca7ZVvsUFaHYNwu","id":"62mwenWca7ZVvsUFaHYNwu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a28093f10f28e9d449f0732a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a28093f10f28e9d449f0732a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a28093f10f28e9d449f0732a"}],"is_playable":true,"name":"Slaaptekort","release_date":"2017-03-17","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:62mwenWca7ZVvsUFaHYNwu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Jsk5iYMr5aNjHury7blm1"},"href":"https://api.spotify.com/v1/artists/0Jsk5iYMr5aNjHury7blm1","id":"0Jsk5iYMr5aNjHury7blm1","name":"Boef","type":"artist","uri":"spotify:artist:0Jsk5iYMr5aNjHury7blm1"}],"disc_number":1,"duration_ms":221935,"explicit":true,"external_ids":{"isrc":"NLMM21700003"},"external_urls":{"spotify":"https://open.spotify.com/track/6JEdbFSIuOI4P67EwomHu8"},"href":"https://api.spotify.com/v1/tracks/6JEdbFSIuOI4P67EwomHu8","id":"6JEdbFSIuOI4P67EwomHu8","is_local":false,"is_playable":true,"name":"Range Sessie","track_number":1,"type":"track","uri":"spotify:track:6JEdbFSIuOI4P67EwomHu8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Jsk5iYMr5aNjHury7blm1"},"href":"https://api.spotify.com/v1/artists/0Jsk5iYMr5aNjHury7blm1","id":"0Jsk5iYMr5aNjHury7blm1","name":"Boef","type":"artist","uri":"spotify:artist:0Jsk5iYMr5aNjHury7blm1"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tEjoImmdtJeQVYQx9Ogy4"},"href":"https://api.spotify.com/v1/albums/5tEjoImmdtJeQVYQx9Ogy4","id":"5tEjoImmdtJeQVYQx9Ogy4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f975b7fec0fa147427048f5c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f975b7fec0fa147427048f5c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f975b7fec0fa147427048f5c"}],"is_playable":true,"name":"93","release_date":"2019-01-11","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5tEjoImmdtJeQVYQx9Ogy4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0Jsk5iYMr5aNjHury7blm1"},"href":"https://api.spotify.com/v1/artists/0Jsk5iYMr5aNjHury7blm1","id":"0Jsk5iYMr5aNjHury7blm1","name":"Boef","type":"artist","uri":"spotify:artist:0Jsk5iYMr5aNjHury7blm1"}],"disc_number":1,"duration_ms":125378,"explicit":true,"external_ids":{"isrc":"NLX1N1800003"},"external_urls":{"spotify":"https://open.spotify.com/track/6CqtQmIlpBJNvbcZD7mLOZ"},"href":"https://api.spotify.com/v1/tracks/6CqtQmIlpBJNvbcZD7mLOZ","id":"6CqtQmIlpBJNvbcZD7mLOZ","is_local":false,"is_playable":true,"name":"Rolls Sessie","track_number":9,"type":"track","uri":"spotify:track:6CqtQmIlpBJNvbcZD7mLOZ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6J2bFI9tQDWfPHjoKHKrOu"},"href":"https://api.spotify.com/v1/artists/6J2bFI9tQDWfPHjoKHKrOu","id":"6J2bFI9tQDWfPHjoKHKrOu","name":"Yung Felix","type":"artist","uri":"spotify:artist:6J2bFI9tQDWfPHjoKHKrOu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/10Tmpcwo1bS6hnYOBI1Gip"},"href":"https://api.spotify.com/v1/artists/10Tmpcwo1bS6hnYOBI1Gip","id":"10Tmpcwo1bS6hnYOBI1Gip","name":"Oomto","type":"artist","uri":"spotify:artist:10Tmpcwo1bS6hnYOBI1Gip"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4dgbnJmnTFDiJiKloaWH2p"},"href":"https://api.spotify.com/v1/artists/4dgbnJmnTFDiJiKloaWH2p","id":"4dgbnJmnTFDiJiKloaWH2p","name":"GP UIT G","type":"artist","uri":"spotify:artist:4dgbnJmnTFDiJiKloaWH2p"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OvGpYbVACth6puRrgGMo0"},"href":"https://api.spotify.com/v1/albums/0OvGpYbVACth6puRrgGMo0","id":"0OvGpYbVACth6puRrgGMo0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bb7b3a88423a0599b8bd35c1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bb7b3a88423a0599b8bd35c1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bb7b3a88423a0599b8bd35c1"}],"is_playable":true,"name":"Baff Baff","release_date":"2026-07-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0OvGpYbVACth6puRrgGMo0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6J2bFI9tQDWfPHjoKHKrOu"},"href":"https://api.spotify.com/v1/artists/6J2bFI9tQDWfPHjoKHKrOu","id":"6J2bFI9tQDWfPHjoKHKrOu","name":"Yung Felix","type":"artist","uri":"spotify:artist:6J2bFI9tQDWfPHjoKHKrOu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/10Tmpcwo1bS6hnYOBI1Gip"},"href":"https://api.spotify.com/v1/artists/10Tmpcwo1bS6hnYOBI1Gip","id":"10Tmpcwo1bS6hnYOBI1Gip","name":"Oomto","type":"artist","uri":"spotify:artist:10Tmpcwo1bS6hnYOBI1Gip"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4dgbnJmnTFDiJiKloaWH2p"},"href":"https://api.spotify.com/v1/artists/4dgbnJmnTFDiJiKloaWH2p","id":"4dgbnJmnTFDiJiKloaWH2p","name":"GP UIT G","type":"artist","uri":"spotify:artist:4dgbnJmnTFDiJiKloaWH2p"}],"disc_number":1,"duration_ms":161379,"explicit":true,"external_ids":{"isrc":"NLG662600341"},"external_urls":{"spotify":"https://open.spotify.com/track/5E57anFYCRW3jQdgiGnMsk"},"href":"https://api.spotify.com/v1/tracks/5E57anFYCRW3jQdgiGnMsk","id":"5E57anFYCRW3jQdgiGnMsk","is_local":false,"is_playable":true,"name":"Baff Baff","track_number":1,"type":"track","uri":"spotify:track:5E57anFYCRW3jQdgiGnMsk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3HL2hJ9MmM9eazDokIndkr"},"href":"https://api.spotify.com/v1/artists/3HL2hJ9MmM9eazDokIndkr","id":"3HL2hJ9MmM9eazDokIndkr","name":"SBMG","type":"artist","uri":"spotify:artist:3HL2hJ9MmM9eazDokIndkr"}],"external_urls":{"spotify":"https://open.spotify.com/album/4U7fHezhSTb9KhYI32Ct5W"},"href":"https://api.spotify.com/v1/albums/4U7fHezhSTb9KhYI32Ct5W","id":"4U7fHezhSTb9KhYI32Ct5W","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e6399b64b9f5472822f879d6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e6399b64b9f5472822f879d6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e6399b64b9f5472822f879d6"}],"is_playable":true,"name":"Metro 53","release_date":"2018-06-22","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4U7fHezhSTb9KhYI32Ct5W"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3HL2hJ9MmM9eazDokIndkr"},"href":"https://api.spotify.com/v1/artists/3HL2hJ9MmM9eazDokIndkr","id":"3HL2hJ9MmM9eazDokIndkr","name":"SBMG","type":"artist","uri":"spotify:artist:3HL2hJ9MmM9eazDokIndkr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0Jsk5iYMr5aNjHury7blm1"},"href":"https://api.spotify.com/v1/artists/0Jsk5iYMr5aNjHury7blm1","id":"0Jsk5iYMr5aNjHury7blm1","name":"Boef","type":"artist","uri":"spotify:artist:0Jsk5iYMr5aNjHury7blm1"}],"disc_number":1,"duration_ms":204410,"explicit":true,"external_ids":{"isrc":"NLG661800595"},"external_urls":{"spotify":"https://open.spotify.com/track/76OfzNtY3nG5hCnh5COSjt"},"href":"https://api.spotify.com/v1/tracks/76OfzNtY3nG5hCnh5COSjt","id":"76OfzNtY3nG5hCnh5COSjt","is_local":false,"is_playable":true,"name":"LIT","track_number":7,"type":"track","uri":"spotify:track:76OfzNtY3nG5hCnh5COSjt"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6hULvykQR9LihkMxU8379M"},"href":"https://api.spotify.com/v1/artists/6hULvykQR9LihkMxU8379M","id":"6hULvykQR9LihkMxU8379M","name":"BeegPapi18","type":"artist","uri":"spotify:artist:6hULvykQR9LihkMxU8379M"}],"external_urls":{"spotify":"https://open.spotify.com/album/1cle6nq1c5icI3lQqTBRrH"},"href":"https://api.spotify.com/v1/albums/1cle6nq1c5icI3lQqTBRrH","id":"1cle6nq1c5icI3lQqTBRrH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273da0f9402c85748e5e17ae0d9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02da0f9402c85748e5e17ae0d9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851da0f9402c85748e5e17ae0d9"}],"is_playable":true,"name":"Studiosessie 343 - 101barz","release_date":"2024-01-08","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:1cle6nq1c5icI3lQqTBRrH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6hULvykQR9LihkMxU8379M"},"href":"https://api.spotify.com/v1/artists/6hULvykQR9LihkMxU8379M","id":"6hULvykQR9LihkMxU8379M","name":"BeegPapi18","type":"artist","uri":"spotify:artist:6hULvykQR9LihkMxU8379M"}],"disc_number":1,"duration_ms":267915,"explicit":true,"external_ids":{"isrc":"TCAHT2461479"},"external_urls":{"spotify":"https://open.spotify.com/track/0fEa0QSu5jt7T4CDnxt6p6"},"href":"https://api.spotify.com/v1/tracks/0fEa0QSu5jt7T4CDnxt6p6","id":"0fEa0QSu5jt7T4CDnxt6p6","is_local":false,"is_playable":true,"name":"Studiosessie 343, Pt. 1","track_number":1,"type":"track","uri":"spotify:track:0fEa0QSu5jt7T4CDnxt6p6"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IA4SdCS8HBDX6oBoOlgaf"},"href":"https://api.spotify.com/v1/artists/0IA4SdCS8HBDX6oBoOlgaf","id":"0IA4SdCS8HBDX6oBoOlgaf","name":"F1rstman","type":"artist","uri":"spotify:artist:0IA4SdCS8HBDX6oBoOlgaf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0Jsk5iYMr5aNjHury7blm1"},"href":"https://api.spotify.com/v1/artists/0Jsk5iYMr5aNjHury7blm1","id":"0Jsk5iYMr5aNjHury7blm1","name":"Boef","type":"artist","uri":"spotify:artist:0Jsk5iYMr5aNjHury7blm1"}],"external_urls":{"spotify":"https://open.spotify.com/album/7C5iaQAlPVjxtGnlbWswqx"},"href":"https://api.spotify.com/v1/albums/7C5iaQAlPVjxtGnlbWswqx","id":"7C5iaQAlPVjxtGnlbWswqx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735ae2521b73f023f458e7b7d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025ae2521b73f023f458e7b7d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515ae2521b73f023f458e7b7d7"}],"is_playable":true,"name":"Overal (feat. DJ Youss-F)","release_date":"2016-11-04","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7C5iaQAlPVjxtGnlbWswqx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IA4SdCS8HBDX6oBoOlgaf"},"href":"https://api.spotify.com/v1/artists/0IA4SdCS8HBDX6oBoOlgaf","id":"0IA4SdCS8HBDX6oBoOlgaf","name":"F1rstman","type":"artist","uri":"spotify:artist:0IA4SdCS8HBDX6oBoOlgaf"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0Jsk5iYMr5aNjHury7blm1"},"href":"https://api.spotify.com/v1/artists/0Jsk5iYMr5aNjHury7blm1","id":"0Jsk5iYMr5aNjHury7blm1","name":"Boef","type":"artist","uri":"spotify:artist:0Jsk5iYMr5aNjHury7blm1"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5DP8uQLYvY07JGJvtVklwV"},"href":"https://api.spotify.com/v1/artists/5DP8uQLYvY07JGJvtVklwV","id":"5DP8uQLYvY07JGJvtVklwV","name":"DJ Youss-F","type":"artist","uri":"spotify:artist:5DP8uQLYvY07JGJvtVklwV"}],"disc_number":1,"duration_ms":182970,"explicit":false,"external_ids":{"isrc":"NLQ4B1600001"},"external_urls":{"spotify":"https://open.spotify.com/track/7bQQ2B4EVLDiMA79EbT2qe"},"href":"https://api.spotify.com/v1/tracks/7bQQ2B4EVLDiMA79EbT2qe","id":"7bQQ2B4EVLDiMA79EbT2qe","is_local":false,"is_playable":true,"name":"Overal (feat. DJ Youss-F)","track_number":1,"type":"track","uri":"spotify:track:7bQQ2B4EVLDiMA79EbT2qe"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6hULvykQR9LihkMxU8379M"},"href":"https://api.spotify.com/v1/artists/6hULvykQR9LihkMxU8379M","id":"6hULvykQR9LihkMxU8379M","name":"BeegPapi18","type":"artist","uri":"spotify:artist:6hULvykQR9LihkMxU8379M"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ybutZsZmZ8ccyLBcKGsJZ"},"href":"https://api.spotify.com/v1/albums/4ybutZsZmZ8ccyLBcKGsJZ","id":"4ybutZsZmZ8ccyLBcKGsJZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d1e71e122353c83335ec460d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d1e71e122353c83335ec460d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d1e71e122353c83335ec460d"}],"is_playable":true,"name":"Nass Studiosessie","release_date":"2023-09-25","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:4ybutZsZmZ8ccyLBcKGsJZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6hULvykQR9LihkMxU8379M"},"href":"https://api.spotify.com/v1/artists/6hULvykQR9LihkMxU8379M","id":"6hULvykQR9LihkMxU8379M","name":"BeegPapi18","type":"artist","uri":"spotify:artist:6hULvykQR9LihkMxU8379M"}],"disc_number":1,"duration_ms":327889,"explicit":false,"external_ids":{"isrc":"TCAHL2380820"},"external_urls":{"spotify":"https://open.spotify.com/track/0g7PuUOwDt9hNYoNMxgWeM"},"href":"https://api.spotify.com/v1/tracks/0g7PuUOwDt9hNYoNMxgWeM","id":"0g7PuUOwDt9hNYoNMxgWeM","is_local":false,"is_playable":true,"name":"Studiosessie 425 101barz","track_number":2,"type":"track","uri":"spotify:track:0g7PuUOwDt9hNYoNMxgWeM"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT0xT3AxJTIwQm9lZiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsImlkIjoiMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsIm5hbWUiOiJCb2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xVDBKRWN2aDVnYWxIcUFlYWlIWFdOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVQwSkVjdmg1Z2FsSHFBZWFpSFhXTiIsImlkIjoiMVQwSkVjdmg1Z2FsSHFBZWFpSFhXTiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlOTBlMmI1OGFjODY5YjU2NzExMTdhY2QifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTkwZTJiNThhYzg2OWI1NjcxMTE3YWNkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlOTBlMmI1OGFjODY5YjU2NzExMTdhY2QifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUGFwZXJjaGFzZSIsInJlbGVhc2VfZGF0ZSI6IjIwMTYtMTEtMDYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFUMEpFY3ZoNWdhbEhxQWVhaUhYV04ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wSnNrNWlZTXI1YU5qSHVyeTdibG0xIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEiLCJpZCI6IjBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEiLCJuYW1lIjoiQm9lZiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5Og==", + "YXJ0aXN0OjBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTgwMDAwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFJVOTE2NTAwOTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJWbUJXMVF3bHVxaFVLVEpkSFdNNm0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yVm1CVzFRd2x1cWhVS1RKZEhXTTZtIiwiaWQiOiIyVm1CVzFRd2x1cWhVS1RKZEhXTTZtIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBhcGVyY2hhc2UiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MlZtQlcxUXdsdXFoVUtUSmRIV002bSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wSnNrNWlZTXI1YU5qSHVyeTdibG0xIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEiLCJpZCI6IjBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEiLCJuYW1lIjoiQm9lZiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowSnNrNWlZTXI1YU5qSHVyeTdibG0xIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNjJtd2VuV2NhN1pWdnNVRmFIWU53dSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzYybXdlbldjYTdaVnZzVUZhSFlOd3UiLCJpZCI6IjYybXdlbldjYTdaVnZzVUZhSFlOd3UiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTI4MDkzZjEwZjI4ZTlkNDQ5ZjA3MzJhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEyODA5M2YxMGYyOGU5ZDQ0OWYwNzMyYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTI4MDkzZjEwZjI4ZTlkNDQ5ZjA3MzJhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNsYWFwdGVrb3J0IiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wMy0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5Og==", + "YWxidW06NjJtd2VuV2NhN1pWdnNVRmFIWU53dSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsImlkIjoiMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsIm5hbWUiOiJCb2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjIxOTM1LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTE1NMjE3MDAwMDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZKRWRiRlNJdU9JNFA2N0V3b21IdTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82SkVkYkZTSXVPSTRQNjdFd29tSHU4IiwiaWQiOiI2SkVkYkZTSXVPSTRQNjdFd29tSHU4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJhbmdlIFNlc3NpZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2SkVkYkZTSXVPSTRQNjdFd29tSHU4In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsImlkIjoiMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsIm5hbWUiOiJCb2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81dEVqb0ltbWR0SmVRVllReDlPZ3k0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNXRFam9JbW1kdEplUVZZUXg5T2d5NCIsImlkIjoiNXRFam9JbW1kdEplUVZZUXg5T2d5NCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmOTc1YjdmZWMwZmExNDc0MjcwNDhmNWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZg==", + "OTc1YjdmZWMwZmExNDc0MjcwNDhmNWMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWY5NzViN2ZlYzBmYTE0NzQyNzA0OGY1YyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiI5MyIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDEtMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1dEVqb0ltbWR0SmVRVllReDlPZ3k0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEpzazVpWU1yNWFOakh1cnk3YmxtMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wSnNrNWlZTXI1YU5qSHVyeTdibG0xIiwiaWQiOiIwSnNrNWlZTXI1YU5qSHVyeTdibG0xIiwibmFtZSI6IkJvZWYiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEpzazVpWU1yNWFOakh1cnk3YmxtMSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxMjUzNzgsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MWDFOMTgwMDAwMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNkNxdFFtSWxwQkpOdmJjWkQ3bUxPWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZDcXRRbUlscEJKTnZiY1pEN21MT1oiLCJpZCI6IjZDcXRRbUlscEJKTnZiY1pEN21MT1oiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm9sbHMgU2Vzc2llIiwidHJhY2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZDcXRRbUlscEJKTnZiY1pEN21MT1oifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZKMmJGSTl0UURXZlBIam9LSEtyT3UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkoyYkZJOXRRRFdmUEhqb0tIS3JPdSIsImlkIjoiNkoyYkZJOXRRRFdmUEhqb0tIS3JPdSIsIm5hbWUiOiJZdW5nIEZlbGl4IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZKMmJGSTl0UURXZlBIam9LSEtyT3UifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTBUbXBjd28xYlM2aG5ZT0JJMUdpcCJ9LCJocmVmIjoiaA==", + "dHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzEwVG1wY3dvMWJTNmhuWU9CSTFHaXAiLCJpZCI6IjEwVG1wY3dvMWJTNmhuWU9CSTFHaXAiLCJuYW1lIjoiT29tdG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTBUbXBjd28xYlM2aG5ZT0JJMUdpcCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80ZGdibkptblRGRGlKaUtsb2FXSDJwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRkZ2JuSm1uVEZEaUppS2xvYVdIMnAiLCJpZCI6IjRkZ2JuSm1uVEZEaUppS2xvYVdIMnAiLCJuYW1lIjoiR1AgVUlUIEciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGRnYm5KbW5URkRpSmlLbG9hV0gycCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBPdkdwWWJWQUN0aDZwdVJyZ0dNbzAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wT3ZHcFliVkFDdGg2cHVScmdHTW8wIiwiaWQiOiIwT3ZHcFliVkFDdGg2cHVScmdHTW8wIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2JiN2IzYTg4NDIzYTA1OTliOGJkMzVjMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiYjdiM2E4ODQyM2EwNTk5YjhiZDM1YzEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWJiN2IzYTg4NDIzYTA1OTliOGJkMzVjMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCYWZmIEJhZmYiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA3LTMwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowT3ZHcFliVkFDdGg2cHVScmdHTW8wIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkoyYkZJOXRRRFdmUEhqb0tIS3JPdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82SjJiRkk5dFFEV2ZQSGpvS0hLck91IiwiaWQiOiI2SjJiRkk5dFFEV2ZQSGpvS0hLck91IiwibmFtZSI6Ill1bmcgRmVsaXgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkoyYkZJOXRRRFdmUEhqb0tIS3JPdSJ9LHsiZXh0ZQ==", + "cm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzEwVG1wY3dvMWJTNmhuWU9CSTFHaXAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTBUbXBjd28xYlM2aG5ZT0JJMUdpcCIsImlkIjoiMTBUbXBjd28xYlM2aG5ZT0JJMUdpcCIsIm5hbWUiOiJPb210byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxMFRtcGN3bzFiUzZobllPQkkxR2lwIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRkZ2JuSm1uVEZEaUppS2xvYVdIMnAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGRnYm5KbW5URkRpSmlLbG9hV0gycCIsImlkIjoiNGRnYm5KbW5URkRpSmlLbG9hV0gycCIsIm5hbWUiOiJHUCBVSVQgRyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0ZGdibkptblRGRGlKaUtsb2FXSDJwIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2MTM3OSwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyNjAwMzQxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81RTU3YW5GWUNSVzNqUWRnaUduTXNrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUU1N2FuRllDUlczalFkZ2lHbk1zayIsImlkIjoiNUU1N2FuRllDUlczalFkZ2lHbk1zayIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCYWZmIEJhZmYiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUU1N2FuRllDUlczalFkZ2lHbk1zayJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zSEwyaEo5TW1NOWVhekRva0luZGtyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNITDJoSjlNbU05ZWF6RG9rSW5ka3IiLCJpZCI6IjNITDJoSjlNbU05ZWF6RG9rSW5ka3IiLCJuYW1lIjoiU0JNRyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozSEwyaEo5TW1NOWVhekRva0luZGtyIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFU3ZkhlemhTVGI5S2hZSTMyQ3Q1VyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRVN2ZIZXpoU1RiOUtoWUkzMkN0NVciLA==", + "ImlkIjoiNFU3ZkhlemhTVGI5S2hZSTMyQ3Q1VyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlNjM5OWI2NGI5ZjU0NzI4MjJmODc5ZDYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTYzOTliNjRiOWY1NDcyODIyZjg3OWQ2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlNjM5OWI2NGI5ZjU0NzI4MjJmODc5ZDYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWV0cm8gNTMiLCJyZWxlYXNlX2RhdGUiOiIyMDE4LTA2LTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFU3ZkhlemhTVGI5S2hZSTMyQ3Q1VyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNITDJoSjlNbU05ZWF6RG9rSW5ka3IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0hMMmhKOU1tTTllYXpEb2tJbmRrciIsImlkIjoiM0hMMmhKOU1tTTllYXpEb2tJbmRrciIsIm5hbWUiOiJTQk1HIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNITDJoSjlNbU05ZWF6RG9rSW5ka3IifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEpzazVpWU1yNWFOakh1cnk3YmxtMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wSnNrNWlZTXI1YU5qSHVyeTdibG0xIiwiaWQiOiIwSnNrNWlZTXI1YU5qSHVyeTdibG0xIiwibmFtZSI6IkJvZWYiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEpzazVpWU1yNWFOakh1cnk3YmxtMSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDQ0MTAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzY2MTgwMDU5NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNzZPZnpOdFkzbkc1aENuaDVDT1NqdCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzc2T2Z6TnRZM25HNWhDbmg1Q09TanQiLCJpZCI6Ijc2T2Z6TnRZM25HNWhDbmg1Q09TanQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTElUIiwidHJhY2tfbnVtYg==", + "ZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NzZPZnpOdFkzbkc1aENuaDVDT1NqdCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmhVTHZ5a1FSOUxpaGtNeFU4Mzc5TSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82aFVMdnlrUVI5TGloa014VTgzNzlNIiwiaWQiOiI2aFVMdnlrUVI5TGloa014VTgzNzlNIiwibmFtZSI6IkJlZWdQYXBpMTgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NmhVTHZ5a1FSOUxpaGtNeFU4Mzc5TSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFjbGU2bnExYzVpY0kzbFFxVEJSckgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xY2xlNm5xMWM1aWNJM2xRcVRCUnJIIiwiaWQiOiIxY2xlNm5xMWM1aWNJM2xRcVRCUnJIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2RhMGY5NDAyYzg1NzQ4ZTVlMTdhZTBkOSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkYTBmOTQwMmM4NTc0OGU1ZTE3YWUwZDkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWRhMGY5NDAyYzg1NzQ4ZTVlMTdhZTBkOSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdHVkaW9zZXNzaWUgMzQzIC0gMTAxYmFyeiIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDEtMDgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFjbGU2bnExYzVpY0kzbFFxVEJSckgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82aFVMdnlrUVI5TGloa014VTgzNzlNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZoVUx2eWtRUjlMaWhrTXhVODM3OU0iLCJpZCI6IjZoVUx2eWtRUjlMaWhrTXhVODM3OU0iLCJuYW1lIjoiQmVlZ1BhcGkxOCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2aFVMdnlrUVI5TGloa014VTgzNzlNIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2NzkxNSwiZXhwbA==", + "aWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJUQ0FIVDI0NjE0NzkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBmRWEwUVN1NWp0N1Q0Q0RueHQ2cDYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wZkVhMFFTdTVqdDdUNENEbnh0NnA2IiwiaWQiOiIwZkVhMFFTdTVqdDdUNENEbnh0NnA2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0dWRpb3Nlc3NpZSAzNDMsIFB0LiAxIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBmRWEwUVN1NWp0N1Q0Q0RueHQ2cDYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBJQTRTZENTOEhCRFg2b0JvT2xnYWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMElBNFNkQ1M4SEJEWDZvQm9PbGdhZiIsImlkIjoiMElBNFNkQ1M4SEJEWDZvQm9PbGdhZiIsIm5hbWUiOiJGMXJzdG1hbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowSUE0U2RDUzhIQkRYNm9Cb09sZ2FmIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsImlkIjoiMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsIm5hbWUiOiJCb2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83QzVpYVFBbFBWanh0R25sYldzd3F4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0M1aWFRQWxQVmp4dEdubGJXc3dxeCIsImlkIjoiN0M1aWFRQWxQVmp4dEdubGJXc3dxeCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1YWUyNTIxYjczZjAyM2Y0NThlN2I3ZDcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWFlMjUyMWI3M2YwMjNmNDU4ZTdiN2Q3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zYw==", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTVhZTI1MjFiNzNmMDIzZjQ1OGU3YjdkNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPdmVyYWwgKGZlYXQuIERKIFlvdXNzLUYpIiwicmVsZWFzZV9kYXRlIjoiMjAxNi0xMS0wNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0M1aWFRQWxQVmp4dEdubGJXc3dxeCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBJQTRTZENTOEhCRFg2b0JvT2xnYWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMElBNFNkQ1M4SEJEWDZvQm9PbGdhZiIsImlkIjoiMElBNFNkQ1M4SEJEWDZvQm9PbGdhZiIsIm5hbWUiOiJGMXJzdG1hbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowSUE0U2RDUzhIQkRYNm9Cb09sZ2FmIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsImlkIjoiMEpzazVpWU1yNWFOakh1cnk3YmxtMSIsIm5hbWUiOiJCb2VmIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBKc2s1aVlNcjVhTmpIdXJ5N2JsbTEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNURQOHVRTFl2WTA3SkdKdnRWa2x3ViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81RFA4dVFMWXZZMDdKR0p2dFZrbHdWIiwiaWQiOiI1RFA4dVFMWXZZMDdKR0p2dFZrbHdWIiwibmFtZSI6IkRKIFlvdXNzLUYiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NURQOHVRTFl2WTA3SkdKdnRWa2x3ViJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODI5NzAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFE0QjE2MDAwMDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdiUVEyQjRFVkxEaU1BNzlFYlQycWUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83YlFRMkI0RVZMRGlNQTc5RWJUMnFlIiwiaWQiOiI3YlFRMkI0RVZMRGlNQTc5RWJUMnFlIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik92ZXJhbCAoZmVhdA==", + "LiBESiBZb3Vzcy1GKSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3YlFRMkI0RVZMRGlNQTc5RWJUMnFlIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82aFVMdnlrUVI5TGloa014VTgzNzlNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZoVUx2eWtRUjlMaWhrTXhVODM3OU0iLCJpZCI6IjZoVUx2eWtRUjlMaWhrTXhVODM3OU0iLCJuYW1lIjoiQmVlZ1BhcGkxOCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2aFVMdnlrUVI5TGloa014VTgzNzlNIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNHlidXRac1ptWjhjY3lMQmNLR3NKWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzR5YnV0WnNabVo4Y2N5TEJjS0dzSloiLCJpZCI6IjR5YnV0WnNabVo4Y2N5TEJjS0dzSloiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDFlNzFlMTIyMzUzYzgzMzM1ZWM0NjBkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQxZTcxZTEyMjM1M2M4MzMzNWVjNDYwZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDFlNzFlMTIyMzUzYzgzMzM1ZWM0NjBkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5hc3MgU3R1ZGlvc2Vzc2llIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wOS0yNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NHlidXRac1ptWjhjY3lMQmNLR3NKWiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZoVUx2eWtRUjlMaWhrTXhVODM3OU0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmhVTHZ5a1FSOUxpaGtNeFU4Mzc5TSIsImlkIjoiNmhVTHZ5a1FSOUxpaGtNeFU4Mzc5TSIsIm5hbWUiOiJCZWVnUGFwaTE4IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZoVUx2eWtRUjlMaWhrTXhVODM3OU0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbg==", + "X21zIjozMjc4ODksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJUQ0FITDIzODA4MjAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBnN1B1VU93RHQ5aE5Zb05NeGdXZU0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wZzdQdVVPd0R0OWhOWW9OTXhnV2VNIiwiaWQiOiIwZzdQdVVPd0R0OWhOWW9OTXhnV2VNIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0dWRpb3Nlc3NpZSA0MjUgMTAxYmFyeiIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowZzdQdVVPd0R0OWhOWW9OTXhnV2VNIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=1Op1+Boef&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Vluchten%20Kan%20Niet%20Meer%20Bl%C3%B6f&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Vluchten%20Kan%20Niet%20Meer%20Bl%C3%B6f&type=track","offset":0,"previous":null,"total":20,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6AppB7gke4WXNRhtlTdSJy"},"href":"https://api.spotify.com/v1/artists/6AppB7gke4WXNRhtlTdSJy","id":"6AppB7gke4WXNRhtlTdSJy","name":"Frans Halsema","type":"artist","uri":"spotify:artist:6AppB7gke4WXNRhtlTdSJy"}],"external_urls":{"spotify":"https://open.spotify.com/album/0440RuDjeEIRAo5bwADBav"},"href":"https://api.spotify.com/v1/albums/0440RuDjeEIRAo5bwADBav","id":"0440RuDjeEIRAo5bwADBav","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e108c325e87b1d7a7dcc5582"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e108c325e87b1d7a7dcc5582"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e108c325e87b1d7a7dcc5582"}],"is_playable":true,"name":"Frans Halsema 1939-1984","release_date":"1985-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:0440RuDjeEIRAo5bwADBav"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6AppB7gke4WXNRhtlTdSJy"},"href":"https://api.spotify.com/v1/artists/6AppB7gke4WXNRhtlTdSJy","id":"6AppB7gke4WXNRhtlTdSJy","name":"Frans Halsema","type":"artist","uri":"spotify:artist:6AppB7gke4WXNRhtlTdSJy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1WbwtKjFpUY7F3IO9VR2u9"},"href":"https://api.spotify.com/v1/artists/1WbwtKjFpUY7F3IO9VR2u9","id":"1WbwtKjFpUY7F3IO9VR2u9","name":"Jenny Arean","type":"artist","uri":"spotify:artist:1WbwtKjFpUY7F3IO9VR2u9"}],"disc_number":1,"duration_ms":221666,"explicit":false,"external_ids":{"isrc":"NLA307100005"},"external_urls":{"spotify":"https://open.spotify.com/track/5f4NLmSx46c7xwTVAgzZ3H"},"href":"https://api.spotify.com/v1/tracks/5f4NLmSx46c7xwTVAgzZ3H","id":"5f4NLmSx46c7xwTVAgzZ3H","is_local":false,"is_playable":true,"name":"Vluchten Kan Niet Meer","track_number":9,"type":"track","uri":"spotify:track:5f4NLmSx46c7xwTVAgzZ3H"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6AppB7gke4WXNRhtlTdSJy"},"href":"https://api.spotify.com/v1/artists/6AppB7gke4WXNRhtlTdSJy","id":"6AppB7gke4WXNRhtlTdSJy","name":"Frans Halsema","type":"artist","uri":"spotify:artist:6AppB7gke4WXNRhtlTdSJy"}],"external_urls":{"spotify":"https://open.spotify.com/album/5gUdAu6hXT7eX3umGhMKlN"},"href":"https://api.spotify.com/v1/albums/5gUdAu6hXT7eX3umGhMKlN","id":"5gUdAu6hXT7eX3umGhMKlN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27386b0c3c62d0f6c3b76e0a304"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0286b0c3c62d0f6c3b76e0a304"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485186b0c3c62d0f6c3b76e0a304"}],"is_playable":true,"name":"Voor Haar (Remastered 2025)","release_date":"1977-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:5gUdAu6hXT7eX3umGhMKlN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6AppB7gke4WXNRhtlTdSJy"},"href":"https://api.spotify.com/v1/artists/6AppB7gke4WXNRhtlTdSJy","id":"6AppB7gke4WXNRhtlTdSJy","name":"Frans Halsema","type":"artist","uri":"spotify:artist:6AppB7gke4WXNRhtlTdSJy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1WbwtKjFpUY7F3IO9VR2u9"},"href":"https://api.spotify.com/v1/artists/1WbwtKjFpUY7F3IO9VR2u9","id":"1WbwtKjFpUY7F3IO9VR2u9","name":"Jenny Arean","type":"artist","uri":"spotify:artist:1WbwtKjFpUY7F3IO9VR2u9"}],"disc_number":1,"duration_ms":220466,"explicit":false,"external_ids":{"isrc":"NLA307100005"},"external_urls":{"spotify":"https://open.spotify.com/track/1VgZ1C6VYcc9Jb9WSvqOLv"},"href":"https://api.spotify.com/v1/tracks/1VgZ1C6VYcc9Jb9WSvqOLv","id":"1VgZ1C6VYcc9Jb9WSvqOLv","is_local":false,"is_playable":true,"name":"Vluchten Kan Niet Meer","track_number":7,"type":"track","uri":"spotify:track:1VgZ1C6VYcc9Jb9WSvqOLv"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/39BzI7vL8N9czgVxsstZO3"},"href":"https://api.spotify.com/v1/albums/39BzI7vL8N9czgVxsstZO3","id":"39BzI7vL8N9czgVxsstZO3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27345bbf44648dbadb1e68acc96"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0245bbf44648dbadb1e68acc96"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485145bbf44648dbadb1e68acc96"}],"is_playable":true,"name":"Die Goeie Ouwe Tijd Top 100","release_date":"2010-01-01","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:39BzI7vL8N9czgVxsstZO3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6AppB7gke4WXNRhtlTdSJy"},"href":"https://api.spotify.com/v1/artists/6AppB7gke4WXNRhtlTdSJy","id":"6AppB7gke4WXNRhtlTdSJy","name":"Frans Halsema","type":"artist","uri":"spotify:artist:6AppB7gke4WXNRhtlTdSJy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1WbwtKjFpUY7F3IO9VR2u9"},"href":"https://api.spotify.com/v1/artists/1WbwtKjFpUY7F3IO9VR2u9","id":"1WbwtKjFpUY7F3IO9VR2u9","name":"Jenny Arean","type":"artist","uri":"spotify:artist:1WbwtKjFpUY7F3IO9VR2u9"}],"disc_number":3,"duration_ms":220960,"explicit":false,"external_ids":{"isrc":"NLA307100005"},"external_urls":{"spotify":"https://open.spotify.com/track/2ze4LABQ3bQXHJqlZiRvxJ"},"href":"https://api.spotify.com/v1/tracks/2ze4LABQ3bQXHJqlZiRvxJ","id":"2ze4LABQ3bQXHJqlZiRvxJ","is_local":false,"is_playable":true,"name":"Vluchten Kan Niet Meer","track_number":16,"type":"track","uri":"spotify:track:2ze4LABQ3bQXHJqlZiRvxJ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6mS5GeFyhea6w9OKo8PO3p"},"href":"https://api.spotify.com/v1/artists/6mS5GeFyhea6w9OKo8PO3p","id":"6mS5GeFyhea6w9OKo8PO3p","name":"Goldband","type":"artist","uri":"spotify:artist:6mS5GeFyhea6w9OKo8PO3p"}],"external_urls":{"spotify":"https://open.spotify.com/album/6iyEGMk28j3ZuiQxz5lvU5"},"href":"https://api.spotify.com/v1/albums/6iyEGMk28j3ZuiQxz5lvU5","id":"6iyEGMk28j3ZuiQxz5lvU5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735febcfb342bac664ce836b59"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025febcfb342bac664ce836b59"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515febcfb342bac664ce836b59"}],"is_playable":true,"name":"Rommel","release_date":"2023-04-13","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:6iyEGMk28j3ZuiQxz5lvU5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6mS5GeFyhea6w9OKo8PO3p"},"href":"https://api.spotify.com/v1/artists/6mS5GeFyhea6w9OKo8PO3p","id":"6mS5GeFyhea6w9OKo8PO3p","name":"Goldband","type":"artist","uri":"spotify:artist:6mS5GeFyhea6w9OKo8PO3p"}],"disc_number":1,"duration_ms":196000,"explicit":false,"external_ids":{"isrc":"NL7EG2300002"},"external_urls":{"spotify":"https://open.spotify.com/track/0pw06mcIzuAeLPOHZT7W4Z"},"href":"https://api.spotify.com/v1/tracks/0pw06mcIzuAeLPOHZT7W4Z","id":"0pw06mcIzuAeLPOHZT7W4Z","is_local":false,"is_playable":true,"name":"Rommel","track_number":2,"type":"track","uri":"spotify:track:0pw06mcIzuAeLPOHZT7W4Z"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5sBoNBXFMzoZjgHLbQueeG"},"href":"https://api.spotify.com/v1/artists/5sBoNBXFMzoZjgHLbQueeG","id":"5sBoNBXFMzoZjgHLbQueeG","name":"Antoon","type":"artist","uri":"spotify:artist:5sBoNBXFMzoZjgHLbQueeG"}],"external_urls":{"spotify":"https://open.spotify.com/album/23nN46ulvMESVJFJJovgSu"},"href":"https://api.spotify.com/v1/albums/23nN46ulvMESVJFJJovgSu","id":"23nN46ulvMESVJFJJovgSu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c65582ae414bcb5d90ea7201"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c65582ae414bcb5d90ea7201"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c65582ae414bcb5d90ea7201"}],"is_playable":true,"name":"De Enige","release_date":"2026-05-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:23nN46ulvMESVJFJJovgSu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5sBoNBXFMzoZjgHLbQueeG"},"href":"https://api.spotify.com/v1/artists/5sBoNBXFMzoZjgHLbQueeG","id":"5sBoNBXFMzoZjgHLbQueeG","name":"Antoon","type":"artist","uri":"spotify:artist:5sBoNBXFMzoZjgHLbQueeG"}],"disc_number":1,"duration_ms":158400,"explicit":false,"external_ids":{"isrc":"NLA802600073"},"external_urls":{"spotify":"https://open.spotify.com/track/4WH5g5hyfQxgN94JGNOUZk"},"href":"https://api.spotify.com/v1/tracks/4WH5g5hyfQxgN94JGNOUZk","id":"4WH5g5hyfQxgN94JGNOUZk","is_local":false,"is_playable":true,"name":"De Enige","track_number":1,"type":"track","uri":"spotify:track:4WH5g5hyfQxgN94JGNOUZk"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6AppB7gke4WXNRhtlTdSJy"},"href":"https://api.spotify.com/v1/artists/6AppB7gke4WXNRhtlTdSJy","id":"6AppB7gke4WXNRhtlTdSJy","name":"Frans Halsema","type":"artist","uri":"spotify:artist:6AppB7gke4WXNRhtlTdSJy"}],"external_urls":{"spotify":"https://open.spotify.com/album/4wtJJageS0xLtoxiqvgQZf"},"href":"https://api.spotify.com/v1/albums/4wtJJageS0xLtoxiqvgQZf","id":"4wtJJageS0xLtoxiqvgQZf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736ea8b55ee14d6ce45816d0c4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026ea8b55ee14d6ce45816d0c4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516ea8b55ee14d6ce45816d0c4"}],"is_playable":true,"name":"Favorieten Expres","release_date":"2018-06-29","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:4wtJJageS0xLtoxiqvgQZf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6AppB7gke4WXNRhtlTdSJy"},"href":"https://api.spotify.com/v1/artists/6AppB7gke4WXNRhtlTdSJy","id":"6AppB7gke4WXNRhtlTdSJy","name":"Frans Halsema","type":"artist","uri":"spotify:artist:6AppB7gke4WXNRhtlTdSJy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1WbwtKjFpUY7F3IO9VR2u9"},"href":"https://api.spotify.com/v1/artists/1WbwtKjFpUY7F3IO9VR2u9","id":"1WbwtKjFpUY7F3IO9VR2u9","name":"Jenny Arean","type":"artist","uri":"spotify:artist:1WbwtKjFpUY7F3IO9VR2u9"}],"disc_number":1,"duration_ms":221160,"explicit":false,"external_ids":{"isrc":"NLA307100005"},"external_urls":{"spotify":"https://open.spotify.com/track/2FUwyzcd4IveujPTuygjRH"},"href":"https://api.spotify.com/v1/tracks/2FUwyzcd4IveujPTuygjRH","id":"2FUwyzcd4IveujPTuygjRH","is_local":false,"is_playable":true,"name":"Vluchten Kan Niet Meer","track_number":10,"type":"track","uri":"spotify:track:2FUwyzcd4IveujPTuygjRH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6AppB7gke4WXNRhtlTdSJy"},"href":"https://api.spotify.com/v1/artists/6AppB7gke4WXNRhtlTdSJy","id":"6AppB7gke4WXNRhtlTdSJy","name":"Frans Halsema","type":"artist","uri":"spotify:artist:6AppB7gke4WXNRhtlTdSJy"}],"external_urls":{"spotify":"https://open.spotify.com/album/1z7t3fczBK0RbDeCun2Xbr"},"href":"https://api.spotify.com/v1/albums/1z7t3fczBK0RbDeCun2Xbr","id":"1z7t3fczBK0RbDeCun2Xbr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e9d5c6c64ce394cf28e7e32d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e9d5c6c64ce394cf28e7e32d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e9d5c6c64ce394cf28e7e32d"}],"is_playable":true,"name":"Het Beste van Frans Halsema - Zijn 40 Mooiste Liedjes","release_date":"1997-01-01","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:1z7t3fczBK0RbDeCun2Xbr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6AppB7gke4WXNRhtlTdSJy"},"href":"https://api.spotify.com/v1/artists/6AppB7gke4WXNRhtlTdSJy","id":"6AppB7gke4WXNRhtlTdSJy","name":"Frans Halsema","type":"artist","uri":"spotify:artist:6AppB7gke4WXNRhtlTdSJy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1WbwtKjFpUY7F3IO9VR2u9"},"href":"https://api.spotify.com/v1/artists/1WbwtKjFpUY7F3IO9VR2u9","id":"1WbwtKjFpUY7F3IO9VR2u9","name":"Jenny Arean","type":"artist","uri":"spotify:artist:1WbwtKjFpUY7F3IO9VR2u9"}],"disc_number":2,"duration_ms":221466,"explicit":false,"external_ids":{"isrc":"NLA307100005"},"external_urls":{"spotify":"https://open.spotify.com/track/3W3gcdUaakPVyABGlvlQtz"},"href":"https://api.spotify.com/v1/tracks/3W3gcdUaakPVyABGlvlQtz","id":"3W3gcdUaakPVyABGlvlQtz","is_local":false,"is_playable":true,"name":"Vluchten Kan Niet Meer","track_number":1,"type":"track","uri":"spotify:track:3W3gcdUaakPVyABGlvlQtz"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0uBVyPbLZRDNEBiA4fZUlp"},"href":"https://api.spotify.com/v1/artists/0uBVyPbLZRDNEBiA4fZUlp","id":"0uBVyPbLZRDNEBiA4fZUlp","name":"Froukje","type":"artist","uri":"spotify:artist:0uBVyPbLZRDNEBiA4fZUlp"}],"external_urls":{"spotify":"https://open.spotify.com/album/0YwrM4igfHYVfNLiIHfiLG"},"href":"https://api.spotify.com/v1/albums/0YwrM4igfHYVfNLiIHfiLG","id":"0YwrM4igfHYVfNLiIHfiLG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad985d0332c864fdaefe25a2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad985d0332c864fdaefe25a2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad985d0332c864fdaefe25a2"}],"is_playable":true,"name":"Licht En Donker","release_date":"2021-01-07","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:0YwrM4igfHYVfNLiIHfiLG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0uBVyPbLZRDNEBiA4fZUlp"},"href":"https://api.spotify.com/v1/artists/0uBVyPbLZRDNEBiA4fZUlp","id":"0uBVyPbLZRDNEBiA4fZUlp","name":"Froukje","type":"artist","uri":"spotify:artist:0uBVyPbLZRDNEBiA4fZUlp"}],"disc_number":1,"duration_ms":167434,"explicit":false,"external_ids":{"isrc":"NLG662000955"},"external_urls":{"spotify":"https://open.spotify.com/track/4dxWDDEkFq9VqsAcIM0IpT"},"href":"https://api.spotify.com/v1/tracks/4dxWDDEkFq9VqsAcIM0IpT","id":"4dxWDDEkFq9VqsAcIM0IpT","is_local":false,"is_playable":true,"name":"Onbezonnen","track_number":6,"type":"track","uri":"spotify:track:4dxWDDEkFq9VqsAcIM0IpT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/11YiKYULtpVKbNGdpKjaj0"},"href":"https://api.spotify.com/v1/albums/11YiKYULtpVKbNGdpKjaj0","id":"11YiKYULtpVKbNGdpKjaj0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273566d303809ace090f10101c9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02566d303809ace090f10101c9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851566d303809ace090f10101c9"}],"is_playable":true,"name":"New Wave","release_date":"2015-04-07","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:11YiKYULtpVKbNGdpKjaj0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"disc_number":1,"duration_ms":208272,"explicit":true,"external_ids":{"isrc":"NLG661500216"},"external_urls":{"spotify":"https://open.spotify.com/track/1Tb7SUdzJTWdd8HEsjt0MY"},"href":"https://api.spotify.com/v1/tracks/1Tb7SUdzJTWdd8HEsjt0MY","id":"1Tb7SUdzJTWdd8HEsjt0MY","is_local":false,"is_playable":true,"name":"Zeg Dat Niet","track_number":3,"type":"track","uri":"spotify:track:1Tb7SUdzJTWdd8HEsjt0MY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IxgA9wO4Op3CSnPlhfwV1"},"href":"https://api.spotify.com/v1/artists/0IxgA9wO4Op3CSnPlhfwV1","id":"0IxgA9wO4Op3CSnPlhfwV1","name":"Kevin","type":"artist","uri":"spotify:artist:0IxgA9wO4Op3CSnPlhfwV1"}],"external_urls":{"spotify":"https://open.spotify.com/album/1kXKhpGQNwFrHZmmzF6xJ4"},"href":"https://api.spotify.com/v1/albums/1kXKhpGQNwFrHZmmzF6xJ4","id":"1kXKhpGQNwFrHZmmzF6xJ4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737ade9485f0bddb462c2b11a1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027ade9485f0bddb462c2b11a1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517ade9485f0bddb462c2b11a1"}],"is_playable":true,"name":"Wonderland","release_date":"2023-11-16","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:1kXKhpGQNwFrHZmmzF6xJ4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0IxgA9wO4Op3CSnPlhfwV1"},"href":"https://api.spotify.com/v1/artists/0IxgA9wO4Op3CSnPlhfwV1","id":"0IxgA9wO4Op3CSnPlhfwV1","name":"Kevin","type":"artist","uri":"spotify:artist:0IxgA9wO4Op3CSnPlhfwV1"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4iCzh7b2cLbHVsPOwhr8W0"},"href":"https://api.spotify.com/v1/artists/4iCzh7b2cLbHVsPOwhr8W0","id":"4iCzh7b2cLbHVsPOwhr8W0","name":"JoeyAK","type":"artist","uri":"spotify:artist:4iCzh7b2cLbHVsPOwhr8W0"}],"disc_number":1,"duration_ms":207458,"explicit":true,"external_ids":{"isrc":"NLG662300093"},"external_urls":{"spotify":"https://open.spotify.com/track/2iWKvvKdwMmTxYcZAPUnDM"},"href":"https://api.spotify.com/v1/tracks/2iWKvvKdwMmTxYcZAPUnDM","id":"2iWKvvKdwMmTxYcZAPUnDM","is_local":false,"is_playable":true,"name":"Kipstraat","track_number":8,"type":"track","uri":"spotify:track:2iWKvvKdwMmTxYcZAPUnDM"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1WbHVjaHRlbiUyMEthbiUyME5pZXQlMjBNZWVyJTIwQmwlQzMlQjZmJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9zZWFyY2g/b2Zmc2V0PTEwJmxpbWl0PTEwJnF1ZXJ5PVZsdWNodGVuJTIwS2FuJTIwTmlldCUyME1lZXIlMjBCbCVDMyVCNmYmdHlwZT10cmFjayIsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyMCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82QXBwQjdna2U0V1hOUmh0bFRkU0p5IiwiaWQiOiI2QXBwQjdna2U0V1hOUmh0bFRkU0p5IiwibmFtZSI6IkZyYW5zIEhhbHNlbWEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkFwcEI3Z2tlNFdYTlJodGxUZFNKeSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzA0NDBSdURqZUVJUkFvNWJ3QURCYXYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wNDQwUnVEamVFSVJBbzVid0FEQmF2IiwiaWQiOiIwNDQwUnVEamVFSVJBbzVid0FEQmF2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2UxMDhjMzI1ZTg3YjFkN2E3ZGNjNTU4MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlMTA4YzMyNWU4N2IxZDdhN2RjYzU1ODIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWUxMDhjMzI1ZTg3YjFkN2E3ZGNjNTU4MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGcmFucyBIYWxzZW1hIDE5MzktMTk4NCIsInJlbGVhc2VfZGF0ZSI6IjE5ODUtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowNDQwUnVEamVFSVJBbzVid0FEQmF2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNg==", + "QXBwQjdna2U0V1hOUmh0bFRkU0p5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZBcHBCN2drZTRXWE5SaHRsVGRTSnkiLCJpZCI6IjZBcHBCN2drZTRXWE5SaHRsVGRTSnkiLCJuYW1lIjoiRnJhbnMgSGFsc2VtYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2QXBwQjdna2U0V1hOUmh0bFRkU0p5In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFXYnd0S2pGcFVZN0YzSU85VlIydTkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVdid3RLakZwVVk3RjNJTzlWUjJ1OSIsImlkIjoiMVdid3RLakZwVVk3RjNJTzlWUjJ1OSIsIm5hbWUiOiJKZW5ueSBBcmVhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxV2J3dEtqRnBVWTdGM0lPOVZSMnU5In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMTY2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTMwNzEwMDAwNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWY0TkxtU3g0NmM3eHdUVkFnelozSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVmNE5MbVN4NDZjN3h3VFZBZ3paM0giLCJpZCI6IjVmNE5MbVN4NDZjN3h3VFZBZ3paM0giLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVmx1Y2h0ZW4gS2FuIE5pZXQgTWVlciIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1ZjROTG1TeDQ2Yzd4d1RWQWd6WjNIIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZBcHBCN2drZTRXWE5SaHRsVGRTSnkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSIsImlkIjoiNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSIsIm5hbWUiOiJGcmFucyBIYWxzZW1hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZBcHBCN2drZTRXWE5SaHRsVGRTSnkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81Z1VkQXU2aFhUN2VYM3VtR2hNS2xOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWdVZEF1NmhYVDdlWDN1bUdoTUtsTiIsImlkIjoiNWdVZEF1NmhYVDdlWDN1bQ==", + "R2hNS2xOIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzg2YjBjM2M2MmQwZjZjM2I3NmUwYTMwNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4NmIwYzNjNjJkMGY2YzNiNzZlMGEzMDQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTg2YjBjM2M2MmQwZjZjM2I3NmUwYTMwNCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWb29yIEhhYXIgKFJlbWFzdGVyZWQgMjAyNSkiLCJyZWxlYXNlX2RhdGUiOiIxOTc3LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWdVZEF1NmhYVDdlWDN1bUdoTUtsTiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZBcHBCN2drZTRXWE5SaHRsVGRTSnkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSIsImlkIjoiNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSIsIm5hbWUiOiJGcmFucyBIYWxzZW1hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZBcHBCN2drZTRXWE5SaHRsVGRTSnkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVdid3RLakZwVVk3RjNJTzlWUjJ1OSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xV2J3dEtqRnBVWTdGM0lPOVZSMnU5IiwiaWQiOiIxV2J3dEtqRnBVWTdGM0lPOVZSMnU5IiwibmFtZSI6Ikplbm55IEFyZWFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFXYnd0S2pGcFVZN0YzSU85VlIydTkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjIwNDY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxBMzA3MTAwMDA1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xVmdaMUM2VlljYzlKYjlXU3ZxT0x2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVZnWjFDNlZZY2M5SmI5V1N2cU9MdiIsImlkIjoiMVZnWjFDNlZZY2M5SmI5V1N2cU9MdiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWbA==", + "dWNodGVuIEthbiBOaWV0IE1lZXIiLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MVZnWjFDNlZZY2M5SmI5V1N2cU9MdiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zOUJ6STd2TDhOOWN6Z1Z4c3N0Wk8zIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMzlCekk3dkw4TjljemdWeHNzdFpPMyIsImlkIjoiMzlCekk3dkw4TjljemdWeHNzdFpPMyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0NWJiZjQ0NjQ4ZGJhZGIxZTY4YWNjOTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDViYmY0NDY0OGRiYWRiMWU2OGFjYzk2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0NWJiZjQ0NjQ4ZGJhZGIxZTY4YWNjOTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGllIEdvZWllIE91d2UgVGlqZCBUb3AgMTAwIiwicmVsZWFzZV9kYXRlIjoiMjAxMC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozOUJ6STd2TDhOOWN6Z1Z4c3N0Wk8zIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82QXBwQjdna2U0V1hOUmh0bFRkU0p5IiwiaWQiOiI2QXBwQjdna2U0V1hOUmh0bFRkU0p5IiwibmFtZSI6IkZyYW5zIEhhbHNlbWEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkFwcEI3Z2tlNFdYTlJodGxUZA==", + "U0p5In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFXYnd0S2pGcFVZN0YzSU85VlIydTkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVdid3RLakZwVVk3RjNJTzlWUjJ1OSIsImlkIjoiMVdid3RLakZwVVk3RjNJTzlWUjJ1OSIsIm5hbWUiOiJKZW5ueSBBcmVhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxV2J3dEtqRnBVWTdGM0lPOVZSMnU5In1dLCJkaXNjX251bWJlciI6MywiZHVyYXRpb25fbXMiOjIyMDk2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTMwNzEwMDAwNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMnplNExBQlEzYlFYSEpxbFppUnZ4SiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJ6ZTRMQUJRM2JRWEhKcWxaaVJ2eEoiLCJpZCI6IjJ6ZTRMQUJRM2JRWEhKcWxaaVJ2eEoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVmx1Y2h0ZW4gS2FuIE5pZXQgTWVlciIsInRyYWNrX251bWJlciI6MTYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MnplNExBQlEzYlFYSEpxbFppUnZ4SiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm1TNUdlRnloZWE2dzlPS284UE8zcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bVM1R2VGeWhlYTZ3OU9LbzhQTzNwIiwiaWQiOiI2bVM1R2VGeWhlYTZ3OU9LbzhQTzNwIiwibmFtZSI6IkdvbGRiYW5kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZtUzVHZUZ5aGVhNnc5T0tvOFBPM3AifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82aXlFR01rMjhqM1p1aVF4ejVsdlU1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNml5RUdNazI4ajNadWlReHo1bHZVNSIsImlkIjoiNml5RUdNazI4ajNadWlReHo1bHZVNSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1ZmViY2ZiMzQyYmFjNjY0Y2U4MzZiNTkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWZlYmNmYjM0MmJhYw==", + "NjY0Y2U4MzZiNTkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTVmZWJjZmIzNDJiYWM2NjRjZTgzNmI1OSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb21tZWwiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA0LTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2aXlFR01rMjhqM1p1aVF4ejVsdlU1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm1TNUdlRnloZWE2dzlPS284UE8zcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bVM1R2VGeWhlYTZ3OU9LbzhQTzNwIiwiaWQiOiI2bVM1R2VGeWhlYTZ3OU9LbzhQTzNwIiwibmFtZSI6IkdvbGRiYW5kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZtUzVHZUZ5aGVhNnc5T0tvOFBPM3AifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk2MDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkw3RUcyMzAwMDAyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wcHcwNm1jSXp1QWVMUE9IWlQ3VzRaIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMHB3MDZtY0l6dUFlTFBPSFpUN1c0WiIsImlkIjoiMHB3MDZtY0l6dUFlTFBPSFpUN1c0WiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb21tZWwiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHB3MDZtY0l6dUFlTFBPSFpUN1c0WiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXNCb05CWEZNem9aamdITGJRdWVlRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81c0JvTkJYRk16b1pqZ0hMYlF1ZWVHIiwiaWQiOiI1c0JvTkJYRk16b1pqZ0hMYlF1ZWVHIiwibmFtZSI6IkFudG9vbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1c0JvTkJYRk16b1pqZ0hMYlF1ZWVHIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMjNuTjQ2dWx2TUVTVkpGSkpvdmdTdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdA==", + "aWZ5LmNvbS92MS9hbGJ1bXMvMjNuTjQ2dWx2TUVTVkpGSkpvdmdTdSIsImlkIjoiMjNuTjQ2dWx2TUVTVkpGSkpvdmdTdSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjNjU1ODJhZTQxNGJjYjVkOTBlYTcyMDEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzY1NTgyYWU0MTRiY2I1ZDkwZWE3MjAxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNjU1ODJhZTQxNGJjYjVkOTBlYTcyMDEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGUgRW5pZ2UiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA1LTI5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyM25ONDZ1bHZNRVNWSkZKSm92Z1N1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXNCb05CWEZNem9aamdITGJRdWVlRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81c0JvTkJYRk16b1pqZ0hMYlF1ZWVHIiwiaWQiOiI1c0JvTkJYRk16b1pqZ0hMYlF1ZWVHIiwibmFtZSI6IkFudG9vbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1c0JvTkJYRk16b1pqZ0hMYlF1ZWVHIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE1ODQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTgwMjYwMDA3MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFdINWc1aHlmUXhnTjk0SkdOT1VaayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRXSDVnNWh5ZlF4Z045NEpHTk9VWmsiLCJpZCI6IjRXSDVnNWh5ZlF4Z045NEpHTk9VWmsiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGUgRW5pZ2UiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFdINWc1aHlmUXhnTjk0SkdOT1VaayJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82QXBwQjdna2U0V1hOUmh0bFRkU0p5In0sImhyZWYiOiJodA==", + "dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSIsImlkIjoiNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSIsIm5hbWUiOiJGcmFucyBIYWxzZW1hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZBcHBCN2drZTRXWE5SaHRsVGRTSnkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80d3RKSmFnZVMweEx0b3hpcXZnUVpmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHd0SkphZ2VTMHhMdG94aXF2Z1FaZiIsImlkIjoiNHd0SkphZ2VTMHhMdG94aXF2Z1FaZiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2ZWE4YjU1ZWUxNGQ2Y2U0NTgxNmQwYzQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNmVhOGI1NWVlMTRkNmNlNDU4MTZkMGM0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2ZWE4YjU1ZWUxNGQ2Y2U0NTgxNmQwYzQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmF2b3JpZXRlbiBFeHByZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDE4LTA2LTI5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NHd0SkphZ2VTMHhMdG94aXF2Z1FaZiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZBcHBCN2drZTRXWE5SaHRsVGRTSnkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSIsImlkIjoiNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSIsIm5hbWUiOiJGcmFucyBIYWxzZW1hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZBcHBCN2drZTRXWE5SaHRsVGRTSnkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVdid3RLakZwVVk3RjNJTzlWUjJ1OSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xV2J3dEtqRnBVWTdGM0lPOVZSMnU5IiwiaWQiOiIxV2J3dEtqRnBVWTdGM0lPOVZSMnU5IiwibmFtZSI6Ikplbm55IEFyZWFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFXYnd0S2pGcA==", + "VVk3RjNJTzlWUjJ1OSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjExNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEEzMDcxMDAwMDUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJGVXd5emNkNEl2ZXVqUFR1eWdqUkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yRlV3eXpjZDRJdmV1alBUdXlnalJIIiwiaWQiOiIyRlV3eXpjZDRJdmV1alBUdXlnalJIIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZsdWNodGVuIEthbiBOaWV0IE1lZXIiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJGVXd5emNkNEl2ZXVqUFR1eWdqUkgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkFwcEI3Z2tlNFdYTlJodGxUZFNKeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82QXBwQjdna2U0V1hOUmh0bFRkU0p5IiwiaWQiOiI2QXBwQjdna2U0V1hOUmh0bFRkU0p5IiwibmFtZSI6IkZyYW5zIEhhbHNlbWEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkFwcEI3Z2tlNFdYTlJodGxUZFNKeSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzF6N3QzZmN6QkswUmJEZUN1bjJYYnIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xejd0M2ZjekJLMFJiRGVDdW4yWGJyIiwiaWQiOiIxejd0M2ZjekJLMFJiRGVDdW4yWGJyIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2U5ZDVjNmM2NGNlMzk0Y2YyOGU3ZTMyZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlOWQ1YzZjNjRjZTM5NGNmMjhlN2UzMmQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWU5ZDVjNmM2NGNlMzk0Y2YyOGU3ZTMyZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXQgQmVzdGUgdmFuIEZyYW5zIEhhbHNlbWEgLSBaaWpuIDQwIE1vb2lzdGUgTGllZGplcyIsInJlbGVhc2VfZGF0ZSI6IjE5OTctMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIg==", + "OiJkYXkiLCJ0b3RhbF90cmFja3MiOjQwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjF6N3QzZmN6QkswUmJEZUN1bjJYYnIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82QXBwQjdna2U0V1hOUmh0bFRkU0p5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZBcHBCN2drZTRXWE5SaHRsVGRTSnkiLCJpZCI6IjZBcHBCN2drZTRXWE5SaHRsVGRTSnkiLCJuYW1lIjoiRnJhbnMgSGFsc2VtYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2QXBwQjdna2U0V1hOUmh0bFRkU0p5In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFXYnd0S2pGcFVZN0YzSU85VlIydTkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVdid3RLakZwVVk3RjNJTzlWUjJ1OSIsImlkIjoiMVdid3RLakZwVVk3RjNJTzlWUjJ1OSIsIm5hbWUiOiJKZW5ueSBBcmVhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxV2J3dEtqRnBVWTdGM0lPOVZSMnU5In1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjIyMTQ2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTMwNzEwMDAwNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM1czZ2NkVWFha1BWeUFCR2x2bFF0eiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNXM2djZFVhYWtQVnlBQkdsdmxRdHoiLCJpZCI6IjNXM2djZFVhYWtQVnlBQkdsdmxRdHoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVmx1Y2h0ZW4gS2FuIE5pZXQgTWVlciIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozVzNnY2RVYWFrUFZ5QUJHbHZsUXR6In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdUJWeVBiTFpSRE5FQmlBNGZaVWxwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB1QlZ5UGJMWlJETkVCaUE0ZlpVbHAiLCJpZCI6IjB1QlZ5UGJMWlJETkVCaUE0ZlpVbHAiLCJuYW1lIjoiRnJvdWtqZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowdUJWeVBiTFpSRE5FQmlBNGZaVWxwIn1dLCJleHRlcm5hbF91cmxzIjp7Ig==", + "c3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wWXdyTTRpZ2ZIWVZmTkxpSUhmaUxHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMFl3ck00aWdmSFlWZk5MaUlIZmlMRyIsImlkIjoiMFl3ck00aWdmSFlWZk5MaUlIZmlMRyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhZDk4NWQwMzMyYzg2NGZkYWVmZTI1YTIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWQ5ODVkMDMzMmM4NjRmZGFlZmUyNWEyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhZDk4NWQwMzMyYzg2NGZkYWVmZTI1YTIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGljaHQgRW4gRG9ua2VyIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wMS0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MFl3ck00aWdmSFlWZk5MaUlIZmlMRyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzB1QlZ5UGJMWlJETkVCaUE0ZlpVbHAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMHVCVnlQYkxaUkRORUJpQTRmWlVscCIsImlkIjoiMHVCVnlQYkxaUkRORUJpQTRmWlVscCIsIm5hbWUiOiJGcm91a2plIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjB1QlZ5UGJMWlJETkVCaUE0ZlpVbHAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTY3NDM0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyMDAwOTU1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80ZHhXRERFa0ZxOVZxc0FjSU0wSXBUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGR4V0RERWtGcTlWcXNBY0lNMElwVCIsImlkIjoiNGR4V0RERWtGcTlWcXNBY0lNMElwVCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPbmJlem9ubmVuIiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRkeFdEREVrRnE5VnFzQWNJTTBJcFQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdA==", + "cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xMVlpS1lVTHRwVktiTkdkcEtqYWowIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTFZaUtZVUx0cFZLYk5HZHBLamFqMCIsImlkIjoiMTFZaUtZVUx0cFZLYk5HZHBLamFqMCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1NjZkMzAzODA5YWNlMDkwZjEwMTAxYzkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTY2ZDMwMzgwOWFjZTA5MGYxMDEwMWM5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1NjZkMzAzODA5YWNlMDkwZjEwMTAxYzkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmV3IFdhdmUiLCJyZWxlYXNlX2RhdGUiOiIyMDE1LTA0LTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MTFZaUtZVUx0cFZLYk5HZHBLamFqMCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNBbFJpeWpNeXdUVk56VGNIYmY5UVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0FsUml5ak15d1RWTnpUY0hiZjlRVCIsImlkIjoiM0FsUml5ak15d1RWTnpUY0hiZjlRVCIsIm5hbWUiOiJMaWwgS2xlaW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNBbFJp", + "eWpNeXdUVk56VGNIYmY5UVQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNWVpcjV6RkpwRVM0ajdnc3ltYlZ5bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIiwiaWQiOiI1ZWlyNXpGSnBFUzRqN2dzeW1iVnlsIiwibmFtZSI6IlJvbm5pZSBGbGV4IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVlaXI1ekZKcEVTNGo3Z3N5bWJWeWwifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA4MjcyLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjE1MDAyMTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFUYjdTVWR6SlRXZGQ4SEVzanQwTVkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xVGI3U1VkekpUV2RkOEhFc2p0ME1ZIiwiaWQiOiIxVGI3U1VkekpUV2RkOEhFc2p0ME1ZIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlplZyBEYXQgTmlldCIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxVGI3U1VkekpUV2RkOEhFc2p0ME1ZIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBJeGdBOXdPNE9wM0NTblBsaGZ3VjEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEl4Z0E5d080T3AzQ1NuUGxoZndWMSIsImlkIjoiMEl4Z0E5d080T3AzQ1NuUGxoZndWMSIsIm5hbWUiOiJLZXZpbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowSXhnQTl3TzRPcDNDU25QbGhmd1YxIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMWtYS2hwR1FOd0ZySFptbXpGNnhKNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFrWEtocEdRTndGckhabW16RjZ4SjQiLCJpZCI6IjFrWEtocEdRTndGckhabW16RjZ4SjQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2FkZTk0ODVmMGJkZGI0NjJjMmIxMWExIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdhZGU5NDg1ZjBiZGRiNA==", + "NjJjMmIxMWExIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3YWRlOTQ4NWYwYmRkYjQ2MmMyYjExYTEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV29uZGVybGFuZCIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMTEtMTYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxa1hLaHBHUU53RnJIWm1tekY2eEo0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEl4Z0E5d080T3AzQ1NuUGxoZndWMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wSXhnQTl3TzRPcDNDU25QbGhmd1YxIiwiaWQiOiIwSXhnQTl3TzRPcDNDU25QbGhmd1YxIiwibmFtZSI6IktldmluIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBJeGdBOXdPNE9wM0NTblBsaGZ3VjEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGlDemg3YjJjTGJIVnNQT3docjhXMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80aUN6aDdiMmNMYkhWc1BPd2hyOFcwIiwiaWQiOiI0aUN6aDdiMmNMYkhWc1BPd2hyOFcwIiwibmFtZSI6IkpvZXlBSyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0aUN6aDdiMmNMYkhWc1BPd2hyOFcwIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNzQ1OCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYyMzAwMDkzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yaVdLdnZLZHdNbVR4WWNaQVBVbkRNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMmlXS3Z2S2R3TW1UeFljWkFQVW5ETSIsImlkIjoiMmlXS3Z2S2R3TW1UeFljWkFQVW5ETSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJLaXBzdHJhYXQiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MmlXS3Z2S2R3TW1UeFljWkFQVW5ETSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Vluchten+Kan+Niet+Meer+Bl%C3%B6f&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJsaWpmJTIwQmlqJTIwTWlqJTIyJTIwYXJ0aXN0JTNBJTIyR3V1cyUyME1lZXV3aXMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJsaWpmJTIwQmlqJTIwTWlqJTIyJTIwYXJ0aXN0JTNBJTIyR3V1cyUyME1lZXV3aXMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Blijf+Bij+Mij%22+artist%3A%22Guus+Meeuwis%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Zoutelande%20Bl%C3%B8f%2C%20Geike%20Arnaert&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tTV2cKaA2TXTUOE642C59"},"href":"https://api.spotify.com/v1/albums/0tTV2cKaA2TXTUOE642C59","id":"0tTV2cKaA2TXTUOE642C59","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfe2c03bb1a14bf176c19833"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfe2c03bb1a14bf176c19833"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfe2c03bb1a14bf176c19833"}],"is_playable":true,"name":"Aan","release_date":"2017-05-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0tTV2cKaA2TXTUOE642C59"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":219546,"explicit":false,"external_ids":{"isrc":"NLR4H1700009"},"external_urls":{"spotify":"https://open.spotify.com/track/6aAJY5FYW0TMLsUe2T7x4p"},"href":"https://api.spotify.com/v1/tracks/6aAJY5FYW0TMLsUe2T7x4p","id":"6aAJY5FYW0TMLsUe2T7x4p","is_local":false,"is_playable":true,"name":"Zoutelande","track_number":9,"type":"track","uri":"spotify:track:6aAJY5FYW0TMLsUe2T7x4p"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0lijSwwkPwnIv3NOnwL5O0"},"href":"https://api.spotify.com/v1/albums/0lijSwwkPwnIv3NOnwL5O0","id":"0lijSwwkPwnIv3NOnwL5O0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ca25d639c8cdce5cf930b79d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ca25d639c8cdce5cf930b79d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ca25d639c8cdce5cf930b79d"}],"is_playable":true,"name":"Zoutelande (feat. Geike)","release_date":"2017-10-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0lijSwwkPwnIv3NOnwL5O0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":223266,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/0le8EcVp4x1JjMhwRKIOVi"},"href":"https://api.spotify.com/v1/tracks/0le8EcVp4x1JjMhwRKIOVi","id":"0le8EcVp4x1JjMhwRKIOVi","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":1,"type":"track","uri":"spotify:track:0le8EcVp4x1JjMhwRKIOVi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tTV2cKaA2TXTUOE642C59"},"href":"https://api.spotify.com/v1/albums/0tTV2cKaA2TXTUOE642C59","id":"0tTV2cKaA2TXTUOE642C59","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfe2c03bb1a14bf176c19833"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfe2c03bb1a14bf176c19833"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfe2c03bb1a14bf176c19833"}],"is_playable":true,"name":"Aan","release_date":"2017-05-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0tTV2cKaA2TXTUOE642C59"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":223266,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/7MOX3ibncypw3xGb4HZVFA"},"href":"https://api.spotify.com/v1/tracks/7MOX3ibncypw3xGb4HZVFA","id":"7MOX3ibncypw3xGb4HZVFA","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":15,"type":"track","uri":"spotify:track:7MOX3ibncypw3xGb4HZVFA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ylIKKdMukkuprCgY4ZDFE"},"href":"https://api.spotify.com/v1/artists/2ylIKKdMukkuprCgY4ZDFE","id":"2ylIKKdMukkuprCgY4ZDFE","name":"Donnie","type":"artist","uri":"spotify:artist:2ylIKKdMukkuprCgY4ZDFE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"external_urls":{"spotify":"https://open.spotify.com/album/660ZzT4n5u5LKvsPzmANkY"},"href":"https://api.spotify.com/v1/albums/660ZzT4n5u5LKvsPzmANkY","id":"660ZzT4n5u5LKvsPzmANkY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b9c79743fef568f42169b71b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b9c79743fef568f42169b71b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b9c79743fef568f42169b71b"}],"is_playable":true,"name":"M Van Marketing","release_date":"2018-08-03","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:660ZzT4n5u5LKvsPzmANkY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ylIKKdMukkuprCgY4ZDFE"},"href":"https://api.spotify.com/v1/artists/2ylIKKdMukkuprCgY4ZDFE","id":"2ylIKKdMukkuprCgY4ZDFE","name":"Donnie","type":"artist","uri":"spotify:artist:2ylIKKdMukkuprCgY4ZDFE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"disc_number":1,"duration_ms":125863,"explicit":true,"external_ids":{"isrc":"NLG661800707"},"external_urls":{"spotify":"https://open.spotify.com/track/4pHaft5iymL4elqKkA3Qxb"},"href":"https://api.spotify.com/v1/tracks/4pHaft5iymL4elqKkA3Qxb","id":"4pHaft5iymL4elqKkA3Qxb","is_local":false,"is_playable":true,"name":"M Van Marketing","track_number":6,"type":"track","uri":"spotify:track:4pHaft5iymL4elqKkA3Qxb"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Zoutelande%20Bl%C3%B8f%2C%20Geike%20Arnaert&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tTV2cKaA2TXTUOE642C59"},"href":"https://api.spotify.com/v1/albums/0tTV2cKaA2TXTUOE642C59","id":"0tTV2cKaA2TXTUOE642C59","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfe2c03bb1a14bf176c19833"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfe2c03bb1a14bf176c19833"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfe2c03bb1a14bf176c19833"}],"is_playable":true,"name":"Aan","release_date":"2017-05-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0tTV2cKaA2TXTUOE642C59"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"disc_number":1,"duration_ms":219546,"explicit":false,"external_ids":{"isrc":"NLR4H1700009"},"external_urls":{"spotify":"https://open.spotify.com/track/6aAJY5FYW0TMLsUe2T7x4p"},"href":"https://api.spotify.com/v1/tracks/6aAJY5FYW0TMLsUe2T7x4p","id":"6aAJY5FYW0TMLsUe2T7x4p","is_local":false,"is_playable":true,"name":"Zoutelande","track_number":9,"type":"track","uri":"spotify:track:6aAJY5FYW0TMLsUe2T7x4p"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0lijSwwkPwnIv3NOnwL5O0"},"href":"https://api.spotify.com/v1/albums/0lijSwwkPwnIv3NOnwL5O0","id":"0lijSwwkPwnIv3NOnwL5O0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ca25d639c8cdce5cf930b79d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ca25d639c8cdce5cf930b79d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ca25d639c8cdce5cf930b79d"}],"is_playable":true,"name":"Zoutelande (feat. Geike)","release_date":"2017-10-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0lijSwwkPwnIv3NOnwL5O0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":223266,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/0le8EcVp4x1JjMhwRKIOVi"},"href":"https://api.spotify.com/v1/tracks/0le8EcVp4x1JjMhwRKIOVi","id":"0le8EcVp4x1JjMhwRKIOVi","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":1,"type":"track","uri":"spotify:track:0le8EcVp4x1JjMhwRKIOVi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tTV2cKaA2TXTUOE642C59"},"href":"https://api.spotify.com/v1/albums/0tTV2cKaA2TXTUOE642C59","id":"0tTV2cKaA2TXTUOE642C59","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfe2c03bb1a14bf176c19833"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfe2c03bb1a14bf176c19833"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfe2c03bb1a14bf176c19833"}],"is_playable":true,"name":"Aan","release_date":"2017-05-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0tTV2cKaA2TXTUOE642C59"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0KQX2wRHV2VLjuscfJFNxB"},"href":"https://api.spotify.com/v1/artists/0KQX2wRHV2VLjuscfJFNxB","id":"0KQX2wRHV2VLjuscfJFNxB","name":"BL\u00d8F","type":"artist","uri":"spotify:artist:0KQX2wRHV2VLjuscfJFNxB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5mkzx9Hq5mYTx1LZ0CUGiP"},"href":"https://api.spotify.com/v1/artists/5mkzx9Hq5mYTx1LZ0CUGiP","id":"5mkzx9Hq5mYTx1LZ0CUGiP","name":"Geike","type":"artist","uri":"spotify:artist:5mkzx9Hq5mYTx1LZ0CUGiP"}],"disc_number":1,"duration_ms":223266,"explicit":false,"external_ids":{"isrc":"NLR4H1700015"},"external_urls":{"spotify":"https://open.spotify.com/track/7MOX3ibncypw3xGb4HZVFA"},"href":"https://api.spotify.com/v1/tracks/7MOX3ibncypw3xGb4HZVFA","id":"7MOX3ibncypw3xGb4HZVFA","is_local":false,"is_playable":true,"name":"Zoutelande (feat. Geike)","track_number":15,"type":"track","uri":"spotify:track:7MOX3ibncypw3xGb4HZVFA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ylIKKdMukkuprCgY4ZDFE"},"href":"https://api.spotify.com/v1/artists/2ylIKKdMukkuprCgY4ZDFE","id":"2ylIKKdMukkuprCgY4ZDFE","name":"Donnie","type":"artist","uri":"spotify:artist:2ylIKKdMukkuprCgY4ZDFE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"external_urls":{"spotify":"https://open.spotify.com/album/660ZzT4n5u5LKvsPzmANkY"},"href":"https://api.spotify.com/v1/albums/660ZzT4n5u5LKvsPzmANkY","id":"660ZzT4n5u5LKvsPzmANkY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b9c79743fef568f42169b71b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b9c79743fef568f42169b71b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b9c79743fef568f42169b71b"}],"is_playable":true,"name":"M Van Marketing","release_date":"2018-08-03","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:660ZzT4n5u5LKvsPzmANkY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ylIKKdMukkuprCgY4ZDFE"},"href":"https://api.spotify.com/v1/artists/2ylIKKdMukkuprCgY4ZDFE","id":"2ylIKKdMukkuprCgY4ZDFE","name":"Donnie","type":"artist","uri":"spotify:artist:2ylIKKdMukkuprCgY4ZDFE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"disc_number":1,"duration_ms":125863,"explicit":true,"external_ids":{"isrc":"NLG661800707"},"external_urls":{"spotify":"https://open.spotify.com/track/4pHaft5iymL4elqKkA3Qxb"},"href":"https://api.spotify.com/v1/tracks/4pHaft5iymL4elqKkA3Qxb","id":"4pHaft5iymL4elqKkA3Qxb","is_local":false,"is_playable":true,"name":"M Van Marketing","track_number":6,"type":"track","uri":"spotify:track:4pHaft5iymL4elqKkA3Qxb"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Zoutelande+Bl%C3%B8f%2C+Geike+Arnaert&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZsaWVnJTIwTWV0JTIwTWUlMjBNZWUlMjIlMjBhcnRpc3QlM0ElMjJHdXVzJTIwTWVldXdpcyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZsaWVnJTIwTWV0JTIwTWUlMjBNZWUlMjIlMjBhcnRpc3QlM0ElMjJHdXVzJTIwTWVldXdpcyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Vlieg+Met+Me+Mee%22+artist%3A%22Guus+Meeuwis%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Rood%22%20artist%3A%22Marco%20Borsato%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/6P8MGrO5WKfHnrXOw45jfR"},"href":"https://api.spotify.com/v1/albums/6P8MGrO5WKfHnrXOw45jfR","id":"6P8MGrO5WKfHnrXOw45jfR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c189fdd3cf3ad54e6b8344d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c189fdd3cf3ad54e6b8344d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c189fdd3cf3ad54e6b8344d7"}],"is_playable":true,"name":"#1","release_date":"2011-11-25","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:6P8MGrO5WKfHnrXOw45jfR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":319186,"explicit":false,"external_ids":{"isrc":"NLUM70600609"},"external_urls":{"spotify":"https://open.spotify.com/track/3yxFiZHkQgJmLEyhij30rr"},"href":"https://api.spotify.com/v1/tracks/3yxFiZHkQgJmLEyhij30rr","id":"3yxFiZHkQgJmLEyhij30rr","is_local":false,"is_playable":true,"name":"Rood","track_number":10,"type":"track","uri":"spotify:track:3yxFiZHkQgJmLEyhij30rr"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/58ft6zt2OOWKX21vYkIz9g"},"href":"https://api.spotify.com/v1/albums/58ft6zt2OOWKX21vYkIz9g","id":"58ft6zt2OOWKX21vYkIz9g","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fff45734a34b393fa3b694d6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fff45734a34b393fa3b694d6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fff45734a34b393fa3b694d6"}],"is_playable":true,"name":"Rood","release_date":"2006-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:58ft6zt2OOWKX21vYkIz9g"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":319453,"explicit":false,"external_ids":{"isrc":"NLUM70600609"},"external_urls":{"spotify":"https://open.spotify.com/track/5oejgs2zqoQ9S0fW3qc1h5"},"href":"https://api.spotify.com/v1/tracks/5oejgs2zqoQ9S0fW3qc1h5","id":"5oejgs2zqoQ9S0fW3qc1h5","is_local":false,"is_playable":true,"name":"Rood - Single Version","track_number":1,"type":"track","uri":"spotify:track:5oejgs2zqoQ9S0fW3qc1h5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/2qllg3CJh2TOJAhvgHAyfP"},"href":"https://api.spotify.com/v1/albums/2qllg3CJh2TOJAhvgHAyfP","id":"2qllg3CJh2TOJAhvgHAyfP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c02bc0d3f093d9a97262fd83"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c02bc0d3f093d9a97262fd83"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c02bc0d3f093d9a97262fd83"}],"is_playable":true,"name":"Symphonica In Rosso (Live)","release_date":"2006-12-01","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:2qllg3CJh2TOJAhvgHAyfP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":520159,"explicit":false,"external_ids":{"isrc":"NLUM70601284"},"external_urls":{"spotify":"https://open.spotify.com/track/3xib7JyBX4dEAexzc8bEWb"},"href":"https://api.spotify.com/v1/tracks/3xib7JyBX4dEAexzc8bEWb","id":"3xib7JyBX4dEAexzc8bEWb","is_local":false,"is_playable":true,"name":"Rood - Live","track_number":1,"type":"track","uri":"spotify:track:3xib7JyBX4dEAexzc8bEWb"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2UWFwMXUXbEs79qbI4NdTT"},"href":"https://api.spotify.com/v1/artists/2UWFwMXUXbEs79qbI4NdTT","id":"2UWFwMXUXbEs79qbI4NdTT","name":"Paul de Leeuw","type":"artist","uri":"spotify:artist:2UWFwMXUXbEs79qbI4NdTT"}],"external_urls":{"spotify":"https://open.spotify.com/album/5hT12BDJ5HI3gWdK2bZJLj"},"href":"https://api.spotify.com/v1/albums/5hT12BDJ5HI3gWdK2bZJLj","id":"5hT12BDJ5HI3gWdK2bZJLj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad14e5d9880eb2e775bbb435"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad14e5d9880eb2e775bbb435"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad14e5d9880eb2e775bbb435"}],"is_playable":true,"name":"Symphonica In Rosso 2007 (Live)","release_date":"2007-01-01","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:5hT12BDJ5HI3gWdK2bZJLj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":2,"duration_ms":408533,"explicit":false,"external_ids":{"isrc":"NLUM70700752"},"external_urls":{"spotify":"https://open.spotify.com/track/2U9Blo6w91BqlKZXV5eQBx"},"href":"https://api.spotify.com/v1/tracks/2U9Blo6w91BqlKZXV5eQBx","id":"2U9Blo6w91BqlKZXV5eQBx","is_local":false,"is_playable":true,"name":"Rood - Live","track_number":4,"type":"track","uri":"spotify:track:2U9Blo6w91BqlKZXV5eQBx"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0SfsnGyD8FpIN4U4WCkBZ5"},"href":"https://api.spotify.com/v1/artists/0SfsnGyD8FpIN4U4WCkBZ5","id":"0SfsnGyD8FpIN4U4WCkBZ5","name":"Armin van Buuren","type":"artist","uri":"spotify:artist:0SfsnGyD8FpIN4U4WCkBZ5"}],"external_urls":{"spotify":"https://open.spotify.com/album/1l7NhlUe5CyBHvFUJ5sA9V"},"href":"https://api.spotify.com/v1/albums/1l7NhlUe5CyBHvFUJ5sA9V","id":"1l7NhlUe5CyBHvFUJ5sA9V","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731b3477b6dd10feda44060dfe"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021b3477b6dd10feda44060dfe"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511b3477b6dd10feda44060dfe"}],"is_playable":true,"name":"This is Rood (The Flying Dutch Mash Up)","release_date":"2016-06-05","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1l7NhlUe5CyBHvFUJ5sA9V"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0SfsnGyD8FpIN4U4WCkBZ5"},"href":"https://api.spotify.com/v1/artists/0SfsnGyD8FpIN4U4WCkBZ5","id":"0SfsnGyD8FpIN4U4WCkBZ5","name":"Armin van Buuren","type":"artist","uri":"spotify:artist:0SfsnGyD8FpIN4U4WCkBZ5"}],"disc_number":1,"duration_ms":259846,"explicit":false,"external_ids":{"isrc":"NLF711603881"},"external_urls":{"spotify":"https://open.spotify.com/track/05zhsqZCgS6CKnvkjuT982"},"href":"https://api.spotify.com/v1/tracks/05zhsqZCgS6CKnvkjuT982","id":"05zhsqZCgS6CKnvkjuT982","is_local":false,"is_playable":true,"name":"This is Rood - The Flying Dutch Mash Up","track_number":1,"type":"track","uri":"spotify:track:05zhsqZCgS6CKnvkjuT982"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/58ft6zt2OOWKX21vYkIz9g"},"href":"https://api.spotify.com/v1/albums/58ft6zt2OOWKX21vYkIz9g","id":"58ft6zt2OOWKX21vYkIz9g","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fff45734a34b393fa3b694d6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fff45734a34b393fa3b694d6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fff45734a34b393fa3b694d6"}],"is_playable":true,"name":"Rood","release_date":"2006-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:58ft6zt2OOWKX21vYkIz9g"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":506146,"explicit":false,"external_ids":{"isrc":"NLUM70600611"},"external_urls":{"spotify":"https://open.spotify.com/track/17kly55o0cC1ykfZ2fvnvd"},"href":"https://api.spotify.com/v1/tracks/17kly55o0cC1ykfZ2fvnvd","id":"17kly55o0cC1ykfZ2fvnvd","is_local":false,"is_playable":true,"name":"Rood - Anthem Symphonica In Rosso","track_number":2,"type":"track","uri":"spotify:track:17kly55o0cC1ykfZ2fvnvd"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/3cYE37Mirob5GiB7gbuMRM"},"href":"https://api.spotify.com/v1/albums/3cYE37Mirob5GiB7gbuMRM","id":"3cYE37Mirob5GiB7gbuMRM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d6bb962b4561d88f661d172e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d6bb962b4561d88f661d172e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d6bb962b4561d88f661d172e"}],"is_playable":true,"name":"3Dimensies Live","release_date":"2011-01-01","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:3cYE37Mirob5GiB7gbuMRM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":2,"duration_ms":417293,"explicit":false,"external_ids":{"isrc":"NLUM71100245"},"external_urls":{"spotify":"https://open.spotify.com/track/6vGGkmrRNg7Slf0na7YNiX"},"href":"https://api.spotify.com/v1/tracks/6vGGkmrRNg7Slf0na7YNiX","id":"6vGGkmrRNg7Slf0na7YNiX","is_local":false,"is_playable":true,"name":"Rood - Live","track_number":7,"type":"track","uri":"spotify:track:6vGGkmrRNg7Slf0na7YNiX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/2Rf3Qpa9lGq7q4u7zLDaoA"},"href":"https://api.spotify.com/v1/albums/2Rf3Qpa9lGq7q4u7zLDaoA","id":"2Rf3Qpa9lGq7q4u7zLDaoA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273549180fa896ebbc801ac4faa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02549180fa896ebbc801ac4faa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851549180fa896ebbc801ac4faa"}],"is_playable":true,"name":"Wit Licht LIVE","release_date":"2009-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:2Rf3Qpa9lGq7q4u7zLDaoA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":2,"duration_ms":384293,"explicit":false,"external_ids":{"isrc":"NLUM70900031"},"external_urls":{"spotify":"https://open.spotify.com/track/4LjXCp31h3ulNoXgtdLViv"},"href":"https://api.spotify.com/v1/tracks/4LjXCp31h3ulNoXgtdLViv","id":"4LjXCp31h3ulNoXgtdLViv","is_local":false,"is_playable":true,"name":"Rood - Live","track_number":8,"type":"track","uri":"spotify:track:4LjXCp31h3ulNoXgtdLViv"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/2FqOeVenR9pICaH0mtj5Xg"},"href":"https://api.spotify.com/v1/albums/2FqOeVenR9pICaH0mtj5Xg","id":"2FqOeVenR9pICaH0mtj5Xg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273114815be6cc3d4b869eff53d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02114815be6cc3d4b869eff53d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851114815be6cc3d4b869eff53d"}],"is_playable":true,"name":"Marco Borsato 2003 - 2006","release_date":"2006-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:2FqOeVenR9pICaH0mtj5Xg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":504426,"explicit":false,"external_ids":{"isrc":"NLUM70600611"},"external_urls":{"spotify":"https://open.spotify.com/track/4aVML4ImYMREYuw59A9kIC"},"href":"https://api.spotify.com/v1/tracks/4aVML4ImYMREYuw59A9kIC","id":"4aVML4ImYMREYuw59A9kIC","is_local":false,"is_playable":true,"name":"Rood - Anthem Symphonica In Rosso","track_number":1,"type":"track","uri":"spotify:track:4aVML4ImYMREYuw59A9kIC"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJvb2QlMjIlMjBhcnRpc3QlM0ElMjJNYXJjbyUyMEJvcnNhdG8lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjksIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82UDhNR3JPNVdLZkhuclhPdzQ1amZSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNlA4TUdyTzVXS2ZIbnJYT3c0NWpmUiIsImlkIjoiNlA4TUdyTzVXS2ZIbnJYT3c0NWpmUiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjMTg5ZmRkM2NmM2FkNTRlNmI4MzQ0ZDcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzE4OWZkZDNjZjNhZDU0ZTZiODM0NGQ3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjMTg5ZmRkM2NmM2FkNTRlNmI4MzQ0ZDcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiIzEiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTExLTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlA4TUdyTzVXS2ZIbnJYT3c0NWpmUiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRA==", + "IiwibmFtZSI6Ik1hcmNvIEJvcnNhdG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMTkxODYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFVNNzA2MDA2MDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzN5eEZpWkhrUWdKbUxFeWhpajMwcnIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zeXhGaVpIa1FnSm1MRXloaWozMHJyIiwiaWQiOiIzeXhGaVpIa1FnSm1MRXloaWozMHJyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvb2QiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjN5eEZpWkhrUWdKbUxFeWhpajMwcnIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81OGZ0Nnp0Mk9PV0tYMjF2WWtJejlnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNThmdDZ6dDJPT1dLWDIxdllrSXo5ZyIsImlkIjoiNThmdDZ6dDJPT1dLWDIxdllrSXo5ZyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmZmY0NTczNGEzNGIzOTNmYTNiNjk0ZDYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZmZmNDU3MzRhMzRiMzkzZmEzYjY5NGQ2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmZmY0NTczNGEzNGIzOTNmYTNiNjk0ZDYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm9vZCIsInJlbGVhc2VfZGF0ZSI6IjIwMDYtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIg==", + "OiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NThmdDZ6dDJPT1dLWDIxdllrSXo5ZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzE5NDUzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxVTTcwNjAwNjA5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81b2VqZ3MyenFvUTlTMGZXM3FjMWg1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNW9lamdzMnpxb1E5UzBmVzNxYzFoNSIsImlkIjoiNW9lamdzMnpxb1E5UzBmVzNxYzFoNSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb29kIC0gU2luZ2xlIFZlcnNpb24iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NW9lamdzMnpxb1E5UzBmVzNxYzFoNSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJpZCI6IjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJuYW1lIjoiTWFyY28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMnFsbGczQ0poMlRPSkFodmdIQXlmUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJxbGxnM0NKaDJUT0pBaHZnSEF5ZlAiLCJpZCI6IjJxbGxnM0NKaDJUT0pBaHZnSEF5ZlAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzAyYmMwZDNmMDkzZDlhOTcyNg==", + "MmZkODMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzAyYmMwZDNmMDkzZDlhOTcyNjJmZDgzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjMDJiYzBkM2YwOTNkOWE5NzI2MmZkODMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3ltcGhvbmljYSBJbiBSb3NzbyAoTGl2ZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTEyLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MnFsbGczQ0poMlRPSkFodmdIQXlmUCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NTIwMTU5LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxVTTcwNjAxMjg0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zeGliN0p5Qlg0ZEVBZXh6YzhiRVdiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM3hpYjdKeUJYNGRFQWV4emM4YkVXYiIsImlkIjoiM3hpYjdKeUJYNGRFQWV4emM4YkVXYiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb29kIC0gTGl2ZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozeGliN0p5Qlg0ZEVBZXh6YzhiRVdiIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVV0Z3TVhVWGJFczc5cWJJNE5kVFQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVXRndNWFVYYkVzNzlxYkk0TmRUVCIsImlkIjoiMlVXRndNWFVYYkVzNzlxYkk0TmRUVCIsIm5hbWUiOiJQYXVsIGRlIExlZXV3IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVVw==", + "RndNWFVYYkVzNzlxYkk0TmRUVCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVoVDEyQkRKNUhJM2dXZEsyYlpKTGoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81aFQxMkJESjVISTNnV2RLMmJaSkxqIiwiaWQiOiI1aFQxMkJESjVISTNnV2RLMmJaSkxqIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FkMTRlNWQ5ODgwZWIyZTc3NWJiYjQzNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhZDE0ZTVkOTg4MGViMmU3NzViYmI0MzUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFkMTRlNWQ5ODgwZWIyZTc3NWJiYjQzNSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTeW1waG9uaWNhIEluIFJvc3NvIDIwMDcgKExpdmUpIiwicmVsZWFzZV9kYXRlIjoiMjAwNy0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVoVDEyQkRKNUhJM2dXZEsyYlpKTGoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJpZCI6IjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJuYW1lIjoiTWFyY28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjQwODUzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MVU03MDcwMDc1MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMlU5QmxvNnc5MUJxbEtaWFY1ZVFCeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJVOUJsbzZ3OTFCcWxLWlhWNWVRQngiLCJpZCI6IjJVOUJsbzZ3OTFCcWxLWlhWNWVRQngiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm9vZCAtIExpdmUiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MlU5Qg==", + "bG82dzkxQnFsS1pYVjVlUUJ4In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJpZCI6IjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJuYW1lIjoiTWFyY28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTZnNuR3lEOEZwSU40VTRXQ2tCWjUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFNmc25HeUQ4RnBJTjRVNFdDa0JaNSIsImlkIjoiMFNmc25HeUQ4RnBJTjRVNFdDa0JaNSIsIm5hbWUiOiJBcm1pbiB2YW4gQnV1cmVuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTZnNuR3lEOEZwSU40VTRXQ2tCWjUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xbDdOaGxVZTVDeUJIdkZVSjVzQTlWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWw3TmhsVWU1Q3lCSHZGVUo1c0E5ViIsImlkIjoiMWw3TmhsVWU1Q3lCSHZGVUo1c0E5ViIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYjM0NzdiNmRkMTBmZWRhNDQwNjBkZmUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWIzNDc3YjZkZDEwZmVkYTQ0MDYwZGZlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYjM0NzdiNmRkMTBmZWRhNDQwNjBkZmUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhpcyBpcyBSb29kIChUaGUgRmx5aW5nIER1dGNoIE1hc2ggVXApIiwicmVsZWFzZV9kYXRlIjoiMjAxNi0wNi0wNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MWw3TmhsVWU1Q3lCSHZGVUo1c0E5ViJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWA==", + "YnRsTDNyMmQ1SEpFbnNGRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwiaWQiOiIzRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwibmFtZSI6Ik1hcmNvIEJvcnNhdG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU2Zzbkd5RDhGcElONFU0V0NrQlo1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTZnNuR3lEOEZwSU40VTRXQ2tCWjUiLCJpZCI6IjBTZnNuR3lEOEZwSU40VTRXQ2tCWjUiLCJuYW1lIjoiQXJtaW4gdmFuIEJ1dXJlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU2Zzbkd5RDhGcElONFU0V0NrQlo1In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1OTg0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRjcxMTYwMzg4MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMDV6aHNxWkNnUzZDS252a2p1VDk4MiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzA1emhzcVpDZ1M2Q0tudmtqdVQ5ODIiLCJpZCI6IjA1emhzcVpDZ1M2Q0tudmtqdVQ5ODIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhpcyBpcyBSb29kIC0gVGhlIEZseWluZyBEdXRjaCBNYXNoIFVwIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjA1emhzcVpDZ1M2Q0tudmtqdVQ5ODIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81OGZ0Nnp0Mk9PV0tYMjF2WWtJejlnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNThmdDZ6dDJPT1dLWDIxdllrSXo5ZyIsImlkIg==", + "OiI1OGZ0Nnp0Mk9PV0tYMjF2WWtJejlnIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ZmZjQ1NzM0YTM0YjM5M2ZhM2I2OTRkNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmZmY0NTczNGEzNGIzOTNmYTNiNjk0ZDYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWZmZjQ1NzM0YTM0YjM5M2ZhM2I2OTRkNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb29kIiwicmVsZWFzZV9kYXRlIjoiMjAwNi0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NThmdDZ6dDJPT1dLWDIxdllrSXo5ZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NTA2MTQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxVTTcwNjAwNjExIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xN2tseTU1bzBjQzF5a2ZaMmZ2bnZkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMTdrbHk1NW8wY0MxeWtmWjJmdm52ZCIsImlkIjoiMTdrbHk1NW8wY0MxeWtmWjJmdm52ZCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb29kIC0gQW50aGVtIFN5bXBob25pY2EgSW4gUm9zc28iLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MTdrbHk1NW8wY0MxeWtmWjJmdm52ZCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MQ==", + "L2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zY1lFMzdNaXJvYjVHaUI3Z2J1TVJNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2NZRTM3TWlyb2I1R2lCN2didU1STSIsImlkIjoiM2NZRTM3TWlyb2I1R2lCN2didU1STSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkNmJiOTYyYjQ1NjFkODhmNjYxZDE3MmUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZDZiYjk2MmI0NTYxZDg4ZjY2MWQxNzJlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkNmJiOTYyYjQ1NjFkODhmNjYxZDE3MmUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiM0RpbWVuc2llcyBMaXZlIiwicmVsZWFzZV9kYXRlIjoiMjAxMS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNjWUUzN01pcm9iNUdpQjdnYnVNUk0ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJpZCI6IjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJuYW1lIjoiTWFyY28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjQxNzI5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MVU03MTEwMDI0NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnZHR2ttclJOZzdTbGYwbmE3WU5pWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ2R0drbXJSTmc3U2xmMG5hN1lOaVgiLCJpZCI6IjZ2R0drbXJSTmc3U2xmMG5hN1lOaVgiLCJpcw==", + "X2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb29kIC0gTGl2ZSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2dkdHa21yUk5nN1NsZjBuYTdZTmlYIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yUmYzUXBhOWxHcTdxNHU3ekxEYW9BIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMlJmM1FwYTlsR3E3cTR1N3pMRGFvQSIsImlkIjoiMlJmM1FwYTlsR3E3cTR1N3pMRGFvQSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1NDkxODBmYTg5NmViYmM4MDFhYzRmYWEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTQ5MTgwZmE4OTZlYmJjODAxYWM0ZmFhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1NDkxODBmYTg5NmViYmM4MDFhYzRmYWEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2l0IExpY2h0IExJVkUiLCJyZWxlYXNlX2RhdGUiOiIyMDA5LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MlJmM1FwYTlsR3E3cTR1N3pMRGFvQSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bA==", + "TDNyMmQ1SEpFbnNGRCJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjozODQyOTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFVNNzA5MDAwMzEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRMalhDcDMxaDN1bE5vWGd0ZExWaXYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80TGpYQ3AzMWgzdWxOb1hndGRMVml2IiwiaWQiOiI0TGpYQ3AzMWgzdWxOb1hndGRMVml2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvb2QgLSBMaXZlIiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRMalhDcDMxaDN1bE5vWGd0ZExWaXYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwiaWQiOiIzRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwibmFtZSI6Ik1hcmNvIEJvcnNhdG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJGcU9lVmVuUjlwSUNhSDBtdGo1WGcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yRnFPZVZlblI5cElDYUgwbXRqNVhnIiwiaWQiOiIyRnFPZVZlblI5cElDYUgwbXRqNVhnIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzExNDgxNWJlNmNjM2Q0Yjg2OWVmZjUzZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxMTQ4MTViZTZjYzNkNGI4NjllZmY1M2QifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTExNDgxNWJlNmNjM2Q0Yjg2OWVmZjUzZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIDIwMDMgLSAyMDA2IiwicmVsZWFzZV9kYXRlIjoiMjAwNi0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLA==", + "InVyaSI6InNwb3RpZnk6YWxidW06MkZxT2VWZW5SOXBJQ2FIMG10ajVYZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NTA0NDI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxVTTcwNjAwNjExIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80YVZNTDRJbVlNUkVZdXc1OUE5a0lDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGFWTUw0SW1ZTVJFWXV3NTlBOWtJQyIsImlkIjoiNGFWTUw0SW1ZTVJFWXV3NTlBOWtJQyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb29kIC0gQW50aGVtIFN5bXBob25pY2EgSW4gUm9zc28iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGFWTUw0SW1ZTVJFWXV3NTlBOWtJQyJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Rood%22+artist%3A%22Marco+Borsato%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Het%20Is%20Een%20Nacht...%22%20artist%3A%22Guus%20Meeuwis%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4gWTRENkdGBRJNldLtEIyZ"},"href":"https://api.spotify.com/v1/albums/4gWTRENkdGBRJNldLtEIyZ","id":"4gWTRENkdGBRJNldLtEIyZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27362cf714b3d512d1ce48f6d90"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0262cf714b3d512d1ce48f6d90"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485162cf714b3d512d1ce48f6d90"}],"is_playable":true,"name":"Verbazing","release_date":"1996-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:4gWTRENkdGBRJNldLtEIyZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZywabPnRCoHjfPJfQavrA"},"href":"https://api.spotify.com/v1/artists/2ZywabPnRCoHjfPJfQavrA","id":"2ZywabPnRCoHjfPJfQavrA","name":"Vagant","type":"artist","uri":"spotify:artist:2ZywabPnRCoHjfPJfQavrA"}],"disc_number":1,"duration_ms":225040,"explicit":false,"external_ids":{"isrc":"NLB590800101"},"external_urls":{"spotify":"https://open.spotify.com/track/69B6SgxGtxSzeTbl6IRGwP"},"href":"https://api.spotify.com/v1/tracks/69B6SgxGtxSzeTbl6IRGwP","id":"69B6SgxGtxSzeTbl6IRGwP","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht)","track_number":4,"type":"track","uri":"spotify:track:69B6SgxGtxSzeTbl6IRGwP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/1BegCmidDeh43ntUxDGODt"},"href":"https://api.spotify.com/v1/albums/1BegCmidDeh43ntUxDGODt","id":"1BegCmidDeh43ntUxDGODt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27369fd0203685172ddc8edc973"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0269fd0203685172ddc8edc973"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485169fd0203685172ddc8edc973"}],"is_playable":true,"name":"Live In Het Philips Stadion","release_date":"2006-01-01","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:1BegCmidDeh43ntUxDGODt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"disc_number":1,"duration_ms":279386,"explicit":false,"external_ids":{"isrc":"NLA270601105"},"external_urls":{"spotify":"https://open.spotify.com/track/5as4m1rmKAmL2jbECYkZKB"},"href":"https://api.spotify.com/v1/tracks/5as4m1rmKAmL2jbECYkZKB","id":"5as4m1rmKAmL2jbECYkZKB","is_local":false,"is_playable":true,"name":"Het Is Een Nacht","track_number":4,"type":"track","uri":"spotify:track:5as4m1rmKAmL2jbECYkZKB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4q2mtBkyPrFynvTRbi5HOv"},"href":"https://api.spotify.com/v1/albums/4q2mtBkyPrFynvTRbi5HOv","id":"4q2mtBkyPrFynvTRbi5HOv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e6decdfd6276b57efe588991"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e6decdfd6276b57efe588991"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e6decdfd6276b57efe588991"}],"is_playable":true,"name":"Groots Met Een Zachte G 2013","release_date":"2013-01-01","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:4q2mtBkyPrFynvTRbi5HOv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/30mNTnmvPn3HwXA5dW1Iza"},"href":"https://api.spotify.com/v1/artists/30mNTnmvPn3HwXA5dW1Iza","id":"30mNTnmvPn3HwXA5dW1Iza","name":"Racoon","type":"artist","uri":"spotify:artist:30mNTnmvPn3HwXA5dW1Iza"}],"disc_number":2,"duration_ms":239200,"explicit":false,"external_ids":{"isrc":"NLUM71300235"},"external_urls":{"spotify":"https://open.spotify.com/track/1JpM0DYtVF2YKeEJ1D6rIG"},"href":"https://api.spotify.com/v1/tracks/1JpM0DYtVF2YKeEJ1D6rIG","id":"1JpM0DYtVF2YKeEJ1D6rIG","is_local":false,"is_playable":true,"name":"Het Is Een Nacht / Love You More - Live @ PSV Stadion Eindhoven June 2013","track_number":5,"type":"track","uri":"spotify:track:1JpM0DYtVF2YKeEJ1D6rIG"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4gWTRENkdGBRJNldLtEIyZ"},"href":"https://api.spotify.com/v1/albums/4gWTRENkdGBRJNldLtEIyZ","id":"4gWTRENkdGBRJNldLtEIyZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27362cf714b3d512d1ce48f6d90"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0262cf714b3d512d1ce48f6d90"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485162cf714b3d512d1ce48f6d90"}],"is_playable":true,"name":"Verbazing","release_date":"1996-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:4gWTRENkdGBRJNldLtEIyZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZywabPnRCoHjfPJfQavrA"},"href":"https://api.spotify.com/v1/artists/2ZywabPnRCoHjfPJfQavrA","id":"2ZywabPnRCoHjfPJfQavrA","name":"Vagant","type":"artist","uri":"spotify:artist:2ZywabPnRCoHjfPJfQavrA"}],"disc_number":1,"duration_ms":286960,"explicit":false,"external_ids":{"isrc":"NLB590800102"},"external_urls":{"spotify":"https://open.spotify.com/track/7k4P9gGrOzGkRONrbSiXfr"},"href":"https://api.spotify.com/v1/tracks/7k4P9gGrOzGkRONrbSiXfr","id":"7k4P9gGrOzGkRONrbSiXfr","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht) - Live Versie","track_number":13,"type":"track","uri":"spotify:track:7k4P9gGrOzGkRONrbSiXfr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Ddv5pUl9FzLGf35J6YSJW"},"href":"https://api.spotify.com/v1/albums/0Ddv5pUl9FzLGf35J6YSJW","id":"0Ddv5pUl9FzLGf35J6YSJW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27366da6482ab60dc4c75d5fd3a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0266da6482ab60dc4c75d5fd3a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485166da6482ab60dc4c75d5fd3a"}],"is_playable":true,"name":"Groots De Laatste - Live In Het Philips Stadion","release_date":"2024-10-24","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:0Ddv5pUl9FzLGf35J6YSJW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"disc_number":1,"duration_ms":303498,"explicit":false,"external_ids":{"isrc":"NLQ7J2400032"},"external_urls":{"spotify":"https://open.spotify.com/track/62GqY0xsQDeikeAKkExXGM"},"href":"https://api.spotify.com/v1/tracks/62GqY0xsQDeikeAKkExXGM","id":"62GqY0xsQDeikeAKkExXGM","is_local":false,"is_playable":true,"name":"Het Is Een Nacht\u2026 (Levensecht) - Live @ Philips Stadion, Eindhoven 2024","track_number":24,"type":"track","uri":"spotify:track:62GqY0xsQDeikeAKkExXGM"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/0t6i4FTsL5SQ4iydzkFP5d"},"href":"https://api.spotify.com/v1/albums/0t6i4FTsL5SQ4iydzkFP5d","id":"0t6i4FTsL5SQ4iydzkFP5d","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c89c3c33d5626baaa61eb0f0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c89c3c33d5626baaa61eb0f0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c89c3c33d5626baaa61eb0f0"}],"is_playable":true,"name":"Groots Met Een Zachte G 2022 (Live @ Philips Stadion, Eindhoven)","release_date":"2022-12-09","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:0t6i4FTsL5SQ4iydzkFP5d"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yDkaiPTFbHGWCMXAEBt5Q"},"href":"https://api.spotify.com/v1/artists/5yDkaiPTFbHGWCMXAEBt5Q","id":"5yDkaiPTFbHGWCMXAEBt5Q","name":"Kraantje Pappie","type":"artist","uri":"spotify:artist:5yDkaiPTFbHGWCMXAEBt5Q"}],"disc_number":1,"duration_ms":346960,"explicit":false,"external_ids":{"isrc":"NLQ7J2200046"},"external_urls":{"spotify":"https://open.spotify.com/track/5BcPPBwDTB2ee47ASBZ1jB"},"href":"https://api.spotify.com/v1/tracks/5BcPPBwDTB2ee47ASBZ1jB","id":"5BcPPBwDTB2ee47ASBZ1jB","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht) - Nacht - Live @ Philips Stadion, Eindhoven 2022","track_number":15,"type":"track","uri":"spotify:track:5BcPPBwDTB2ee47ASBZ1jB"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/6fWsuxfmYmkc49VgRHb5Eq"},"href":"https://api.spotify.com/v1/albums/6fWsuxfmYmkc49VgRHb5Eq","id":"6fWsuxfmYmkc49VgRHb5Eq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27306dd42d1fee46676b09ee8c5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0206dd42d1fee46676b09ee8c5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485106dd42d1fee46676b09ee8c5"}],"is_playable":true,"name":"Het Beste Van Guus Meeuwis","release_date":"2010-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6fWsuxfmYmkc49VgRHb5Eq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZywabPnRCoHjfPJfQavrA"},"href":"https://api.spotify.com/v1/artists/2ZywabPnRCoHjfPJfQavrA","id":"2ZywabPnRCoHjfPJfQavrA","name":"Vagant","type":"artist","uri":"spotify:artist:2ZywabPnRCoHjfPJfQavrA"}],"disc_number":1,"duration_ms":226560,"explicit":false,"external_ids":{"isrc":"NLB590800101"},"external_urls":{"spotify":"https://open.spotify.com/track/7GUZ9LcqvI4R1wQGvWdM59"},"href":"https://api.spotify.com/v1/tracks/7GUZ9LcqvI4R1wQGvWdM59","id":"7GUZ9LcqvI4R1wQGvWdM59","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht)","track_number":9,"type":"track","uri":"spotify:track:7GUZ9LcqvI4R1wQGvWdM59"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/1qFfzdsLXQQPM7trx3ustr"},"href":"https://api.spotify.com/v1/albums/1qFfzdsLXQQPM7trx3ustr","id":"1qFfzdsLXQQPM7trx3ustr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733350d0387336d5be7ba9f251"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023350d0387336d5be7ba9f251"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513350d0387336d5be7ba9f251"}],"is_playable":true,"name":"Armen Open (Deluxe Editie)","release_date":"2011-01-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:1qFfzdsLXQQPM7trx3ustr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Ek1EdkcbRFvSDJj9j5JXQ"},"href":"https://api.spotify.com/v1/artists/3Ek1EdkcbRFvSDJj9j5JXQ","id":"3Ek1EdkcbRFvSDJj9j5JXQ","name":"The Baseballs","type":"artist","uri":"spotify:artist:3Ek1EdkcbRFvSDJj9j5JXQ"}],"disc_number":2,"duration_ms":187946,"explicit":false,"external_ids":{"isrc":"DEA621100185"},"external_urls":{"spotify":"https://open.spotify.com/track/7v0UHYYdIAw1ZY5Kg20kiW"},"href":"https://api.spotify.com/v1/tracks/7v0UHYYdIAw1ZY5Kg20kiW","id":"7v0UHYYdIAw1ZY5Kg20kiW","is_local":false,"is_playable":true,"name":"This Is A Night (Het Is Een Nacht)","track_number":5,"type":"track","uri":"spotify:track:7v0UHYYdIAw1ZY5Kg20kiW"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4IrojBEsEUYzbTOkJzyz5e"},"href":"https://api.spotify.com/v1/albums/4IrojBEsEUYzbTOkJzyz5e","id":"4IrojBEsEUYzbTOkJzyz5e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f9aab85305006c76fb28247c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f9aab85305006c76fb28247c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f9aab85305006c76fb28247c"}],"is_playable":true,"name":"Groots Met Een Zachte G Live In Het Philips Stadion 2008","release_date":"2008-01-01","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:4IrojBEsEUYzbTOkJzyz5e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"disc_number":1,"duration_ms":424866,"explicit":false,"external_ids":{"isrc":"NLA270800424"},"external_urls":{"spotify":"https://open.spotify.com/track/026qMmLRqV03ynatiit26G"},"href":"https://api.spotify.com/v1/tracks/026qMmLRqV03ynatiit26G","id":"026qMmLRqV03ynatiit26G","is_local":false,"is_playable":true,"name":"Het Is Een Nacht - Live From Philips Stadion, Eindhoven / 2008","track_number":11,"type":"track","uri":"spotify:track:026qMmLRqV03ynatiit26G"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/5jiTnsMatYDKTcrUFdX5vh"},"href":"https://api.spotify.com/v1/albums/5jiTnsMatYDKTcrUFdX5vh","id":"5jiTnsMatYDKTcrUFdX5vh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f086e0cc3a1d7d815511790c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f086e0cc3a1d7d815511790c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f086e0cc3a1d7d815511790c"}],"is_playable":true,"name":"Het Is Een Nacht... (Levensecht)","release_date":"1995-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:5jiTnsMatYDKTcrUFdX5vh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZywabPnRCoHjfPJfQavrA"},"href":"https://api.spotify.com/v1/artists/2ZywabPnRCoHjfPJfQavrA","id":"2ZywabPnRCoHjfPJfQavrA","name":"Vagant","type":"artist","uri":"spotify:artist:2ZywabPnRCoHjfPJfQavrA"}],"disc_number":1,"duration_ms":226733,"explicit":false,"external_ids":{"isrc":"NLB590800101"},"external_urls":{"spotify":"https://open.spotify.com/track/1r7UTkce4bDSbKA3gBIb4a"},"href":"https://api.spotify.com/v1/tracks/1r7UTkce4bDSbKA3gBIb4a","id":"1r7UTkce4bDSbKA3gBIb4a","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht)","track_number":1,"type":"track","uri":"spotify:track:1r7UTkce4bDSbKA3gBIb4a"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Het%20Is%20Een%20Nacht...%22%20artist%3A%22Guus%20Meeuwis%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4gWTRENkdGBRJNldLtEIyZ"},"href":"https://api.spotify.com/v1/albums/4gWTRENkdGBRJNldLtEIyZ","id":"4gWTRENkdGBRJNldLtEIyZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27362cf714b3d512d1ce48f6d90"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0262cf714b3d512d1ce48f6d90"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485162cf714b3d512d1ce48f6d90"}],"is_playable":true,"name":"Verbazing","release_date":"1996-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:4gWTRENkdGBRJNldLtEIyZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZywabPnRCoHjfPJfQavrA"},"href":"https://api.spotify.com/v1/artists/2ZywabPnRCoHjfPJfQavrA","id":"2ZywabPnRCoHjfPJfQavrA","name":"Vagant","type":"artist","uri":"spotify:artist:2ZywabPnRCoHjfPJfQavrA"}],"disc_number":1,"duration_ms":225040,"explicit":false,"external_ids":{"isrc":"NLB590800101"},"external_urls":{"spotify":"https://open.spotify.com/track/69B6SgxGtxSzeTbl6IRGwP"},"href":"https://api.spotify.com/v1/tracks/69B6SgxGtxSzeTbl6IRGwP","id":"69B6SgxGtxSzeTbl6IRGwP","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht)","track_number":4,"type":"track","uri":"spotify:track:69B6SgxGtxSzeTbl6IRGwP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/1BegCmidDeh43ntUxDGODt"},"href":"https://api.spotify.com/v1/albums/1BegCmidDeh43ntUxDGODt","id":"1BegCmidDeh43ntUxDGODt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27369fd0203685172ddc8edc973"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0269fd0203685172ddc8edc973"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485169fd0203685172ddc8edc973"}],"is_playable":true,"name":"Live In Het Philips Stadion","release_date":"2006-01-01","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:1BegCmidDeh43ntUxDGODt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"disc_number":1,"duration_ms":279386,"explicit":false,"external_ids":{"isrc":"NLA270601105"},"external_urls":{"spotify":"https://open.spotify.com/track/5as4m1rmKAmL2jbECYkZKB"},"href":"https://api.spotify.com/v1/tracks/5as4m1rmKAmL2jbECYkZKB","id":"5as4m1rmKAmL2jbECYkZKB","is_local":false,"is_playable":true,"name":"Het Is Een Nacht","track_number":4,"type":"track","uri":"spotify:track:5as4m1rmKAmL2jbECYkZKB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4q2mtBkyPrFynvTRbi5HOv"},"href":"https://api.spotify.com/v1/albums/4q2mtBkyPrFynvTRbi5HOv","id":"4q2mtBkyPrFynvTRbi5HOv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e6decdfd6276b57efe588991"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e6decdfd6276b57efe588991"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e6decdfd6276b57efe588991"}],"is_playable":true,"name":"Groots Met Een Zachte G 2013","release_date":"2013-01-01","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:4q2mtBkyPrFynvTRbi5HOv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/30mNTnmvPn3HwXA5dW1Iza"},"href":"https://api.spotify.com/v1/artists/30mNTnmvPn3HwXA5dW1Iza","id":"30mNTnmvPn3HwXA5dW1Iza","name":"Racoon","type":"artist","uri":"spotify:artist:30mNTnmvPn3HwXA5dW1Iza"}],"disc_number":2,"duration_ms":239200,"explicit":false,"external_ids":{"isrc":"NLUM71300235"},"external_urls":{"spotify":"https://open.spotify.com/track/1JpM0DYtVF2YKeEJ1D6rIG"},"href":"https://api.spotify.com/v1/tracks/1JpM0DYtVF2YKeEJ1D6rIG","id":"1JpM0DYtVF2YKeEJ1D6rIG","is_local":false,"is_playable":true,"name":"Het Is Een Nacht / Love You More - Live @ PSV Stadion Eindhoven June 2013","track_number":5,"type":"track","uri":"spotify:track:1JpM0DYtVF2YKeEJ1D6rIG"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4gWTRENkdGBRJNldLtEIyZ"},"href":"https://api.spotify.com/v1/albums/4gWTRENkdGBRJNldLtEIyZ","id":"4gWTRENkdGBRJNldLtEIyZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27362cf714b3d512d1ce48f6d90"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0262cf714b3d512d1ce48f6d90"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485162cf714b3d512d1ce48f6d90"}],"is_playable":true,"name":"Verbazing","release_date":"1996-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:4gWTRENkdGBRJNldLtEIyZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZywabPnRCoHjfPJfQavrA"},"href":"https://api.spotify.com/v1/artists/2ZywabPnRCoHjfPJfQavrA","id":"2ZywabPnRCoHjfPJfQavrA","name":"Vagant","type":"artist","uri":"spotify:artist:2ZywabPnRCoHjfPJfQavrA"}],"disc_number":1,"duration_ms":286960,"explicit":false,"external_ids":{"isrc":"NLB590800102"},"external_urls":{"spotify":"https://open.spotify.com/track/7k4P9gGrOzGkRONrbSiXfr"},"href":"https://api.spotify.com/v1/tracks/7k4P9gGrOzGkRONrbSiXfr","id":"7k4P9gGrOzGkRONrbSiXfr","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht) - Live Versie","track_number":13,"type":"track","uri":"spotify:track:7k4P9gGrOzGkRONrbSiXfr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Ddv5pUl9FzLGf35J6YSJW"},"href":"https://api.spotify.com/v1/albums/0Ddv5pUl9FzLGf35J6YSJW","id":"0Ddv5pUl9FzLGf35J6YSJW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27366da6482ab60dc4c75d5fd3a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0266da6482ab60dc4c75d5fd3a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485166da6482ab60dc4c75d5fd3a"}],"is_playable":true,"name":"Groots De Laatste - Live In Het Philips Stadion","release_date":"2024-10-24","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:0Ddv5pUl9FzLGf35J6YSJW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"disc_number":1,"duration_ms":303498,"explicit":false,"external_ids":{"isrc":"NLQ7J2400032"},"external_urls":{"spotify":"https://open.spotify.com/track/62GqY0xsQDeikeAKkExXGM"},"href":"https://api.spotify.com/v1/tracks/62GqY0xsQDeikeAKkExXGM","id":"62GqY0xsQDeikeAKkExXGM","is_local":false,"is_playable":true,"name":"Het Is Een Nacht\u2026 (Levensecht) - Live @ Philips Stadion, Eindhoven 2024","track_number":24,"type":"track","uri":"spotify:track:62GqY0xsQDeikeAKkExXGM"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/0t6i4FTsL5SQ4iydzkFP5d"},"href":"https://api.spotify.com/v1/albums/0t6i4FTsL5SQ4iydzkFP5d","id":"0t6i4FTsL5SQ4iydzkFP5d","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c89c3c33d5626baaa61eb0f0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c89c3c33d5626baaa61eb0f0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c89c3c33d5626baaa61eb0f0"}],"is_playable":true,"name":"Groots Met Een Zachte G 2022 (Live @ Philips Stadion, Eindhoven)","release_date":"2022-12-09","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:0t6i4FTsL5SQ4iydzkFP5d"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5yDkaiPTFbHGWCMXAEBt5Q"},"href":"https://api.spotify.com/v1/artists/5yDkaiPTFbHGWCMXAEBt5Q","id":"5yDkaiPTFbHGWCMXAEBt5Q","name":"Kraantje Pappie","type":"artist","uri":"spotify:artist:5yDkaiPTFbHGWCMXAEBt5Q"}],"disc_number":1,"duration_ms":346960,"explicit":false,"external_ids":{"isrc":"NLQ7J2200046"},"external_urls":{"spotify":"https://open.spotify.com/track/5BcPPBwDTB2ee47ASBZ1jB"},"href":"https://api.spotify.com/v1/tracks/5BcPPBwDTB2ee47ASBZ1jB","id":"5BcPPBwDTB2ee47ASBZ1jB","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht) - Nacht - Live @ Philips Stadion, Eindhoven 2022","track_number":15,"type":"track","uri":"spotify:track:5BcPPBwDTB2ee47ASBZ1jB"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/6fWsuxfmYmkc49VgRHb5Eq"},"href":"https://api.spotify.com/v1/albums/6fWsuxfmYmkc49VgRHb5Eq","id":"6fWsuxfmYmkc49VgRHb5Eq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27306dd42d1fee46676b09ee8c5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0206dd42d1fee46676b09ee8c5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485106dd42d1fee46676b09ee8c5"}],"is_playable":true,"name":"Het Beste Van Guus Meeuwis","release_date":"2010-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6fWsuxfmYmkc49VgRHb5Eq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZywabPnRCoHjfPJfQavrA"},"href":"https://api.spotify.com/v1/artists/2ZywabPnRCoHjfPJfQavrA","id":"2ZywabPnRCoHjfPJfQavrA","name":"Vagant","type":"artist","uri":"spotify:artist:2ZywabPnRCoHjfPJfQavrA"}],"disc_number":1,"duration_ms":226560,"explicit":false,"external_ids":{"isrc":"NLB590800101"},"external_urls":{"spotify":"https://open.spotify.com/track/7GUZ9LcqvI4R1wQGvWdM59"},"href":"https://api.spotify.com/v1/tracks/7GUZ9LcqvI4R1wQGvWdM59","id":"7GUZ9LcqvI4R1wQGvWdM59","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht)","track_number":9,"type":"track","uri":"spotify:track:7GUZ9LcqvI4R1wQGvWdM59"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/1qFfzdsLXQQPM7trx3ustr"},"href":"https://api.spotify.com/v1/albums/1qFfzdsLXQQPM7trx3ustr","id":"1qFfzdsLXQQPM7trx3ustr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733350d0387336d5be7ba9f251"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023350d0387336d5be7ba9f251"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513350d0387336d5be7ba9f251"}],"is_playable":true,"name":"Armen Open (Deluxe Editie)","release_date":"2011-01-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:1qFfzdsLXQQPM7trx3ustr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Ek1EdkcbRFvSDJj9j5JXQ"},"href":"https://api.spotify.com/v1/artists/3Ek1EdkcbRFvSDJj9j5JXQ","id":"3Ek1EdkcbRFvSDJj9j5JXQ","name":"The Baseballs","type":"artist","uri":"spotify:artist:3Ek1EdkcbRFvSDJj9j5JXQ"}],"disc_number":2,"duration_ms":187946,"explicit":false,"external_ids":{"isrc":"DEA621100185"},"external_urls":{"spotify":"https://open.spotify.com/track/7v0UHYYdIAw1ZY5Kg20kiW"},"href":"https://api.spotify.com/v1/tracks/7v0UHYYdIAw1ZY5Kg20kiW","id":"7v0UHYYdIAw1ZY5Kg20kiW","is_local":false,"is_playable":true,"name":"This Is A Night (Het Is Een Nacht)","track_number":5,"type":"track","uri":"spotify:track:7v0UHYYdIAw1ZY5Kg20kiW"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4IrojBEsEUYzbTOkJzyz5e"},"href":"https://api.spotify.com/v1/albums/4IrojBEsEUYzbTOkJzyz5e","id":"4IrojBEsEUYzbTOkJzyz5e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f9aab85305006c76fb28247c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f9aab85305006c76fb28247c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f9aab85305006c76fb28247c"}],"is_playable":true,"name":"Groots Met Een Zachte G Live In Het Philips Stadion 2008","release_date":"2008-01-01","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:4IrojBEsEUYzbTOkJzyz5e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"disc_number":1,"duration_ms":424866,"explicit":false,"external_ids":{"isrc":"NLA270800424"},"external_urls":{"spotify":"https://open.spotify.com/track/026qMmLRqV03ynatiit26G"},"href":"https://api.spotify.com/v1/tracks/026qMmLRqV03ynatiit26G","id":"026qMmLRqV03ynatiit26G","is_local":false,"is_playable":true,"name":"Het Is Een Nacht - Live From Philips Stadion, Eindhoven / 2008","track_number":11,"type":"track","uri":"spotify:track:026qMmLRqV03ynatiit26G"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"}],"external_urls":{"spotify":"https://open.spotify.com/album/5jiTnsMatYDKTcrUFdX5vh"},"href":"https://api.spotify.com/v1/albums/5jiTnsMatYDKTcrUFdX5vh","id":"5jiTnsMatYDKTcrUFdX5vh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f086e0cc3a1d7d815511790c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f086e0cc3a1d7d815511790c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f086e0cc3a1d7d815511790c"}],"is_playable":true,"name":"Het Is Een Nacht... (Levensecht)","release_date":"1995-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:5jiTnsMatYDKTcrUFdX5vh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/72qVrKXRp9GeFQOesj0Pmv"},"href":"https://api.spotify.com/v1/artists/72qVrKXRp9GeFQOesj0Pmv","id":"72qVrKXRp9GeFQOesj0Pmv","name":"Guus Meeuwis","type":"artist","uri":"spotify:artist:72qVrKXRp9GeFQOesj0Pmv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZywabPnRCoHjfPJfQavrA"},"href":"https://api.spotify.com/v1/artists/2ZywabPnRCoHjfPJfQavrA","id":"2ZywabPnRCoHjfPJfQavrA","name":"Vagant","type":"artist","uri":"spotify:artist:2ZywabPnRCoHjfPJfQavrA"}],"disc_number":1,"duration_ms":226733,"explicit":false,"external_ids":{"isrc":"NLB590800101"},"external_urls":{"spotify":"https://open.spotify.com/track/1r7UTkce4bDSbKA3gBIb4a"},"href":"https://api.spotify.com/v1/tracks/1r7UTkce4bDSbKA3gBIb4a","id":"1r7UTkce4bDSbKA3gBIb4a","is_local":false,"is_playable":true,"name":"Het Is Een Nacht... (Levensecht)","track_number":1,"type":"track","uri":"spotify:track:1r7UTkce4bDSbKA3gBIb4a"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Het+Is+Een+Nacht...%22+artist%3A%22Guus+Meeuwis%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Zo%20Ver%20Weg%20Marco%20Borsato&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Zo%20Ver%20Weg%20Marco%20Borsato&type=track","offset":0,"previous":null,"total":18,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MP0NXMhl5TfFKtG3Q5uk2"},"href":"https://api.spotify.com/v1/artists/5MP0NXMhl5TfFKtG3Q5uk2","id":"5MP0NXMhl5TfFKtG3Q5uk2","name":"Def Rhymz","type":"artist","uri":"spotify:artist:5MP0NXMhl5TfFKtG3Q5uk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/1dbz3bcXwCQUMZr226anyI"},"href":"https://api.spotify.com/v1/albums/1dbz3bcXwCQUMZr226anyI","id":"1dbz3bcXwCQUMZr226anyI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f9af5ecd9f5f65ee5805c60"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f9af5ecd9f5f65ee5805c60"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f9af5ecd9f5f65ee5805c60"}],"is_playable":true,"name":"De Allergoeiste (Reissue)","release_date":"2001-01-01","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:1dbz3bcXwCQUMZr226anyI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MP0NXMhl5TfFKtG3Q5uk2"},"href":"https://api.spotify.com/v1/artists/5MP0NXMhl5TfFKtG3Q5uk2","id":"5MP0NXMhl5TfFKtG3Q5uk2","name":"Def Rhymz","type":"artist","uri":"spotify:artist:5MP0NXMhl5TfFKtG3Q5uk2"}],"disc_number":1,"duration_ms":229573,"explicit":false,"external_ids":{"isrc":"NLA359900209"},"external_urls":{"spotify":"https://open.spotify.com/track/6Iaj06EGyIvSSRHBjLBwh8"},"href":"https://api.spotify.com/v1/tracks/6Iaj06EGyIvSSRHBjLBwh8","id":"6Iaj06EGyIvSSRHBjLBwh8","is_local":false,"is_playable":true,"name":"Doekoe","track_number":8,"type":"track","uri":"spotify:track:6Iaj06EGyIvSSRHBjLBwh8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1e4opLDDJ52zacE50hm2sv"},"href":"https://api.spotify.com/v1/artists/1e4opLDDJ52zacE50hm2sv","id":"1e4opLDDJ52zacE50hm2sv","name":"Mama's Jasje","type":"artist","uri":"spotify:artist:1e4opLDDJ52zacE50hm2sv"}],"external_urls":{"spotify":"https://open.spotify.com/album/7MHbb7cj1VjVQxcPN5WmAM"},"href":"https://api.spotify.com/v1/albums/7MHbb7cj1VjVQxcPN5WmAM","id":"7MHbb7cj1VjVQxcPN5WmAM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346af4963ee942730369bd046"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246af4963ee942730369bd046"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146af4963ee942730369bd046"}],"is_playable":true,"name":"Paradijs Op Aarde","release_date":"1991-01-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:7MHbb7cj1VjVQxcPN5WmAM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1e4opLDDJ52zacE50hm2sv"},"href":"https://api.spotify.com/v1/artists/1e4opLDDJ52zacE50hm2sv","id":"1e4opLDDJ52zacE50hm2sv","name":"Mama's Jasje","type":"artist","uri":"spotify:artist:1e4opLDDJ52zacE50hm2sv"}],"disc_number":1,"duration_ms":209400,"explicit":false,"external_ids":{"isrc":"BEV019100004"},"external_urls":{"spotify":"https://open.spotify.com/track/1Y9V0LhY470fc676oEXaLQ"},"href":"https://api.spotify.com/v1/tracks/1Y9V0LhY470fc676oEXaLQ","id":"1Y9V0LhY470fc676oEXaLQ","is_local":false,"is_playable":true,"name":"Zo ver weg","track_number":4,"type":"track","uri":"spotify:track:1Y9V0LhY470fc676oEXaLQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tsLLrRYEzdpphF6QSFhBT"},"href":"https://api.spotify.com/v1/albums/0tsLLrRYEzdpphF6QSFhBT","id":"0tsLLrRYEzdpphF6QSFhBT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27396b55ed8f820021bea33b752"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0296b55ed8f820021bea33b752"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485196b55ed8f820021bea33b752"}],"is_playable":true,"name":"De Waarheid","release_date":"1996-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:0tsLLrRYEzdpphF6QSFhBT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7nJtdgCxkhZFvFMPTsHavb"},"href":"https://api.spotify.com/v1/artists/7nJtdgCxkhZFvFMPTsHavb","id":"7nJtdgCxkhZFvFMPTsHavb","name":"Trijntje Oosterhuis","type":"artist","uri":"spotify:artist:7nJtdgCxkhZFvFMPTsHavb"}],"disc_number":1,"duration_ms":235933,"explicit":false,"external_ids":{"isrc":"NLA319600427"},"external_urls":{"spotify":"https://open.spotify.com/track/1f4VAmKMduljFaWtRGGweZ"},"href":"https://api.spotify.com/v1/tracks/1f4VAmKMduljFaWtRGGweZ","id":"1f4VAmKMduljFaWtRGGweZ","is_local":false,"is_playable":true,"name":"Wereld Zonder Jou","track_number":8,"type":"track","uri":"spotify:track:1f4VAmKMduljFaWtRGGweZ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"external_urls":{"spotify":"https://open.spotify.com/album/7v3UktLA1JnkuZK3kq2ym9"},"href":"https://api.spotify.com/v1/albums/7v3UktLA1JnkuZK3kq2ym9","id":"7v3UktLA1JnkuZK3kq2ym9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e13d44be17f6a5e7c58203ab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e13d44be17f6a5e7c58203ab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e13d44be17f6a5e7c58203ab"}],"is_playable":true,"name":"Begin Twintig","release_date":"2007-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:7v3UktLA1JnkuZK3kq2ym9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"disc_number":1,"duration_ms":216440,"explicit":true,"external_ids":{"isrc":"NLG660700146"},"external_urls":{"spotify":"https://open.spotify.com/track/0ymIeBLUmtuLZQwxC47TH1"},"href":"https://api.spotify.com/v1/tracks/0ymIeBLUmtuLZQwxC47TH1","id":"0ymIeBLUmtuLZQwxC47TH1","is_local":false,"is_playable":true,"name":"Leven Is Een Droom","track_number":12,"type":"track","uri":"spotify:track:0ymIeBLUmtuLZQwxC47TH1"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"external_urls":{"spotify":"https://open.spotify.com/album/06SqrPkDlWtTDEuxDtUiQ1"},"href":"https://api.spotify.com/v1/albums/06SqrPkDlWtTDEuxDtUiQ1","id":"06SqrPkDlWtTDEuxDtUiQ1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273680790729783920dc58b34b6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02680790729783920dc58b34b6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851680790729783920dc58b34b6"}],"is_playable":true,"name":"De Nacht Is Nog Jong Net Als Wij Voor Altijd","release_date":"2014-11-14","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:06SqrPkDlWtTDEuxDtUiQ1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AvkVClT6JuPL4LFy7liYN"},"href":"https://api.spotify.com/v1/artists/5AvkVClT6JuPL4LFy7liYN","id":"5AvkVClT6JuPL4LFy7liYN","name":"Gers Pardoel","type":"artist","uri":"spotify:artist:5AvkVClT6JuPL4LFy7liYN"}],"disc_number":1,"duration_ms":238933,"explicit":true,"external_ids":{"isrc":"NLG661400644"},"external_urls":{"spotify":"https://open.spotify.com/track/3asbIOpGVNsKoeFmvGGpQm"},"href":"https://api.spotify.com/v1/tracks/3asbIOpGVNsKoeFmvGGpQm","id":"3asbIOpGVNsKoeFmvGGpQm","is_local":false,"is_playable":true,"name":"Ik Wil Het Hebben","track_number":7,"type":"track","uri":"spotify:track:3asbIOpGVNsKoeFmvGGpQm"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OELFWvZ1tR4wKREmndcEJ"},"href":"https://api.spotify.com/v1/albums/0OELFWvZ1tR4wKREmndcEJ","id":"0OELFWvZ1tR4wKREmndcEJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c81c59d560502cd89d5bf1a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c81c59d560502cd89d5bf1a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c81c59d560502cd89d5bf1a"}],"is_playable":true,"name":"Marco","release_date":"1994-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0OELFWvZ1tR4wKREmndcEJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":242733,"explicit":false,"external_ids":{"isrc":"NLA319400194"},"external_urls":{"spotify":"https://open.spotify.com/track/2o4iWZOFE8kkl0tK66WADw"},"href":"https://api.spotify.com/v1/tracks/2o4iWZOFE8kkl0tK66WADw","id":"2o4iWZOFE8kkl0tK66WADw","is_local":false,"is_playable":true,"name":"Dromen Zijn Bedrog","track_number":1,"type":"track","uri":"spotify:track:2o4iWZOFE8kkl0tK66WADw"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/20gA8CDMDxdmigQadx7y7x"},"href":"https://api.spotify.com/v1/albums/20gA8CDMDxdmigQadx7y7x","id":"20gA8CDMDxdmigQadx7y7x","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731715532f93f4de4af3d72c36"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021715532f93f4de4af3d72c36"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511715532f93f4de4af3d72c36"}],"is_playable":true,"name":"Alle 13 Dope (Reissue)","release_date":"1998-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:20gA8CDMDxdmigQadx7y7x"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MP0NXMhl5TfFKtG3Q5uk2"},"href":"https://api.spotify.com/v1/artists/5MP0NXMhl5TfFKtG3Q5uk2","id":"5MP0NXMhl5TfFKtG3Q5uk2","name":"Def Rhymz","type":"artist","uri":"spotify:artist:5MP0NXMhl5TfFKtG3Q5uk2"}],"disc_number":1,"duration_ms":231453,"explicit":false,"external_ids":{"isrc":"NLA359900209"},"external_urls":{"spotify":"https://open.spotify.com/track/3HRNlR3brouPtb1HSplfWX"},"href":"https://api.spotify.com/v1/tracks/3HRNlR3brouPtb1HSplfWX","id":"3HRNlR3brouPtb1HSplfWX","is_local":false,"is_playable":true,"name":"Doekoe","track_number":2,"type":"track","uri":"spotify:track:3HRNlR3brouPtb1HSplfWX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5EiwVYDUqfqDNhUSKvL8gq"},"href":"https://api.spotify.com/v1/artists/5EiwVYDUqfqDNhUSKvL8gq","id":"5EiwVYDUqfqDNhUSKvL8gq","name":"Get Ready","type":"artist","uri":"spotify:artist:5EiwVYDUqfqDNhUSKvL8gq"}],"external_urls":{"spotify":"https://open.spotify.com/album/6zYql91MQJOd2DZJsQxA0N"},"href":"https://api.spotify.com/v1/albums/6zYql91MQJOd2DZJsQxA0N","id":"6zYql91MQJOd2DZJsQxA0N","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273626f5f230384686345251dd5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02626f5f230384686345251dd5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851626f5f230384686345251dd5"}],"is_playable":true,"name":"Go For It!","release_date":"1997","release_date_precision":"year","total_tracks":20,"type":"album","uri":"spotify:album:6zYql91MQJOd2DZJsQxA0N"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5EiwVYDUqfqDNhUSKvL8gq"},"href":"https://api.spotify.com/v1/artists/5EiwVYDUqfqDNhUSKvL8gq","id":"5EiwVYDUqfqDNhUSKvL8gq","name":"Get Ready","type":"artist","uri":"spotify:artist:5EiwVYDUqfqDNhUSKvL8gq"}],"disc_number":1,"duration_ms":214360,"explicit":false,"external_ids":{"isrc":"BEV019700049"},"external_urls":{"spotify":"https://open.spotify.com/track/3o8POiAMb2gNW3cJ8QxXo4"},"href":"https://api.spotify.com/v1/tracks/3o8POiAMb2gNW3cJ8QxXo4","id":"3o8POiAMb2gNW3cJ8QxXo4","is_local":false,"is_playable":true,"name":"Weg","track_number":13,"type":"track","uri":"spotify:track:3o8POiAMb2gNW3cJ8QxXo4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1LrwZBHqOs7YZianBDKVIz"},"href":"https://api.spotify.com/v1/artists/1LrwZBHqOs7YZianBDKVIz","id":"1LrwZBHqOs7YZianBDKVIz","name":"Tr\u00f6ckener Kecks","type":"artist","uri":"spotify:artist:1LrwZBHqOs7YZianBDKVIz"}],"external_urls":{"spotify":"https://open.spotify.com/album/2xjva5NbGWv62jM1HJe4R3"},"href":"https://api.spotify.com/v1/albums/2xjva5NbGWv62jM1HJe4R3","id":"2xjva5NbGWv62jM1HJe4R3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a82d23050c87d88488d87e54"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a82d23050c87d88488d87e54"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a82d23050c87d88488d87e54"}],"is_playable":true,"name":">tk","release_date":"2000-02-07","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2xjva5NbGWv62jM1HJe4R3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1LrwZBHqOs7YZianBDKVIz"},"href":"https://api.spotify.com/v1/artists/1LrwZBHqOs7YZianBDKVIz","id":"1LrwZBHqOs7YZianBDKVIz","name":"Tr\u00f6ckener Kecks","type":"artist","uri":"spotify:artist:1LrwZBHqOs7YZianBDKVIz"}],"disc_number":1,"duration_ms":251760,"explicit":false,"external_ids":{"isrc":"NLZ1Q2000009"},"external_urls":{"spotify":"https://open.spotify.com/track/7b7EzGi2SQys7YGqURiSGI"},"href":"https://api.spotify.com/v1/tracks/7b7EzGi2SQys7YGqURiSGI","id":"7b7EzGi2SQys7YGqURiSGI","is_local":false,"is_playable":true,"name":"Geen Kaart, Geen Plan, Geen Gids","track_number":9,"type":"track","uri":"spotify:track:7b7EzGi2SQys7YGqURiSGI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2RGaq5wlFtCbIZlxOwwZWb"},"href":"https://api.spotify.com/v1/artists/2RGaq5wlFtCbIZlxOwwZWb","id":"2RGaq5wlFtCbIZlxOwwZWb","name":"Bart Boonstra","type":"artist","uri":"spotify:artist:2RGaq5wlFtCbIZlxOwwZWb"}],"external_urls":{"spotify":"https://open.spotify.com/album/48ILdGuDAQtE8W7g1kUoqV"},"href":"https://api.spotify.com/v1/albums/48ILdGuDAQtE8W7g1kUoqV","id":"48ILdGuDAQtE8W7g1kUoqV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad1ace5668a1e3ad3a2f0bcc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad1ace5668a1e3ad3a2f0bcc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad1ace5668a1e3ad3a2f0bcc"}],"is_playable":true,"name":"Verliefd","release_date":"2014-05-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:48ILdGuDAQtE8W7g1kUoqV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2RGaq5wlFtCbIZlxOwwZWb"},"href":"https://api.spotify.com/v1/artists/2RGaq5wlFtCbIZlxOwwZWb","id":"2RGaq5wlFtCbIZlxOwwZWb","name":"Bart Boonstra","type":"artist","uri":"spotify:artist:2RGaq5wlFtCbIZlxOwwZWb"}],"disc_number":1,"duration_ms":196521,"explicit":false,"external_ids":{"isrc":"TCABX1421011"},"external_urls":{"spotify":"https://open.spotify.com/track/3bK3r0TUlUgRy83Jkeaf7e"},"href":"https://api.spotify.com/v1/tracks/3bK3r0TUlUgRy83Jkeaf7e","id":"3bK3r0TUlUgRy83Jkeaf7e","is_local":false,"is_playable":true,"name":"Verliefd","track_number":1,"type":"track","uri":"spotify:track:3bK3r0TUlUgRy83Jkeaf7e"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Zo%20Ver%20Weg%20Marco%20Borsato&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Zo%20Ver%20Weg%20Marco%20Borsato&type=track","offset":0,"previous":null,"total":18,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MP0NXMhl5TfFKtG3Q5uk2"},"href":"https://api.spotify.com/v1/artists/5MP0NXMhl5TfFKtG3Q5uk2","id":"5MP0NXMhl5TfFKtG3Q5uk2","name":"Def Rhymz","type":"artist","uri":"spotify:artist:5MP0NXMhl5TfFKtG3Q5uk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/1dbz3bcXwCQUMZr226anyI"},"href":"https://api.spotify.com/v1/albums/1dbz3bcXwCQUMZr226anyI","id":"1dbz3bcXwCQUMZr226anyI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f9af5ecd9f5f65ee5805c60"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f9af5ecd9f5f65ee5805c60"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f9af5ecd9f5f65ee5805c60"}],"is_playable":true,"name":"De Allergoeiste (Reissue)","release_date":"2001-01-01","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:1dbz3bcXwCQUMZr226anyI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MP0NXMhl5TfFKtG3Q5uk2"},"href":"https://api.spotify.com/v1/artists/5MP0NXMhl5TfFKtG3Q5uk2","id":"5MP0NXMhl5TfFKtG3Q5uk2","name":"Def Rhymz","type":"artist","uri":"spotify:artist:5MP0NXMhl5TfFKtG3Q5uk2"}],"disc_number":1,"duration_ms":229573,"explicit":false,"external_ids":{"isrc":"NLA359900209"},"external_urls":{"spotify":"https://open.spotify.com/track/6Iaj06EGyIvSSRHBjLBwh8"},"href":"https://api.spotify.com/v1/tracks/6Iaj06EGyIvSSRHBjLBwh8","id":"6Iaj06EGyIvSSRHBjLBwh8","is_local":false,"is_playable":true,"name":"Doekoe","track_number":8,"type":"track","uri":"spotify:track:6Iaj06EGyIvSSRHBjLBwh8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1e4opLDDJ52zacE50hm2sv"},"href":"https://api.spotify.com/v1/artists/1e4opLDDJ52zacE50hm2sv","id":"1e4opLDDJ52zacE50hm2sv","name":"Mama's Jasje","type":"artist","uri":"spotify:artist:1e4opLDDJ52zacE50hm2sv"}],"external_urls":{"spotify":"https://open.spotify.com/album/7MHbb7cj1VjVQxcPN5WmAM"},"href":"https://api.spotify.com/v1/albums/7MHbb7cj1VjVQxcPN5WmAM","id":"7MHbb7cj1VjVQxcPN5WmAM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346af4963ee942730369bd046"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246af4963ee942730369bd046"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146af4963ee942730369bd046"}],"is_playable":true,"name":"Paradijs Op Aarde","release_date":"1991-01-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:7MHbb7cj1VjVQxcPN5WmAM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1e4opLDDJ52zacE50hm2sv"},"href":"https://api.spotify.com/v1/artists/1e4opLDDJ52zacE50hm2sv","id":"1e4opLDDJ52zacE50hm2sv","name":"Mama's Jasje","type":"artist","uri":"spotify:artist:1e4opLDDJ52zacE50hm2sv"}],"disc_number":1,"duration_ms":209400,"explicit":false,"external_ids":{"isrc":"BEV019100004"},"external_urls":{"spotify":"https://open.spotify.com/track/1Y9V0LhY470fc676oEXaLQ"},"href":"https://api.spotify.com/v1/tracks/1Y9V0LhY470fc676oEXaLQ","id":"1Y9V0LhY470fc676oEXaLQ","is_local":false,"is_playable":true,"name":"Zo ver weg","track_number":4,"type":"track","uri":"spotify:track:1Y9V0LhY470fc676oEXaLQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/0tsLLrRYEzdpphF6QSFhBT"},"href":"https://api.spotify.com/v1/albums/0tsLLrRYEzdpphF6QSFhBT","id":"0tsLLrRYEzdpphF6QSFhBT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27396b55ed8f820021bea33b752"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0296b55ed8f820021bea33b752"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485196b55ed8f820021bea33b752"}],"is_playable":true,"name":"De Waarheid","release_date":"1996-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:0tsLLrRYEzdpphF6QSFhBT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7nJtdgCxkhZFvFMPTsHavb"},"href":"https://api.spotify.com/v1/artists/7nJtdgCxkhZFvFMPTsHavb","id":"7nJtdgCxkhZFvFMPTsHavb","name":"Trijntje Oosterhuis","type":"artist","uri":"spotify:artist:7nJtdgCxkhZFvFMPTsHavb"}],"disc_number":1,"duration_ms":235933,"explicit":false,"external_ids":{"isrc":"NLA319600427"},"external_urls":{"spotify":"https://open.spotify.com/track/1f4VAmKMduljFaWtRGGweZ"},"href":"https://api.spotify.com/v1/tracks/1f4VAmKMduljFaWtRGGweZ","id":"1f4VAmKMduljFaWtRGGweZ","is_local":false,"is_playable":true,"name":"Wereld Zonder Jou","track_number":8,"type":"track","uri":"spotify:track:1f4VAmKMduljFaWtRGGweZ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"external_urls":{"spotify":"https://open.spotify.com/album/7v3UktLA1JnkuZK3kq2ym9"},"href":"https://api.spotify.com/v1/albums/7v3UktLA1JnkuZK3kq2ym9","id":"7v3UktLA1JnkuZK3kq2ym9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e13d44be17f6a5e7c58203ab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e13d44be17f6a5e7c58203ab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e13d44be17f6a5e7c58203ab"}],"is_playable":true,"name":"Begin Twintig","release_date":"2007-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:7v3UktLA1JnkuZK3kq2ym9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23951Pg9PiLB8Uza3k12g6"},"href":"https://api.spotify.com/v1/artists/23951Pg9PiLB8Uza3k12g6","id":"23951Pg9PiLB8Uza3k12g6","name":"The Opposites","type":"artist","uri":"spotify:artist:23951Pg9PiLB8Uza3k12g6"}],"disc_number":1,"duration_ms":216440,"explicit":true,"external_ids":{"isrc":"NLG660700146"},"external_urls":{"spotify":"https://open.spotify.com/track/0ymIeBLUmtuLZQwxC47TH1"},"href":"https://api.spotify.com/v1/tracks/0ymIeBLUmtuLZQwxC47TH1","id":"0ymIeBLUmtuLZQwxC47TH1","is_local":false,"is_playable":true,"name":"Leven Is Een Droom","track_number":12,"type":"track","uri":"spotify:track:0ymIeBLUmtuLZQwxC47TH1"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"}],"external_urls":{"spotify":"https://open.spotify.com/album/06SqrPkDlWtTDEuxDtUiQ1"},"href":"https://api.spotify.com/v1/albums/06SqrPkDlWtTDEuxDtUiQ1","id":"06SqrPkDlWtTDEuxDtUiQ1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273680790729783920dc58b34b6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02680790729783920dc58b34b6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851680790729783920dc58b34b6"}],"is_playable":true,"name":"De Nacht Is Nog Jong Net Als Wij Voor Altijd","release_date":"2014-11-14","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:06SqrPkDlWtTDEuxDtUiQ1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5eir5zFJpES4j7gsymbVyl"},"href":"https://api.spotify.com/v1/artists/5eir5zFJpES4j7gsymbVyl","id":"5eir5zFJpES4j7gsymbVyl","name":"Ronnie Flex","type":"artist","uri":"spotify:artist:5eir5zFJpES4j7gsymbVyl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AvkVClT6JuPL4LFy7liYN"},"href":"https://api.spotify.com/v1/artists/5AvkVClT6JuPL4LFy7liYN","id":"5AvkVClT6JuPL4LFy7liYN","name":"Gers Pardoel","type":"artist","uri":"spotify:artist:5AvkVClT6JuPL4LFy7liYN"}],"disc_number":1,"duration_ms":238933,"explicit":true,"external_ids":{"isrc":"NLG661400644"},"external_urls":{"spotify":"https://open.spotify.com/track/3asbIOpGVNsKoeFmvGGpQm"},"href":"https://api.spotify.com/v1/tracks/3asbIOpGVNsKoeFmvGGpQm","id":"3asbIOpGVNsKoeFmvGGpQm","is_local":false,"is_playable":true,"name":"Ik Wil Het Hebben","track_number":7,"type":"track","uri":"spotify:track:3asbIOpGVNsKoeFmvGGpQm"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OELFWvZ1tR4wKREmndcEJ"},"href":"https://api.spotify.com/v1/albums/0OELFWvZ1tR4wKREmndcEJ","id":"0OELFWvZ1tR4wKREmndcEJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c81c59d560502cd89d5bf1a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c81c59d560502cd89d5bf1a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c81c59d560502cd89d5bf1a"}],"is_playable":true,"name":"Marco","release_date":"1994-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0OELFWvZ1tR4wKREmndcEJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":242733,"explicit":false,"external_ids":{"isrc":"NLA319400194"},"external_urls":{"spotify":"https://open.spotify.com/track/2o4iWZOFE8kkl0tK66WADw"},"href":"https://api.spotify.com/v1/tracks/2o4iWZOFE8kkl0tK66WADw","id":"2o4iWZOFE8kkl0tK66WADw","is_local":false,"is_playable":true,"name":"Dromen Zijn Bedrog","track_number":1,"type":"track","uri":"spotify:track:2o4iWZOFE8kkl0tK66WADw"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/20gA8CDMDxdmigQadx7y7x"},"href":"https://api.spotify.com/v1/albums/20gA8CDMDxdmigQadx7y7x","id":"20gA8CDMDxdmigQadx7y7x","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731715532f93f4de4af3d72c36"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021715532f93f4de4af3d72c36"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511715532f93f4de4af3d72c36"}],"is_playable":true,"name":"Alle 13 Dope (Reissue)","release_date":"1998-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:20gA8CDMDxdmigQadx7y7x"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MP0NXMhl5TfFKtG3Q5uk2"},"href":"https://api.spotify.com/v1/artists/5MP0NXMhl5TfFKtG3Q5uk2","id":"5MP0NXMhl5TfFKtG3Q5uk2","name":"Def Rhymz","type":"artist","uri":"spotify:artist:5MP0NXMhl5TfFKtG3Q5uk2"}],"disc_number":1,"duration_ms":231453,"explicit":false,"external_ids":{"isrc":"NLA359900209"},"external_urls":{"spotify":"https://open.spotify.com/track/3HRNlR3brouPtb1HSplfWX"},"href":"https://api.spotify.com/v1/tracks/3HRNlR3brouPtb1HSplfWX","id":"3HRNlR3brouPtb1HSplfWX","is_local":false,"is_playable":true,"name":"Doekoe","track_number":2,"type":"track","uri":"spotify:track:3HRNlR3brouPtb1HSplfWX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5EiwVYDUqfqDNhUSKvL8gq"},"href":"https://api.spotify.com/v1/artists/5EiwVYDUqfqDNhUSKvL8gq","id":"5EiwVYDUqfqDNhUSKvL8gq","name":"Get Ready","type":"artist","uri":"spotify:artist:5EiwVYDUqfqDNhUSKvL8gq"}],"external_urls":{"spotify":"https://open.spotify.com/album/6zYql91MQJOd2DZJsQxA0N"},"href":"https://api.spotify.com/v1/albums/6zYql91MQJOd2DZJsQxA0N","id":"6zYql91MQJOd2DZJsQxA0N","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273626f5f230384686345251dd5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02626f5f230384686345251dd5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851626f5f230384686345251dd5"}],"is_playable":true,"name":"Go For It!","release_date":"1997","release_date_precision":"year","total_tracks":20,"type":"album","uri":"spotify:album:6zYql91MQJOd2DZJsQxA0N"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5EiwVYDUqfqDNhUSKvL8gq"},"href":"https://api.spotify.com/v1/artists/5EiwVYDUqfqDNhUSKvL8gq","id":"5EiwVYDUqfqDNhUSKvL8gq","name":"Get Ready","type":"artist","uri":"spotify:artist:5EiwVYDUqfqDNhUSKvL8gq"}],"disc_number":1,"duration_ms":214360,"explicit":false,"external_ids":{"isrc":"BEV019700049"},"external_urls":{"spotify":"https://open.spotify.com/track/3o8POiAMb2gNW3cJ8QxXo4"},"href":"https://api.spotify.com/v1/tracks/3o8POiAMb2gNW3cJ8QxXo4","id":"3o8POiAMb2gNW3cJ8QxXo4","is_local":false,"is_playable":true,"name":"Weg","track_number":13,"type":"track","uri":"spotify:track:3o8POiAMb2gNW3cJ8QxXo4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1LrwZBHqOs7YZianBDKVIz"},"href":"https://api.spotify.com/v1/artists/1LrwZBHqOs7YZianBDKVIz","id":"1LrwZBHqOs7YZianBDKVIz","name":"Tr\u00f6ckener Kecks","type":"artist","uri":"spotify:artist:1LrwZBHqOs7YZianBDKVIz"}],"external_urls":{"spotify":"https://open.spotify.com/album/2xjva5NbGWv62jM1HJe4R3"},"href":"https://api.spotify.com/v1/albums/2xjva5NbGWv62jM1HJe4R3","id":"2xjva5NbGWv62jM1HJe4R3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a82d23050c87d88488d87e54"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a82d23050c87d88488d87e54"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a82d23050c87d88488d87e54"}],"is_playable":true,"name":">tk","release_date":"2000-02-07","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2xjva5NbGWv62jM1HJe4R3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1LrwZBHqOs7YZianBDKVIz"},"href":"https://api.spotify.com/v1/artists/1LrwZBHqOs7YZianBDKVIz","id":"1LrwZBHqOs7YZianBDKVIz","name":"Tr\u00f6ckener Kecks","type":"artist","uri":"spotify:artist:1LrwZBHqOs7YZianBDKVIz"}],"disc_number":1,"duration_ms":251760,"explicit":false,"external_ids":{"isrc":"NLZ1Q2000009"},"external_urls":{"spotify":"https://open.spotify.com/track/7b7EzGi2SQys7YGqURiSGI"},"href":"https://api.spotify.com/v1/tracks/7b7EzGi2SQys7YGqURiSGI","id":"7b7EzGi2SQys7YGqURiSGI","is_local":false,"is_playable":true,"name":"Geen Kaart, Geen Plan, Geen Gids","track_number":9,"type":"track","uri":"spotify:track:7b7EzGi2SQys7YGqURiSGI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2RGaq5wlFtCbIZlxOwwZWb"},"href":"https://api.spotify.com/v1/artists/2RGaq5wlFtCbIZlxOwwZWb","id":"2RGaq5wlFtCbIZlxOwwZWb","name":"Bart Boonstra","type":"artist","uri":"spotify:artist:2RGaq5wlFtCbIZlxOwwZWb"}],"external_urls":{"spotify":"https://open.spotify.com/album/48ILdGuDAQtE8W7g1kUoqV"},"href":"https://api.spotify.com/v1/albums/48ILdGuDAQtE8W7g1kUoqV","id":"48ILdGuDAQtE8W7g1kUoqV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad1ace5668a1e3ad3a2f0bcc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad1ace5668a1e3ad3a2f0bcc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad1ace5668a1e3ad3a2f0bcc"}],"is_playable":true,"name":"Verliefd","release_date":"2014-05-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:48ILdGuDAQtE8W7g1kUoqV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2RGaq5wlFtCbIZlxOwwZWb"},"href":"https://api.spotify.com/v1/artists/2RGaq5wlFtCbIZlxOwwZWb","id":"2RGaq5wlFtCbIZlxOwwZWb","name":"Bart Boonstra","type":"artist","uri":"spotify:artist:2RGaq5wlFtCbIZlxOwwZWb"}],"disc_number":1,"duration_ms":196521,"explicit":false,"external_ids":{"isrc":"TCABX1421011"},"external_urls":{"spotify":"https://open.spotify.com/track/3bK3r0TUlUgRy83Jkeaf7e"},"href":"https://api.spotify.com/v1/tracks/3bK3r0TUlUgRy83Jkeaf7e","id":"3bK3r0TUlUgRy83Jkeaf7e","is_local":false,"is_playable":true,"name":"Verliefd","track_number":1,"type":"track","uri":"spotify:track:3bK3r0TUlUgRy83Jkeaf7e"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Zo+Ver+Weg+Marco+Borsato&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Blijf%20Bij%20Mij%20Guus%20Meeuwis&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Blijf%20Bij%20Mij%20Guus%20Meeuwis&type=track","offset":0,"previous":null,"total":22,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1u7uShzlA1tXJeox3jMFPq"},"href":"https://api.spotify.com/v1/artists/1u7uShzlA1tXJeox3jMFPq","id":"1u7uShzlA1tXJeox3jMFPq","name":"De Jeugd Van Tegenwoordig","type":"artist","uri":"spotify:artist:1u7uShzlA1tXJeox3jMFPq"}],"external_urls":{"spotify":"https://open.spotify.com/album/29Fo0IBU1ZuyZD5ozPkjAs"},"href":"https://api.spotify.com/v1/albums/29Fo0IBU1ZuyZD5ozPkjAs","id":"29Fo0IBU1ZuyZD5ozPkjAs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f55d4578fe7043336238574"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f55d4578fe7043336238574"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f55d4578fe7043336238574"}],"is_playable":true,"name":"Parels Voor De Zwijnen","release_date":"2005-09-30","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:29Fo0IBU1ZuyZD5ozPkjAs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1u7uShzlA1tXJeox3jMFPq"},"href":"https://api.spotify.com/v1/artists/1u7uShzlA1tXJeox3jMFPq","id":"1u7uShzlA1tXJeox3jMFPq","name":"De Jeugd Van Tegenwoordig","type":"artist","uri":"spotify:artist:1u7uShzlA1tXJeox3jMFPq"}],"disc_number":1,"duration_ms":357866,"explicit":true,"external_ids":{"isrc":"NLG660500048"},"external_urls":{"spotify":"https://open.spotify.com/track/7hv0wyEgvGTTMe9ycOVwPV"},"href":"https://api.spotify.com/v1/tracks/7hv0wyEgvGTTMe9ycOVwPV","id":"7hv0wyEgvGTTMe9ycOVwPV","is_local":false,"is_playable":true,"name":"De Stofzuiger","track_number":9,"type":"track","uri":"spotify:track:7hv0wyEgvGTTMe9ycOVwPV"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Hx2t9BIWDlr3Bpd6eWmei"},"href":"https://api.spotify.com/v1/artists/7Hx2t9BIWDlr3Bpd6eWmei","id":"7Hx2t9BIWDlr3Bpd6eWmei","name":"Thijs Boontjes","type":"artist","uri":"spotify:artist:7Hx2t9BIWDlr3Bpd6eWmei"}],"external_urls":{"spotify":"https://open.spotify.com/album/4eueg0K9RALrcC4OInrPdN"},"href":"https://api.spotify.com/v1/albums/4eueg0K9RALrcC4OInrPdN","id":"4eueg0K9RALrcC4OInrPdN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dcb1f6e9cafb64d09ed9afd1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dcb1f6e9cafb64d09ed9afd1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dcb1f6e9cafb64d09ed9afd1"}],"is_playable":true,"name":"Deze Nacht (All Night Long)","release_date":"2020-02-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4eueg0K9RALrcC4OInrPdN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Hx2t9BIWDlr3Bpd6eWmei"},"href":"https://api.spotify.com/v1/artists/7Hx2t9BIWDlr3Bpd6eWmei","id":"7Hx2t9BIWDlr3Bpd6eWmei","name":"Thijs Boontjes","type":"artist","uri":"spotify:artist:7Hx2t9BIWDlr3Bpd6eWmei"}],"disc_number":1,"duration_ms":243005,"explicit":false,"external_ids":{"isrc":"NLB602000052"},"external_urls":{"spotify":"https://open.spotify.com/track/00tDSqUMjyOICNNmQSBE8w"},"href":"https://api.spotify.com/v1/tracks/00tDSqUMjyOICNNmQSBE8w","id":"00tDSqUMjyOICNNmQSBE8w","is_local":false,"is_playable":true,"name":"Deze Nacht (All Night Long)","track_number":1,"type":"track","uri":"spotify:track:00tDSqUMjyOICNNmQSBE8w"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/33KABng8GO42ojFJVcABxQ"},"href":"https://api.spotify.com/v1/artists/33KABng8GO42ojFJVcABxQ","id":"33KABng8GO42ojFJVcABxQ","name":"Eefje de Visser","type":"artist","uri":"spotify:artist:33KABng8GO42ojFJVcABxQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/6i4IItGQSRvbdBguRDggMI"},"href":"https://api.spotify.com/v1/albums/6i4IItGQSRvbdBguRDggMI","id":"6i4IItGQSRvbdBguRDggMI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735481ee8abce9d7f8a6fceea2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025481ee8abce9d7f8a6fceea2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515481ee8abce9d7f8a6fceea2"}],"is_playable":true,"name":"Bitterzoet","release_date":"2020-01-24","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:6i4IItGQSRvbdBguRDggMI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/33KABng8GO42ojFJVcABxQ"},"href":"https://api.spotify.com/v1/artists/33KABng8GO42ojFJVcABxQ","id":"33KABng8GO42ojFJVcABxQ","name":"Eefje de Visser","type":"artist","uri":"spotify:artist:33KABng8GO42ojFJVcABxQ"}],"disc_number":1,"duration_ms":238746,"explicit":false,"external_ids":{"isrc":"NLPH61900002"},"external_urls":{"spotify":"https://open.spotify.com/track/39He9xYIIOdK0pU3U9OjAs"},"href":"https://api.spotify.com/v1/tracks/39He9xYIIOdK0pU3U9OjAs","id":"39He9xYIIOdK0pU3U9OjAs","is_local":false,"is_playable":true,"name":"Bitterzoet","track_number":2,"type":"track","uri":"spotify:track:39He9xYIIOdK0pU3U9OjAs"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3Llaa1wsUdDPjKmkgkQWw9"},"href":"https://api.spotify.com/v1/artists/3Llaa1wsUdDPjKmkgkQWw9","id":"3Llaa1wsUdDPjKmkgkQWw9","name":"Fouradi","type":"artist","uri":"spotify:artist:3Llaa1wsUdDPjKmkgkQWw9"}],"external_urls":{"spotify":"https://open.spotify.com/album/3fSUWiDyJvGLZoEGla0Ycb"},"href":"https://api.spotify.com/v1/albums/3fSUWiDyJvGLZoEGla0Ycb","id":"3fSUWiDyJvGLZoEGla0Ycb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a3d5f144177f655735c35ae0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a3d5f144177f655735c35ae0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a3d5f144177f655735c35ae0"}],"is_playable":true,"name":"De Favoriete Schoonzoons","release_date":"2009-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3fSUWiDyJvGLZoEGla0Ycb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3Llaa1wsUdDPjKmkgkQWw9"},"href":"https://api.spotify.com/v1/artists/3Llaa1wsUdDPjKmkgkQWw9","id":"3Llaa1wsUdDPjKmkgkQWw9","name":"Fouradi","type":"artist","uri":"spotify:artist:3Llaa1wsUdDPjKmkgkQWw9"}],"disc_number":1,"duration_ms":198480,"explicit":false,"external_ids":{"isrc":"NLG270600425"},"external_urls":{"spotify":"https://open.spotify.com/track/7hoBdvEj6cfKR8NvDIbq07"},"href":"https://api.spotify.com/v1/tracks/7hoBdvEj6cfKR8NvDIbq07","id":"7hoBdvEj6cfKR8NvDIbq07","is_local":false,"is_playable":true,"name":"1 Ding","track_number":1,"type":"track","uri":"spotify:track:7hoBdvEj6cfKR8NvDIbq07"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5adKMaYrGOMyOfnbiLPuHg"},"href":"https://api.spotify.com/v1/artists/5adKMaYrGOMyOfnbiLPuHg","id":"5adKMaYrGOMyOfnbiLPuHg","name":"Jonna Fraser","type":"artist","uri":"spotify:artist:5adKMaYrGOMyOfnbiLPuHg"}],"external_urls":{"spotify":"https://open.spotify.com/album/08XCGZJvFATyHBwUzddDyn"},"href":"https://api.spotify.com/v1/albums/08XCGZJvFATyHBwUzddDyn","id":"08XCGZJvFATyHBwUzddDyn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27318357a8f800195cf617925c9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0218357a8f800195cf617925c9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485118357a8f800195cf617925c9"}],"is_playable":true,"name":"Goed Teken","release_date":"2016-05-02","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:08XCGZJvFATyHBwUzddDyn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5adKMaYrGOMyOfnbiLPuHg"},"href":"https://api.spotify.com/v1/artists/5adKMaYrGOMyOfnbiLPuHg","id":"5adKMaYrGOMyOfnbiLPuHg","name":"Jonna Fraser","type":"artist","uri":"spotify:artist:5adKMaYrGOMyOfnbiLPuHg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5GvMLzUp6tMBpaCbr903RN"},"href":"https://api.spotify.com/v1/artists/5GvMLzUp6tMBpaCbr903RN","id":"5GvMLzUp6tMBpaCbr903RN","name":"Broederliefde","type":"artist","uri":"spotify:artist:5GvMLzUp6tMBpaCbr903RN"}],"disc_number":1,"duration_ms":225737,"explicit":false,"external_ids":{"isrc":"NLG661600305"},"external_urls":{"spotify":"https://open.spotify.com/track/2Y63yg1Lgdp96IoiZIvjKz"},"href":"https://api.spotify.com/v1/tracks/2Y63yg1Lgdp96IoiZIvjKz","id":"2Y63yg1Lgdp96IoiZIvjKz","is_local":false,"is_playable":true,"name":"Do Or Die","track_number":4,"type":"track","uri":"spotify:track:2Y63yg1Lgdp96IoiZIvjKz"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"external_urls":{"spotify":"https://open.spotify.com/album/260VIHFdGNsHL3DKUZYYkc"},"href":"https://api.spotify.com/v1/albums/260VIHFdGNsHL3DKUZYYkc","id":"260VIHFdGNsHL3DKUZYYkc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335d98894d7f97dc12c1df28a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235d98894d7f97dc12c1df28a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135d98894d7f97dc12c1df28a"}],"is_playable":true,"name":"Albino","release_date":"2019-01-18","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:260VIHFdGNsHL3DKUZYYkc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23mbvDIZJjSK4y4KhwlnHi"},"href":"https://api.spotify.com/v1/artists/23mbvDIZJjSK4y4KhwlnHi","id":"23mbvDIZJjSK4y4KhwlnHi","name":"Mick Spek","type":"artist","uri":"spotify:artist:23mbvDIZJjSK4y4KhwlnHi"}],"disc_number":1,"duration_ms":174312,"explicit":false,"external_ids":{"isrc":"NL1MC1900009"},"external_urls":{"spotify":"https://open.spotify.com/track/7nLwUujLMjEw6khA97N6I2"},"href":"https://api.spotify.com/v1/tracks/7nLwUujLMjEw6khA97N6I2","id":"7nLwUujLMjEw6khA97N6I2","is_local":false,"is_playable":true,"name":"Guus Meeuwis","track_number":12,"type":"track","uri":"spotify:track:7nLwUujLMjEw6khA97N6I2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1GWpddfwL9bVovOzCtNQN6"},"href":"https://api.spotify.com/v1/artists/1GWpddfwL9bVovOzCtNQN6","id":"1GWpddfwL9bVovOzCtNQN6","name":"Roxeanne Hazes","type":"artist","uri":"spotify:artist:1GWpddfwL9bVovOzCtNQN6"}],"external_urls":{"spotify":"https://open.spotify.com/album/6myczO3dCuLnjSoUS6yOfY"},"href":"https://api.spotify.com/v1/albums/6myczO3dCuLnjSoUS6yOfY","id":"6myczO3dCuLnjSoUS6yOfY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273821e4e9ffb6fd593cfe4716c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02821e4e9ffb6fd593cfe4716c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851821e4e9ffb6fd593cfe4716c"}],"is_playable":true,"name":"De Tijd Gaat Mooie Dingen Doen","release_date":"2023-10-13","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6myczO3dCuLnjSoUS6yOfY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1GWpddfwL9bVovOzCtNQN6"},"href":"https://api.spotify.com/v1/artists/1GWpddfwL9bVovOzCtNQN6","id":"1GWpddfwL9bVovOzCtNQN6","name":"Roxeanne Hazes","type":"artist","uri":"spotify:artist:1GWpddfwL9bVovOzCtNQN6"}],"disc_number":1,"duration_ms":170500,"explicit":false,"external_ids":{"isrc":"NLUM72301056"},"external_urls":{"spotify":"https://open.spotify.com/track/4lxLSzOPZSd1ZMrhMFHliD"},"href":"https://api.spotify.com/v1/tracks/4lxLSzOPZSd1ZMrhMFHliD","id":"4lxLSzOPZSd1ZMrhMFHliD","is_local":false,"is_playable":true,"name":"De Wereld Draait Door","track_number":4,"type":"track","uri":"spotify:track:4lxLSzOPZSd1ZMrhMFHliD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4vonRu1LX49arENHgrkkD6"},"href":"https://api.spotify.com/v1/artists/4vonRu1LX49arENHgrkkD6","id":"4vonRu1LX49arENHgrkkD6","name":"Blue Dog","type":"artist","uri":"spotify:artist:4vonRu1LX49arENHgrkkD6"}],"external_urls":{"spotify":"https://open.spotify.com/album/61N0uK0rTPbhZ46pgA9SkT"},"href":"https://api.spotify.com/v1/albums/61N0uK0rTPbhZ46pgA9SkT","id":"61N0uK0rTPbhZ46pgA9SkT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737b8d7d5337fe7970302569ec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027b8d7d5337fe7970302569ec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517b8d7d5337fe7970302569ec"}],"is_playable":true,"name":"Songs of the Anthropocene II","release_date":"2019-06-25","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:61N0uK0rTPbhZ46pgA9SkT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4vonRu1LX49arENHgrkkD6"},"href":"https://api.spotify.com/v1/artists/4vonRu1LX49arENHgrkkD6","id":"4vonRu1LX49arENHgrkkD6","name":"Blue Dog","type":"artist","uri":"spotify:artist:4vonRu1LX49arENHgrkkD6"}],"disc_number":1,"duration_ms":261546,"explicit":false,"external_ids":{"isrc":"QZFYZ1933396"},"external_urls":{"spotify":"https://open.spotify.com/track/7axtsfJwNRx9w77QrxjFty"},"href":"https://api.spotify.com/v1/tracks/7axtsfJwNRx9w77QrxjFty","id":"7axtsfJwNRx9w77QrxjFty","is_local":false,"is_playable":true,"name":"Blijf Bij Mij","track_number":6,"type":"track","uri":"spotify:track:7axtsfJwNRx9w77QrxjFty"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7CAtmuyGlzYum4BKfl34ij"},"href":"https://api.spotify.com/v1/artists/7CAtmuyGlzYum4BKfl34ij","id":"7CAtmuyGlzYum4BKfl34ij","name":"Gorki","type":"artist","uri":"spotify:artist:7CAtmuyGlzYum4BKfl34ij"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Z48ep3UgYuBoGELQPtq2y"},"href":"https://api.spotify.com/v1/albums/4Z48ep3UgYuBoGELQPtq2y","id":"4Z48ep3UgYuBoGELQPtq2y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27318c66fc54356a6e363a435e4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0218c66fc54356a6e363a435e4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485118c66fc54356a6e363a435e4"}],"is_playable":true,"name":"Boterhammen","release_date":"1992-07-01","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:4Z48ep3UgYuBoGELQPtq2y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7CAtmuyGlzYum4BKfl34ij"},"href":"https://api.spotify.com/v1/artists/7CAtmuyGlzYum4BKfl34ij","id":"7CAtmuyGlzYum4BKfl34ij","name":"Gorki","type":"artist","uri":"spotify:artist:7CAtmuyGlzYum4BKfl34ij"}],"disc_number":1,"duration_ms":187800,"explicit":false,"external_ids":{"isrc":"BEV019200101"},"external_urls":{"spotify":"https://open.spotify.com/track/0fofTHKaua2JyfXtBTppQR"},"href":"https://api.spotify.com/v1/tracks/0fofTHKaua2JyfXtBTppQR","id":"0fofTHKaua2JyfXtBTppQR","is_local":false,"is_playable":true,"name":"Ik word oud","track_number":1,"type":"track","uri":"spotify:track:0fofTHKaua2JyfXtBTppQR"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5kqIUI0aXHIVZofHKUSPYk"},"href":"https://api.spotify.com/v1/artists/5kqIUI0aXHIVZofHKUSPYk","id":"5kqIUI0aXHIVZofHKUSPYk","name":"Marlane","type":"artist","uri":"spotify:artist:5kqIUI0aXHIVZofHKUSPYk"}],"external_urls":{"spotify":"https://open.spotify.com/album/0axs40xsLToxxzb8oqDZwe"},"href":"https://api.spotify.com/v1/albums/0axs40xsLToxxzb8oqDZwe","id":"0axs40xsLToxxzb8oqDZwe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a1586851138cb598cfee0123"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a1586851138cb598cfee0123"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a1586851138cb598cfee0123"}],"is_playable":true,"name":"Ik Wil Je","release_date":"2019-10-24","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0axs40xsLToxxzb8oqDZwe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5kqIUI0aXHIVZofHKUSPYk"},"href":"https://api.spotify.com/v1/artists/5kqIUI0aXHIVZofHKUSPYk","id":"5kqIUI0aXHIVZofHKUSPYk","name":"Marlane","type":"artist","uri":"spotify:artist:5kqIUI0aXHIVZofHKUSPYk"}],"disc_number":1,"duration_ms":178836,"explicit":false,"external_ids":{"isrc":"NLQ271900097"},"external_urls":{"spotify":"https://open.spotify.com/track/69ThsvqHvh3M5l4ivab6aI"},"href":"https://api.spotify.com/v1/tracks/69ThsvqHvh3M5l4ivab6aI","id":"69ThsvqHvh3M5l4ivab6aI","is_local":false,"is_playable":true,"name":"Ik Wil Je","track_number":1,"type":"track","uri":"spotify:track:69ThsvqHvh3M5l4ivab6aI"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1CbGlqZiUyMEJpaiUyME1paiUyMEd1dXMlMjBNZWV1d2lzJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9zZWFyY2g/b2Zmc2V0PTEwJmxpbWl0PTEwJnF1ZXJ5PUJsaWpmJTIwQmlqJTIwTWlqJTIwR3V1cyUyME1lZXV3aXMmdHlwZT10cmFjayIsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyMiwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXU3dVNoemxBMXRYSmVveDNqTUZQcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xdTd1U2h6bEExdFhKZW94M2pNRlBxIiwiaWQiOiIxdTd1U2h6bEExdFhKZW94M2pNRlBxIiwibmFtZSI6IkRlIEpldWdkIFZhbiBUZWdlbndvb3JkaWciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXU3dVNoemxBMXRYSmVveDNqTUZQcSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzI5Rm8wSUJVMVp1eVpENW96UGtqQXMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yOUZvMElCVTFadXlaRDVvelBrakFzIiwiaWQiOiIyOUZvMElCVTFadXlaRDVvelBrakFzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzBmNTVkNDU3OGZlNzA0MzMzNjIzODU3NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwZjU1ZDQ1NzhmZTcwNDMzMzYyMzg1NzQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTBmNTVkNDU3OGZlNzA0MzMzNjIzODU3NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQYXJlbHMgVm9vciBEZSBad2lqbmVuIiwicmVsZWFzZV9kYXRlIjoiMjAwNS0wOS0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjI5Rm8wSUJVMVp1eVpENW96UGtqQXMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xdTd1U2h6bA==", + "QTF0WEplb3gzak1GUHEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXU3dVNoemxBMXRYSmVveDNqTUZQcSIsImlkIjoiMXU3dVNoemxBMXRYSmVveDNqTUZQcSIsIm5hbWUiOiJEZSBKZXVnZCBWYW4gVGVnZW53b29yZGlnIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF1N3VTaHpsQTF0WEplb3gzak1GUHEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzU3ODY2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjA1MDAwNDgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdodjB3eUVndkdUVE1lOXljT1Z3UFYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83aHYwd3lFZ3ZHVFRNZTl5Y09Wd1BWIiwiaWQiOiI3aHYwd3lFZ3ZHVFRNZTl5Y09Wd1BWIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlIFN0b2Z6dWlnZXIiLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2h2MHd5RWd2R1RUTWU5eWNPVndQViJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0h4MnQ5QklXRGxyM0JwZDZlV21laSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83SHgydDlCSVdEbHIzQnBkNmVXbWVpIiwiaWQiOiI3SHgydDlCSVdEbHIzQnBkNmVXbWVpIiwibmFtZSI6IlRoaWpzIEJvb250amVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdIeDJ0OUJJV0RscjNCcGQ2ZVdtZWkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80ZXVlZzBLOVJBTHJjQzRPSW5yUGROIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNGV1ZWcwSzlSQUxyY0M0T0luclBkTiIsImlkIjoiNGV1ZWcwSzlSQUxyY0M0T0luclBkTiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkY2IxZjZlOWNhZmI2NGQwOWVkOWFmZDEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZGNiMWY2ZTljYWZiNjRkMDllZDlhZmQxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYQ==", + "Z2UvYWI2NzYxNmQwMDAwNDg1MWRjYjFmNmU5Y2FmYjY0ZDA5ZWQ5YWZkMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZXplIE5hY2h0IChBbGwgTmlnaHQgTG9uZykiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTAyLTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0ZXVlZzBLOVJBTHJjQzRPSW5yUGROIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0h4MnQ5QklXRGxyM0JwZDZlV21laSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83SHgydDlCSVdEbHIzQnBkNmVXbWVpIiwiaWQiOiI3SHgydDlCSVdEbHIzQnBkNmVXbWVpIiwibmFtZSI6IlRoaWpzIEJvb250amVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdIeDJ0OUJJV0RscjNCcGQ2ZVdtZWkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQzMDA1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxCNjAyMDAwMDUyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wMHREU3FVTWp5T0lDTk5tUVNCRTh3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDB0RFNxVU1qeU9JQ05ObVFTQkU4dyIsImlkIjoiMDB0RFNxVU1qeU9JQ05ObVFTQkU4dyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZXplIE5hY2h0IChBbGwgTmlnaHQgTG9uZykiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MDB0RFNxVU1qeU9JQ05ObVFTQkU4dyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zM0tBQm5nOEdPNDJvakZKVmNBQnhRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzMzS0FCbmc4R080Mm9qRkpWY0FCeFEiLCJpZCI6IjMzS0FCbmc4R080Mm9qRkpWY0FCeFEiLCJuYW1lIjoiRWVmamUgZGUgVmlzc2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjMzS0FCbmc4R080Mm9qRkpWY0FCeFEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82aTRJSXRHUVNSdmJkQmd1UkRnZ01JIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MQ==", + "L2FsYnVtcy82aTRJSXRHUVNSdmJkQmd1UkRnZ01JIiwiaWQiOiI2aTRJSXRHUVNSdmJkQmd1UkRnZ01JIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzU0ODFlZThhYmNlOWQ3ZjhhNmZjZWVhMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1NDgxZWU4YWJjZTlkN2Y4YTZmY2VlYTIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTU0ODFlZThhYmNlOWQ3ZjhhNmZjZWVhMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCaXR0ZXJ6b2V0IiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wMS0yNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZpNElJdEdRU1J2YmRCZ3VSRGdnTUkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zM0tBQm5nOEdPNDJvakZKVmNBQnhRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzMzS0FCbmc4R080Mm9qRkpWY0FCeFEiLCJpZCI6IjMzS0FCbmc4R080Mm9qRkpWY0FCeFEiLCJuYW1lIjoiRWVmamUgZGUgVmlzc2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjMzS0FCbmc4R080Mm9qRkpWY0FCeFEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjM4NzQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxQSDYxOTAwMDAyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zOUhlOXhZSUlPZEswcFUzVTlPakFzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzlIZTl4WUlJT2RLMHBVM1U5T2pBcyIsImlkIjoiMzlIZTl4WUlJT2RLMHBVM1U5T2pBcyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCaXR0ZXJ6b2V0IiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjM5SGU5eFlJSU9kSzBwVTNVOU9qQXMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0xsYWExd3NVZERQaktta2drUVd3OSJ9LCJocmVmIjoiaHR0cA==", + "czovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNMbGFhMXdzVWREUGpLbWtna1FXdzkiLCJpZCI6IjNMbGFhMXdzVWREUGpLbWtna1FXdzkiLCJuYW1lIjoiRm91cmFkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozTGxhYTF3c1VkRFBqS21rZ2tRV3c5In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2ZTVVdpRHlKdkdMWm9FR2xhMFljYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNmU1VXaUR5SnZHTFpvRUdsYTBZY2IiLCJpZCI6IjNmU1VXaUR5SnZHTFpvRUdsYTBZY2IiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTNkNWYxNDQxNzdmNjU1NzM1YzM1YWUwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEzZDVmMTQ0MTc3ZjY1NTczNWMzNWFlMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTNkNWYxNDQxNzdmNjU1NzM1YzM1YWUwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlIEZhdm9yaWV0ZSBTY2hvb256b29ucyIsInJlbGVhc2VfZGF0ZSI6IjIwMDktMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozZlNVV2lEeUp2R0xab0VHbGEwWWNiIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0xsYWExd3NVZERQaktta2drUVd3OSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zTGxhYTF3c1VkRFBqS21rZ2tRV3c5IiwiaWQiOiIzTGxhYTF3c1VkRFBqS21rZ2tRV3c5IiwibmFtZSI6IkZvdXJhZGkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0xsYWExd3NVZERQaktta2drUVd3OSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTg0ODAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEcyNzA2MDA0MjUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdob0JkdkVqNmNmS1I4TnZESWJxMDcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83aG9CZHZFajZjZktSOE52RElicTA3IiwiaWQiOiI3aG9CZHZFag==", + "NmNmS1I4TnZESWJxMDciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMSBEaW5nIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdob0JkdkVqNmNmS1I4TnZESWJxMDcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNWFkS01hWXJHT015T2ZuYmlMUHVIZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81YWRLTWFZckdPTXlPZm5iaUxQdUhnIiwiaWQiOiI1YWRLTWFZckdPTXlPZm5iaUxQdUhnIiwibmFtZSI6Ikpvbm5hIEZyYXNlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1YWRLTWFZckdPTXlPZm5iaUxQdUhnIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMDhYQ0daSnZGQVR5SEJ3VXpkZER5biJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzA4WENHWkp2RkFUeUhCd1V6ZGREeW4iLCJpZCI6IjA4WENHWkp2RkFUeUhCd1V6ZGREeW4iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMTgzNTdhOGY4MDAxOTVjZjYxNzkyNWM5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE4MzU3YThmODAwMTk1Y2Y2MTc5MjVjOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTgzNTdhOGY4MDAxOTVjZjYxNzkyNWM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdvZWQgVGVrZW4iLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTA1LTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowOFhDR1pKdkZBVHlIQndVemRkRHluIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNWFkS01hWXJHT015T2ZuYmlMUHVIZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81YWRLTWFZckdPTXlPZm5iaUxQdUhnIiwiaWQiOiI1YWRLTWFZckdPTXlPZm5iaUxQdUhnIiwibmFtZSI6Ikpvbm5hIEZyYXNlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1YQ==", + "ZEtNYVlyR09NeU9mbmJpTFB1SGcifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUd2TUx6VXA2dE1CcGFDYnI5MDNSTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81R3ZNTHpVcDZ0TUJwYUNicjkwM1JOIiwiaWQiOiI1R3ZNTHpVcDZ0TUJwYUNicjkwM1JOIiwibmFtZSI6IkJyb2VkZXJsaWVmZGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUd2TUx6VXA2dE1CcGFDYnI5MDNSTiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjU3MzcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEc2NjE2MDAzMDUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJZNjN5ZzFMZ2RwOTZJb2laSXZqS3oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yWTYzeWcxTGdkcDk2SW9pWkl2akt6IiwiaWQiOiIyWTYzeWcxTGdkcDk2SW9pWkl2akt6IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRvIE9yIERpZSIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyWTYzeWcxTGdkcDk2SW9pWkl2akt6In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZzNXViQXA2NXdYb1RaZWZFMDFSTlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnM1dWJBcDY1d1hvVFplZkUwMVJOUiIsImlkIjoiNnM1dWJBcDY1d1hvVFplZkUwMVJOUiIsIm5hbWUiOiJKb29zdCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2czV1YkFwNjV3WG9UWmVmRTAxUk5SIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMjYwVklIRmRHTnNITDNES1VaWVlrYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzI2MFZJSEZkR05zSEwzREtVWllZa2MiLCJpZCI6IjI2MFZJSEZkR05zSEwzREtVWllZa2MiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzVkOTg4OTRkN2Y5N2RjMTJjMWRmMjhhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjM1ZDk4ODk0ZDdmOQ==", + "N2RjMTJjMWRmMjhhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzNWQ5ODg5NGQ3Zjk3ZGMxMmMxZGYyOGEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWxiaW5vIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wMS0xOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjI2MFZJSEZkR05zSEwzREtVWllZa2MifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82czV1YkFwNjV3WG9UWmVmRTAxUk5SIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZzNXViQXA2NXdYb1RaZWZFMDFSTlIiLCJpZCI6IjZzNXViQXA2NXdYb1RaZWZFMDFSTlIiLCJuYW1lIjoiSm9vc3QiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnM1dWJBcDY1d1hvVFplZkUwMVJOUiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yM21idkRJWkpqU0s0eTRLaHdsbkhpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzIzbWJ2RElaSmpTSzR5NEtod2xuSGkiLCJpZCI6IjIzbWJ2RElaSmpTSzR5NEtod2xuSGkiLCJuYW1lIjoiTWljayBTcGVrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjIzbWJ2RElaSmpTSzR5NEtod2xuSGkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc0MzEyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkwxTUMxOTAwMDA5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83bkx3VXVqTE1qRXc2a2hBOTdONkkyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN25Md1V1akxNakV3NmtoQTk3TjZJMiIsImlkIjoiN25Md1V1akxNakV3NmtoQTk3TjZJMiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHdXVzIE1lZXV3aXMiLCJ0cmFja19udW1iZXIiOjEyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjduTHdVdWpMTWpFdzZraEE5N042STIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMUdXcGRkZndMOWJWb3ZPekN0TlFONiJ9LCJocmVmIjoiaHR0cHM6Lw==", + "L2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFHV3BkZGZ3TDliVm92T3pDdE5RTjYiLCJpZCI6IjFHV3BkZGZ3TDliVm92T3pDdE5RTjYiLCJuYW1lIjoiUm94ZWFubmUgSGF6ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUdXcGRkZndMOWJWb3ZPekN0TlFONiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZteWN6TzNkQ3VMbmpTb1VTNnlPZlkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82bXljek8zZEN1TG5qU29VUzZ5T2ZZIiwiaWQiOiI2bXljek8zZEN1TG5qU29VUzZ5T2ZZIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzgyMWU0ZTlmZmI2ZmQ1OTNjZmU0NzE2YyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4MjFlNGU5ZmZiNmZkNTkzY2ZlNDcxNmMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTgyMWU0ZTlmZmI2ZmQ1OTNjZmU0NzE2YyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZSBUaWpkIEdhYXQgTW9vaWUgRGluZ2VuIERvZW4iLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTEwLTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nm15Y3pPM2RDdUxualNvVVM2eU9mWSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFHV3BkZGZ3TDliVm92T3pDdE5RTjYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUdXcGRkZndMOWJWb3ZPekN0TlFONiIsImlkIjoiMUdXcGRkZndMOWJWb3ZPekN0TlFONiIsIm5hbWUiOiJSb3hlYW5uZSBIYXplcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxR1dwZGRmd0w5YlZvdk96Q3ROUU42In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3MDUwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MVU03MjMwMTA1NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGx4TFN6T1BaU2QxWk1yaE1GSGxpRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRseExTek9QWlNkMVpNcmhNRkhsaQ==", + "RCIsImlkIjoiNGx4TFN6T1BaU2QxWk1yaE1GSGxpRCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZSBXZXJlbGQgRHJhYWl0IERvb3IiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGx4TFN6T1BaU2QxWk1yaE1GSGxpRCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80dm9uUnUxTFg0OWFyRU5IZ3Jra0Q2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzR2b25SdTFMWDQ5YXJFTkhncmtrRDYiLCJpZCI6IjR2b25SdTFMWDQ5YXJFTkhncmtrRDYiLCJuYW1lIjoiQmx1ZSBEb2ciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHZvblJ1MUxYNDlhckVOSGdya2tENiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzYxTjB1SzByVFBiaFo0NnBnQTlTa1QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82MU4wdUswclRQYmhaNDZwZ0E5U2tUIiwiaWQiOiI2MU4wdUswclRQYmhaNDZwZ0E5U2tUIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzdiOGQ3ZDUzMzdmZTc5NzAzMDI1NjllYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3YjhkN2Q1MzM3ZmU3OTcwMzAyNTY5ZWMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTdiOGQ3ZDUzMzdmZTc5NzAzMDI1NjllYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb25ncyBvZiB0aGUgQW50aHJvcG9jZW5lIElJIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wNi0yNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjYxTjB1SzByVFBiaFo0NnBnQTlTa1QifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80dm9uUnUxTFg0OWFyRU5IZ3Jra0Q2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzR2b25SdTFMWDQ5YXJFTkhncmtrRDYiLCJpZCI6IjR2b25SdTFMWDQ5YXJFTkhncmtrRDYiLCJuYW1lIjoiQmx1ZSBEbw==", + "ZyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0dm9uUnUxTFg0OWFyRU5IZ3Jra0Q2In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2MTU0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaRllaMTkzMzM5NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2F4dHNmSndOUng5dzc3UXJ4akZ0eSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdheHRzZkp3TlJ4OXc3N1FyeGpGdHkiLCJpZCI6IjdheHRzZkp3TlJ4OXc3N1FyeGpGdHkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmxpamYgQmlqIE1paiIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3YXh0c2ZKd05SeDl3NzdRcnhqRnR5In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdDQXRtdXlHbHpZdW00QktmbDM0aWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0NBdG11eUdsell1bTRCS2ZsMzRpaiIsImlkIjoiN0NBdG11eUdsell1bTRCS2ZsMzRpaiIsIm5hbWUiOiJHb3JraSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3Q0F0bXV5R2x6WXVtNEJLZmwzNGlqIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFo0OGVwM1VnWXVCb0dFTFFQdHEyeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRaNDhlcDNVZ1l1Qm9HRUxRUHRxMnkiLCJpZCI6IjRaNDhlcDNVZ1l1Qm9HRUxRUHRxMnkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMThjNjZmYzU0MzU2YTZlMzYzYTQzNWU0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE4YzY2ZmM1NDM1NmE2ZTM2M2E0MzVlNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMThjNjZmYzU0MzU2YTZlMzYzYTQzNWU0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJvdGVyaGFtbWVuIiwicmVsZWFzZV9kYXRlIjoiMTk5Mi0wNy0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cg==", + "YWNrcyI6OCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0WjQ4ZXAzVWdZdUJvR0VMUVB0cTJ5In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0NBdG11eUdsell1bTRCS2ZsMzRpaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83Q0F0bXV5R2x6WXVtNEJLZmwzNGlqIiwiaWQiOiI3Q0F0bXV5R2x6WXVtNEJLZmwzNGlqIiwibmFtZSI6IkdvcmtpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdDQXRtdXlHbHpZdW00QktmbDM0aWoifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg3ODAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiQkVWMDE5MjAwMTAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wZm9mVEhLYXVhMkp5Zlh0QlRwcFFSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGZvZlRIS2F1YTJKeWZYdEJUcHBRUiIsImlkIjoiMGZvZlRIS2F1YTJKeWZYdEJUcHBRUiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJayB3b3JkIG91ZCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowZm9mVEhLYXVhMkp5Zlh0QlRwcFFSIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81a3FJVUkwYVhISVZab2ZIS1VTUFlrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVrcUlVSTBhWEhJVlpvZkhLVVNQWWsiLCJpZCI6IjVrcUlVSTBhWEhJVlpvZkhLVVNQWWsiLCJuYW1lIjoiTWFybGFuZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1a3FJVUkwYVhISVZab2ZIS1VTUFlrIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMGF4czQweHNMVG94eHpiOG9xRFp3ZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBheHM0MHhzTFRveHh6YjhvcURad2UiLCJpZCI6IjBheHM0MHhzTFRveHg=", + "emI4b3FEWndlIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ExNTg2ODUxMTM4Y2I1OThjZmVlMDEyMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhMTU4Njg1MTEzOGNiNTk4Y2ZlZTAxMjMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWExNTg2ODUxMTM4Y2I1OThjZmVlMDEyMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJayBXaWwgSmUiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTEwLTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowYXhzNDB4c0xUb3h4emI4b3FEWndlIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNWtxSVVJMGFYSElWWm9mSEtVU1BZayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81a3FJVUkwYVhISVZab2ZIS1VTUFlrIiwiaWQiOiI1a3FJVUkwYVhISVZab2ZIS1VTUFlrIiwibmFtZSI6Ik1hcmxhbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWtxSVVJMGFYSElWWm9mSEtVU1BZayJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzg4MzYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFEyNzE5MDAwOTcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzY5VGhzdnFIdmgzTTVsNGl2YWI2YUkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82OVRoc3ZxSHZoM001bDRpdmFiNmFJIiwiaWQiOiI2OVRoc3ZxSHZoM001bDRpdmFiNmFJIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IklrIFdpbCBKZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2OVRoc3ZxSHZoM001bDRpdmFiNmFJIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Blijf+Bij+Mij+Guus+Meeuwis&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRyb21lbiUyMFppam4lMjBCZWRyb2clMjIlMjBhcnRpc3QlM0ElMjJGcmFucyUyMEJhdWVyJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRyb21lbiUyMFppam4lMjBCZWRyb2clMjIlMjBhcnRpc3QlM0ElMjJGcmFucyUyMEJhdWVyJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Dromen+Zijn+Bedrog%22+artist%3A%22Frans+Bauer%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Waarom%20Nou%20Jij%22%20artist%3A%22Marco%20Borsato%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":6,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/6aNqB0DO4ni5VNDEjDwH8g"},"href":"https://api.spotify.com/v1/albums/6aNqB0DO4ni5VNDEjDwH8g","id":"6aNqB0DO4ni5VNDEjDwH8g","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d21f6dcb3cc6b759f1fca232"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d21f6dcb3cc6b759f1fca232"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d21f6dcb3cc6b759f1fca232"}],"is_playable":true,"name":"Onderweg","release_date":"2002","release_date_precision":"year","total_tracks":32,"type":"album","uri":"spotify:album:6aNqB0DO4ni5VNDEjDwH8g"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":244800,"explicit":false,"external_ids":{"isrc":"NLA319400230"},"external_urls":{"spotify":"https://open.spotify.com/track/1gw0YCogZvwqh39aCj7ksZ"},"href":"https://api.spotify.com/v1/tracks/1gw0YCogZvwqh39aCj7ksZ","id":"1gw0YCogZvwqh39aCj7ksZ","is_local":false,"is_playable":true,"name":"Waarom Nou Jij - Radio Edit","track_number":14,"type":"track","uri":"spotify:track:1gw0YCogZvwqh39aCj7ksZ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OELFWvZ1tR4wKREmndcEJ"},"href":"https://api.spotify.com/v1/albums/0OELFWvZ1tR4wKREmndcEJ","id":"0OELFWvZ1tR4wKREmndcEJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c81c59d560502cd89d5bf1a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c81c59d560502cd89d5bf1a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c81c59d560502cd89d5bf1a"}],"is_playable":true,"name":"Marco","release_date":"1994-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0OELFWvZ1tR4wKREmndcEJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":289440,"explicit":false,"external_ids":{"isrc":"NLA319400203"},"external_urls":{"spotify":"https://open.spotify.com/track/1ZaWR909NbpUVEAxpgf7hW"},"href":"https://api.spotify.com/v1/tracks/1ZaWR909NbpUVEAxpgf7hW","id":"1ZaWR909NbpUVEAxpgf7hW","is_local":false,"is_playable":true,"name":"Waarom Nou Jij","track_number":5,"type":"track","uri":"spotify:track:1ZaWR909NbpUVEAxpgf7hW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/6P8MGrO5WKfHnrXOw45jfR"},"href":"https://api.spotify.com/v1/albums/6P8MGrO5WKfHnrXOw45jfR","id":"6P8MGrO5WKfHnrXOw45jfR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c189fdd3cf3ad54e6b8344d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c189fdd3cf3ad54e6b8344d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c189fdd3cf3ad54e6b8344d7"}],"is_playable":true,"name":"#1","release_date":"2011-11-25","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:6P8MGrO5WKfHnrXOw45jfR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":244906,"explicit":false,"external_ids":{"isrc":"NLA319400230"},"external_urls":{"spotify":"https://open.spotify.com/track/1IPZSKXc8tAL0lFco019WF"},"href":"https://api.spotify.com/v1/tracks/1IPZSKXc8tAL0lFco019WF","id":"1IPZSKXc8tAL0lFco019WF","is_local":false,"is_playable":true,"name":"Waarom Nou Jij","track_number":2,"type":"track","uri":"spotify:track:1IPZSKXc8tAL0lFco019WF"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/2Rf3Qpa9lGq7q4u7zLDaoA"},"href":"https://api.spotify.com/v1/albums/2Rf3Qpa9lGq7q4u7zLDaoA","id":"2Rf3Qpa9lGq7q4u7zLDaoA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273549180fa896ebbc801ac4faa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02549180fa896ebbc801ac4faa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851549180fa896ebbc801ac4faa"}],"is_playable":true,"name":"Wit Licht LIVE","release_date":"2009-01-01","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:2Rf3Qpa9lGq7q4u7zLDaoA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":2,"duration_ms":332720,"explicit":false,"external_ids":{"isrc":"NLUM70900035"},"external_urls":{"spotify":"https://open.spotify.com/track/4gHq46PIPGUDhglQUtdqOA"},"href":"https://api.spotify.com/v1/tracks/4gHq46PIPGUDhglQUtdqOA","id":"4gHq46PIPGUDhglQUtdqOA","is_local":false,"is_playable":true,"name":"Waarom Nou Jij - Live","track_number":7,"type":"track","uri":"spotify:track:4gHq46PIPGUDhglQUtdqOA"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/338hnTNJmwzF5pAB8vWJYc"},"href":"https://api.spotify.com/v1/albums/338hnTNJmwzF5pAB8vWJYc","id":"338hnTNJmwzF5pAB8vWJYc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ece2487618d34bdc659a85a5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ece2487618d34bdc659a85a5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ece2487618d34bdc659a85a5"}],"is_playable":true,"name":"Onderweg","release_date":"2002-01-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:338hnTNJmwzF5pAB8vWJYc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":244800,"explicit":false,"external_ids":{"isrc":"NLA319400230"},"external_urls":{"spotify":"https://open.spotify.com/track/68so2VknkAvKz0hlvy0pYL"},"href":"https://api.spotify.com/v1/tracks/68so2VknkAvKz0hlvy0pYL","id":"68so2VknkAvKz0hlvy0pYL","is_local":false,"is_playable":true,"name":"Waarom Nou Jij - Radio Edit","track_number":14,"type":"track","uri":"spotify:track:68so2VknkAvKz0hlvy0pYL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/0YDTWNkJOF81Sis0Yw6qhQ"},"href":"https://api.spotify.com/v1/albums/0YDTWNkJOF81Sis0Yw6qhQ","id":"0YDTWNkJOF81Sis0Yw6qhQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bb2243f338194665141f9dbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bb2243f338194665141f9dbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bb2243f338194665141f9dbc"}],"is_playable":true,"name":"Marco Borsato 1994 - 1997","release_date":"2006-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:0YDTWNkJOF81Sis0Yw6qhQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":289120,"explicit":false,"external_ids":{"isrc":"NLA319400203"},"external_urls":{"spotify":"https://open.spotify.com/track/3HHZS6PyMR4MQujYTi0gcy"},"href":"https://api.spotify.com/v1/tracks/3HHZS6PyMR4MQujYTi0gcy","id":"3HHZS6PyMR4MQujYTi0gcy","is_local":false,"is_playable":true,"name":"Waarom Nou Jij","track_number":9,"type":"track","uri":"spotify:track:3HHZS6PyMR4MQujYTi0gcy"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhYXJvbSUyME5vdSUyMEppaiUyMiUyMGFydGlzdCUzQSUyMk1hcmNvJTIwQm9yc2F0byUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NiwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwiaWQiOiIzRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwibmFtZSI6Ik1hcmNvIEJvcnNhdG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZhTnFCMERPNG5pNVZOREVqRHdIOGcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82YU5xQjBETzRuaTVWTkRFakR3SDhnIiwiaWQiOiI2YU5xQjBETzRuaTVWTkRFakR3SDhnIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoi", + "aHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2QyMWY2ZGNiM2NjNmI3NTlmMWZjYTIzMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkMjFmNmRjYjNjYzZiNzU5ZjFmY2EyMzIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWQyMWY2ZGNiM2NjNmI3NTlmMWZjYTIzMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPbmRlcndlZyIsInJlbGVhc2VfZGF0ZSI6IjIwMDIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MzIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NmFOcUIwRE80bmk1Vk5ERWpEd0g4ZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ0ODAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxBMzE5NDAwMjMwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xZ3cwWUNvZ1p2d3FoMzlhQ2o3a3NaIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMWd3MFlDb2dadndxaDM5YUNqN2tzWiIsImlkIjoiMWd3MFlDb2dadndxaDM5YUNqN2tzWiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWFyb20gTm91IEppaiAtIFJhZGlvIEVkaXQiLCJ0cmFja19udW1iZXIiOjE0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFndzBZQ29nWnZ3cWgzOWFDajdrc1oifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwiaWQiOiIzRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwibmFtZSI6Ik1hcg==", + "Y28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vME9FTEZXdloxdFI0d0tSRW1uZGNFSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBPRUxGV3ZaMXRSNHdLUkVtbmRjRUoiLCJpZCI6IjBPRUxGV3ZaMXRSNHdLUkVtbmRjRUoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmM4MWM1OWQ1NjA1MDJjZDg5ZDViZjFhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZjODFjNTlkNTYwNTAyY2Q4OWQ1YmYxYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmM4MWM1OWQ1NjA1MDJjZDg5ZDViZjFhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1hcmNvIiwicmVsZWFzZV9kYXRlIjoiMTk5NC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBPRUxGV3ZaMXRSNHdLUkVtbmRjRUoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJpZCI6IjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJuYW1lIjoiTWFyY28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI4OTQ0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTMxOTQwMDIwMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVphV1I5MDlOYnBVVkVBeHBnZjdoVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFaYVdSOTA5TmJwVVZFQXhwZ2Y3aFciLCJpZCI6IjFaYVdSOTA5TmJwVVZFQXhwZ2Y3aFciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2Fhcm9tIE5vdSBKaWoiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cg==", + "YWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxWmFXUjkwOU5icFVWRUF4cGdmN2hXIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82UDhNR3JPNVdLZkhuclhPdzQ1amZSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNlA4TUdyTzVXS2ZIbnJYT3c0NWpmUiIsImlkIjoiNlA4TUdyTzVXS2ZIbnJYT3c0NWpmUiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjMTg5ZmRkM2NmM2FkNTRlNmI4MzQ0ZDcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzE4OWZkZDNjZjNhZDU0ZTZiODM0NGQ3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjMTg5ZmRkM2NmM2FkNTRlNmI4MzQ0ZDcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiIzEiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTExLTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlA4TUdyTzVXS2ZIbnJYT3c0NWpmUiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ0OTA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6ew==", + "ImlzcmMiOiJOTEEzMTk0MDAyMzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFJUFpTS1hjOHRBTDBsRmNvMDE5V0YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xSVBaU0tYYzh0QUwwbEZjbzAxOVdGIiwiaWQiOiIxSVBaU0tYYzh0QUwwbEZjbzAxOVdGIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhYXJvbSBOb3UgSmlqIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFJUFpTS1hjOHRBTDBsRmNvMDE5V0YifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwiaWQiOiIzRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwibmFtZSI6Ik1hcmNvIEJvcnNhdG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJSZjNRcGE5bEdxN3E0dTd6TERhb0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yUmYzUXBhOWxHcTdxNHU3ekxEYW9BIiwiaWQiOiIyUmYzUXBhOWxHcTdxNHU3ekxEYW9BIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzU0OTE4MGZhODk2ZWJiYzgwMWFjNGZhYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1NDkxODBmYTg5NmViYmM4MDFhYzRmYWEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTU0OTE4MGZhODk2ZWJiYzgwMWFjNGZhYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXaXQgTGljaHQgTElWRSIsInJlbGVhc2VfZGF0ZSI6IjIwMDktMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyUmYzUXBhOWxHcTdxNHU3ekxEYW9BIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcA==", + "b3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJpZCI6IjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJuYW1lIjoiTWFyY28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjMzMjcyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MVU03MDkwMDAzNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGdIcTQ2UElQR1VEaGdsUVV0ZHFPQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRnSHE0NlBJUEdVRGhnbFFVdGRxT0EiLCJpZCI6IjRnSHE0NlBJUEdVRGhnbFFVdGRxT0EiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2Fhcm9tIE5vdSBKaWogLSBMaXZlIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRnSHE0NlBJUEdVRGhnbFFVdGRxT0EifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwiaWQiOiIzRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwibmFtZSI6Ik1hcmNvIEJvcnNhdG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzMzOGhuVE5KbXd6RjVwQUI4dldKWWMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zMzhoblROSm13ekY1cEFCOHZXSlljIiwiaWQiOiIzMzhoblROSm13ekY1cEFCOHZXSlljIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2VjZTI0ODc2MThkMzRiZGM2NTlhODVhNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlY2UyNDg3NjE4ZDM0YmRjNjU5YTg1YTUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidQ==", + "cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZWNlMjQ4NzYxOGQzNGJkYzY1OWE4NWE1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik9uZGVyd2VnIiwicmVsZWFzZV9kYXRlIjoiMjAwMi0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjMzOGhuVE5KbXd6RjVwQUI4dldKWWMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJpZCI6IjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJuYW1lIjoiTWFyY28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NDgwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTMxOTQwMDIzMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNjhzbzJWa25rQXZLejBobHZ5MHBZTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzY4c28yVmtua0F2S3owaGx2eTBwWUwiLCJpZCI6IjY4c28yVmtua0F2S3owaGx2eTBwWUwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2Fhcm9tIE5vdSBKaWogLSBSYWRpbyBFZGl0IiwidHJhY2tfbnVtYmVyIjoxNCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2OHNvMlZrbmtBdkt6MGhsdnkwcFlMIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wWURUV05rSk9GODFTaXMwWXc2cWhRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcA==", + "b3RpZnkuY29tL3YxL2FsYnVtcy8wWURUV05rSk9GODFTaXMwWXc2cWhRIiwiaWQiOiIwWURUV05rSk9GODFTaXMwWXc2cWhRIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2JiMjI0M2YzMzgxOTQ2NjUxNDFmOWRiYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiYjIyNDNmMzM4MTk0NjY1MTQxZjlkYmMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWJiMjI0M2YzMzgxOTQ2NjUxNDFmOWRiYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIDE5OTQgLSAxOTk3IiwicmVsZWFzZV9kYXRlIjoiMjAwNi0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBZRFRXTmtKT0Y4MVNpczBZdzZxaFEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJpZCI6IjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJuYW1lIjoiTWFyY28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI4OTEyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTMxOTQwMDIwMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0hIWlM2UHlNUjRNUXVqWVRpMGdjeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNISFpTNlB5TVI0TVF1allUaTBnY3kiLCJpZCI6IjNISFpTNlB5TVI0TVF1allUaTBnY3kiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2Fhcm9tIE5vdSBKaWoiLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0hIWlM2UHlNUjRNUXVqWVRpMGdjeSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Waarom+Nou+Jij%22+artist%3A%22Marco+Borsato%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkxpZWZzJTIwVWl0JTIwQW1zdGVyZGFtJTIyJTIwYXJ0aXN0JTNBJTIyTGFuZ2UlMjBGcmFucyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkxpZWZzJTIwVWl0JTIwQW1zdGVyZGFtJTIyJTIwYXJ0aXN0JTNBJTIyTGFuZ2UlMjBGcmFucyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Liefs+Uit+Amsterdam%22+artist%3A%22Lange+Frans%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRvZW4lMjBJayUyMEplJTIwWmFnJTIyJTIwYXJ0aXN0JTNBJTIyTmllbHNvbiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRvZW4lMjBJayUyMEplJTIwWmFnJTIyJTIwYXJ0aXN0JTNBJTIyTmllbHNvbiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Toen+Ik+Je+Zag%22+artist%3A%22Nielson%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Het%20Land%20Van...%22%20artist%3A%22Lange%20Frans%2C%20Baas%20B%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/6um3VlGOcC7PWzcKeYidCV"},"href":"https://api.spotify.com/v1/albums/6um3VlGOcC7PWzcKeYidCV","id":"6um3VlGOcC7PWzcKeYidCV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e2e4b4cf54573a895f7defa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e2e4b4cf54573a895f7defa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e2e4b4cf54573a895f7defa"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-08-10","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:6um3VlGOcC7PWzcKeYidCV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":230440,"explicit":false,"external_ids":{"isrc":"NLG270500124"},"external_urls":{"spotify":"https://open.spotify.com/track/0wMAsL98TGuI6eWUEocd1O"},"href":"https://api.spotify.com/v1/tracks/0wMAsL98TGuI6eWUEocd1O","id":"0wMAsL98TGuI6eWUEocd1O","is_local":false,"is_playable":true,"name":"Het Land Van","track_number":2,"type":"track","uri":"spotify:track:0wMAsL98TGuI6eWUEocd1O"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GxCjxM4YUabJgybJq06XT"},"href":"https://api.spotify.com/v1/artists/3GxCjxM4YUabJgybJq06XT","id":"3GxCjxM4YUabJgybJq06XT","name":"Lange Frans & Baas B","type":"artist","uri":"spotify:artist:3GxCjxM4YUabJgybJq06XT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/7G7sz71wV7PLd4mi3vb44s"},"href":"https://api.spotify.com/v1/albums/7G7sz71wV7PLd4mi3vb44s","id":"7G7sz71wV7PLd4mi3vb44s","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27329210b1922d3a7887c5deb39"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0229210b1922d3a7887c5deb39"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485129210b1922d3a7887c5deb39"}],"is_playable":true,"name":"Het Land van Vriendschap","release_date":"2019-09-27","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:7G7sz71wV7PLd4mi3vb44s"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GxCjxM4YUabJgybJq06XT"},"href":"https://api.spotify.com/v1/artists/3GxCjxM4YUabJgybJq06XT","id":"3GxCjxM4YUabJgybJq06XT","name":"Lange Frans & Baas B","type":"artist","uri":"spotify:artist:3GxCjxM4YUabJgybJq06XT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":252077,"explicit":false,"external_ids":{"isrc":"QM7281999077"},"external_urls":{"spotify":"https://open.spotify.com/track/6cL2Iu5NjLB6vAE4AmvL5G"},"href":"https://api.spotify.com/v1/tracks/6cL2Iu5NjLB6vAE4AmvL5G","id":"6cL2Iu5NjLB6vAE4AmvL5G","is_local":false,"is_playable":true,"name":"Het Land van Vriendschap - Instrumental","track_number":2,"type":"track","uri":"spotify:track:6cL2Iu5NjLB6vAE4AmvL5G"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/7KNScUfntGmEglib8BOvIw"},"href":"https://api.spotify.com/v1/albums/7KNScUfntGmEglib8BOvIw","id":"7KNScUfntGmEglib8BOvIw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27315e20f9f09d1134c65cf5057"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0215e20f9f09d1134c65cf5057"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485115e20f9f09d1134c65cf5057"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-01-01","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:7KNScUfntGmEglib8BOvIw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":262706,"explicit":false,"external_ids":{"isrc":"NLG270500123"},"external_urls":{"spotify":"https://open.spotify.com/track/7bOLDp1XTFUVWvARR2IhwB"},"href":"https://api.spotify.com/v1/tracks/7bOLDp1XTFUVWvARR2IhwB","id":"7bOLDp1XTFUVWvARR2IhwB","is_local":false,"is_playable":true,"name":"Het Land Van - Live","track_number":1,"type":"track","uri":"spotify:track:7bOLDp1XTFUVWvARR2IhwB"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/6um3VlGOcC7PWzcKeYidCV"},"href":"https://api.spotify.com/v1/albums/6um3VlGOcC7PWzcKeYidCV","id":"6um3VlGOcC7PWzcKeYidCV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e2e4b4cf54573a895f7defa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e2e4b4cf54573a895f7defa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e2e4b4cf54573a895f7defa"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-08-10","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:6um3VlGOcC7PWzcKeYidCV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":262706,"explicit":false,"external_ids":{"isrc":"NLG270500123"},"external_urls":{"spotify":"https://open.spotify.com/track/5dpiBQNmK5XzdELUZoOmA7"},"href":"https://api.spotify.com/v1/tracks/5dpiBQNmK5XzdELUZoOmA7","id":"5dpiBQNmK5XzdELUZoOmA7","is_local":false,"is_playable":true,"name":"Het Land Van - Live","track_number":1,"type":"track","uri":"spotify:track:5dpiBQNmK5XzdELUZoOmA7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GxCjxM4YUabJgybJq06XT"},"href":"https://api.spotify.com/v1/artists/3GxCjxM4YUabJgybJq06XT","id":"3GxCjxM4YUabJgybJq06XT","name":"Lange Frans & Baas B","type":"artist","uri":"spotify:artist:3GxCjxM4YUabJgybJq06XT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/7G7sz71wV7PLd4mi3vb44s"},"href":"https://api.spotify.com/v1/albums/7G7sz71wV7PLd4mi3vb44s","id":"7G7sz71wV7PLd4mi3vb44s","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27329210b1922d3a7887c5deb39"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0229210b1922d3a7887c5deb39"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485129210b1922d3a7887c5deb39"}],"is_playable":true,"name":"Het Land van Vriendschap","release_date":"2019-09-27","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:7G7sz71wV7PLd4mi3vb44s"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GxCjxM4YUabJgybJq06XT"},"href":"https://api.spotify.com/v1/artists/3GxCjxM4YUabJgybJq06XT","id":"3GxCjxM4YUabJgybJq06XT","name":"Lange Frans & Baas B","type":"artist","uri":"spotify:artist:3GxCjxM4YUabJgybJq06XT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":252077,"explicit":false,"external_ids":{"isrc":"QM7281988518"},"external_urls":{"spotify":"https://open.spotify.com/track/681hSZvGVUWR9K5CUxLqMD"},"href":"https://api.spotify.com/v1/tracks/681hSZvGVUWR9K5CUxLqMD","id":"681hSZvGVUWR9K5CUxLqMD","is_local":false,"is_playable":true,"name":"Het Land van Vriendschap","track_number":1,"type":"track","uri":"spotify:track:681hSZvGVUWR9K5CUxLqMD"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkhldCUyMExhbmQlMjBWYW4uLi4lMjIlMjBhcnRpc3QlM0ElMjJMYW5nZSUyMEZyYW5zJTJDJTIwQmFhcyUyMEIlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJpZCI6IjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJuYW1lIjoiQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVy", + "aSI6InNwb3RpZnk6YXJ0aXN0OjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82dW0zVmxHT2NDN1BXemNLZVlpZENWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnVtM1ZsR09jQzdQV3pjS2VZaWRDViIsImlkIjoiNnVtM1ZsR09jQzdQV3pjS2VZaWRDViIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3ZTJlNGI0Y2Y1NDU3M2E4OTVmN2RlZmEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyN2UyZTRiNGNmNTQ1NzNhODk1ZjdkZWZhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3ZTJlNGI0Y2Y1NDU3M2E4OTVmN2RlZmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGV0IExhbmQgVmFuIiwicmVsZWFzZV9kYXRlIjoiMjAwNS0wOC0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NnVtM1ZsR09jQzdQV3pjS2VZaWRDViJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzA0NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEcyNzA1MDAxMjQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cA==", + "czovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHdNQXNMOThUR3VJNmVXVUVvY2QxTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzB3TUFzTDk4VEd1STZlV1VFb2NkMU8iLCJpZCI6IjB3TUFzTDk4VEd1STZlV1VFb2NkMU8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGV0IExhbmQgVmFuIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjB3TUFzTDk4VEd1STZlV1VFb2NkMU8ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNHeENqeE00WVVhYkpneWJKcTA2WFQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0d4Q2p4TTRZVWFiSmd5YkpxMDZYVCIsImlkIjoiM0d4Q2p4TTRZVWFiSmd5YkpxMDZYVCIsIm5hbWUiOiJMYW5nZSBGcmFucyAmIEJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozR3hDanhNNFlVYWJKZ3liSnEwNlhUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdHN3N6NzF3VjdQTGQ0bWkzdmI0NHMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83Rzdzejcxd1Y3UExkNG1pM3ZiNDRzIiwiaWQiOiI3Rzdzejcxd1Y3UExkNG1pM3ZiNDRzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZw==", + "ZS9hYjY3NjE2ZDAwMDBiMjczMjkyMTBiMTkyMmQzYTc4ODdjNWRlYjM5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI5MjEwYjE5MjJkM2E3ODg3YzVkZWIzOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjkyMTBiMTkyMmQzYTc4ODdjNWRlYjM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBMYW5kIHZhbiBWcmllbmRzY2hhcCIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDktMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdHN3N6NzF3VjdQTGQ0bWkzdmI0NHMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zR3hDanhNNFlVYWJKZ3liSnEwNlhUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNHeENqeE00WVVhYkpneWJKcTA2WFQiLCJpZCI6IjNHeENqeE00WVVhYkpneWJKcTA2WFQiLCJuYW1lIjoiTGFuZ2UgRnJhbnMgJiBCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0d4Q2p4TTRZVWFiSmd5YkpxMDZYVCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJpZCI6IjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJuYW1lIjoiQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjUyMDc3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU03MjgxOTk5MDc3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOg==", + "Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZjTDJJdTVOakxCNnZBRTRBbXZMNUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82Y0wySXU1TmpMQjZ2QUU0QW12TDVHIiwiaWQiOiI2Y0wySXU1TmpMQjZ2QUU0QW12TDVHIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBMYW5kIHZhbiBWcmllbmRzY2hhcCAtIEluc3RydW1lbnRhbCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2Y0wySXU1TmpMQjZ2QUU0QW12TDVHIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdLTlNjVWZudEdtRWdsaWI4Qk92SXcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83S05TY1VmbnRHbUVnbGliOEJPdkl3IiwiaWQiOiI3S05TY1VmbnRHbUVnbGliOEJPdkl3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNWUyMGY5ZjA5ZDExMzRjNjVjZjUwNTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9XSwiaXNfcGxheQ==", + "YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBMYW5kIFZhbiIsInJlbGVhc2VfZGF0ZSI6IjIwMDUtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3S05TY1VmbnRHbUVnbGliOEJPdkl3In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwiaWQiOiI1STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwibmFtZSI6IkxhbmdlIEZyYW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwiaWQiOiIyVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwibmFtZSI6IkJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVVlQOE5YVW9OMmJGeDdzeWxXUTE0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2MjcwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzI3MDUwMDEyMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2JPTERwMVhURlVWV3ZBUlIySWh3QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdiT0xEcDFYVEZVVld2QVJSMklod0IiLCJpZCI6IjdiT0xEcDFYVEZVVld2QVJSMklod0IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGV0IExhbmQgVmFuIC0gTGl2ZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3Yk9MRHAxWFRGVVZXdkFSUjJJaHdCIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eQ==", + "cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ1bTNWbEdPY0M3UFd6Y0tlWWlkQ1YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82dW0zVmxHT2NDN1BXemNLZVlpZENWIiwiaWQiOiI2dW0zVmxHT2NDN1BXemNLZVlpZENWIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzdlMmU0YjRjZjU0NTczYTg5NWY3ZGVmYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3ZTJlNGI0Y2Y1NDU3M2E4OTVmN2RlZmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTdlMmU0YjRjZjU0NTczYTg5NWY3ZGVmYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXQgTGFuZCBWYW4iLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTA4LTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2dW0zVmxHT2NDN1BXemNLZVlpZENWIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwiaWQiOiI1STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwibmFtZSI6IkxhbmdlIEZyYW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdA==", + "aWZ5LmNvbS92MS9hcnRpc3RzLzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJpZCI6IjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJuYW1lIjoiQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjYyNzA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHMjcwNTAwMTIzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81ZHBpQlFObUs1WHpkRUxVWm9PbUE3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNWRwaUJRTm1LNVh6ZEVMVVpvT21BNyIsImlkIjoiNWRwaUJRTm1LNVh6ZEVMVVpvT21BNyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXQgTGFuZCBWYW4gLSBMaXZlIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVkcGlCUU5tSzVYemRFTFVab09tQTcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNHeENqeE00WVVhYkpneWJKcTA2WFQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0d4Q2p4TTRZVWFiSmd5YkpxMDZYVCIsImlkIjoiM0d4Q2p4TTRZVWFiSmd5YkpxMDZYVCIsIm5hbWUiOiJMYW5nZSBGcmFucyAmIEJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozR3hDanhNNFlVYWJKZ3liSnEwNlhUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoicw==", + "cG90aWZ5OmFydGlzdDoyVVlQOE5YVW9OMmJGeDdzeWxXUTE0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN0c3c3o3MXdWN1BMZDRtaTN2YjQ0cyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdHN3N6NzF3VjdQTGQ0bWkzdmI0NHMiLCJpZCI6IjdHN3N6NzF3VjdQTGQ0bWkzdmI0NHMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjkyMTBiMTkyMmQzYTc4ODdjNWRlYjM5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI5MjEwYjE5MjJkM2E3ODg3YzVkZWIzOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjkyMTBiMTkyMmQzYTc4ODdjNWRlYjM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBMYW5kIHZhbiBWcmllbmRzY2hhcCIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDktMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdHN3N6NzF3VjdQTGQ0bWkzdmI0NHMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zR3hDanhNNFlVYWJKZ3liSnEwNlhUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNHeENqeE00WVVhYkpneWJKcTA2WFQiLCJpZCI6IjNHeENqeE00WVVhYkpneWJKcTA2WFQiLCJuYW1lIjoiTGFuZ2UgRnJhbnMgJiBCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0d4Q2p4TTRZVWFiSmd5YkpxMDZYVCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0In0sImhyZWYiOiJodHRwczovL2FwaQ==", + "LnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTIwNzcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRTTcyODE5ODg1MTgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzY4MWhTWnZHVlVXUjlLNUNVeExxTUQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82ODFoU1p2R1ZVV1I5SzVDVXhMcU1EIiwiaWQiOiI2ODFoU1p2R1ZVV1I5SzVDVXhMcU1EIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBMYW5kIHZhbiBWcmllbmRzY2hhcCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2ODFoU1p2R1ZVV1I5SzVDVXhMcU1EIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Het+Land+Van...%22+artist%3A%22Lange+Frans%2C+Baas+B%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJhLUJhLUJhJTIyJTIwYXJ0aXN0JTNBJTIyTmllbHNvbiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJhLUJhLUJhJTIyJTIwYXJ0aXN0JTNBJTIyTmllbHNvbiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Ba-Ba-Ba%22+artist%3A%22Nielson%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Vlieg%20Met%20Me%20Mee%20Guus%20Meeuwis&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Vlieg%20Met%20Me%20Mee%20Guus%20Meeuwis&type=track","offset":0,"previous":null,"total":20,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5N0fvYueADU53qanvPfmV7"},"href":"https://api.spotify.com/v1/artists/5N0fvYueADU53qanvPfmV7","id":"5N0fvYueADU53qanvPfmV7","name":"Rutger van Barneveld","type":"artist","uri":"spotify:artist:5N0fvYueADU53qanvPfmV7"}],"external_urls":{"spotify":"https://open.spotify.com/album/1tosO6LN7sy2lKJ0Hx4dmT"},"href":"https://api.spotify.com/v1/albums/1tosO6LN7sy2lKJ0Hx4dmT","id":"1tosO6LN7sy2lKJ0Hx4dmT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f3d6500bd1308c865515edc5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f3d6500bd1308c865515edc5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f3d6500bd1308c865515edc5"}],"is_playable":true,"name":"Zwoele Zomernachten","release_date":"2026-05-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1tosO6LN7sy2lKJ0Hx4dmT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5N0fvYueADU53qanvPfmV7"},"href":"https://api.spotify.com/v1/artists/5N0fvYueADU53qanvPfmV7","id":"5N0fvYueADU53qanvPfmV7","name":"Rutger van Barneveld","type":"artist","uri":"spotify:artist:5N0fvYueADU53qanvPfmV7"}],"disc_number":1,"duration_ms":195454,"explicit":false,"external_ids":{"isrc":"NLAAE2600001"},"external_urls":{"spotify":"https://open.spotify.com/track/6gtGFybqydN4OMfy8M6M4b"},"href":"https://api.spotify.com/v1/tracks/6gtGFybqydN4OMfy8M6M4b","id":"6gtGFybqydN4OMfy8M6M4b","is_local":false,"is_playable":true,"name":"Zwoele Zomernachten","track_number":1,"type":"track","uri":"spotify:track:6gtGFybqydN4OMfy8M6M4b"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5N0fvYueADU53qanvPfmV7"},"href":"https://api.spotify.com/v1/artists/5N0fvYueADU53qanvPfmV7","id":"5N0fvYueADU53qanvPfmV7","name":"Rutger van Barneveld","type":"artist","uri":"spotify:artist:5N0fvYueADU53qanvPfmV7"}],"external_urls":{"spotify":"https://open.spotify.com/album/7E835zbKECtCXNKrKhLRVo"},"href":"https://api.spotify.com/v1/albums/7E835zbKECtCXNKrKhLRVo","id":"7E835zbKECtCXNKrKhLRVo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733efeddc55568b29b14f39885"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023efeddc55568b29b14f39885"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513efeddc55568b29b14f39885"}],"is_playable":true,"name":"Zwoele Zomernachten","release_date":"2026-05-21","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7E835zbKECtCXNKrKhLRVo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5N0fvYueADU53qanvPfmV7"},"href":"https://api.spotify.com/v1/artists/5N0fvYueADU53qanvPfmV7","id":"5N0fvYueADU53qanvPfmV7","name":"Rutger van Barneveld","type":"artist","uri":"spotify:artist:5N0fvYueADU53qanvPfmV7"}],"disc_number":1,"duration_ms":195454,"explicit":false,"external_ids":{"isrc":"QT6FH2688866"},"external_urls":{"spotify":"https://open.spotify.com/track/6JVKEpB8VQmt1LYRxNmdK0"},"href":"https://api.spotify.com/v1/tracks/6JVKEpB8VQmt1LYRxNmdK0","id":"6JVKEpB8VQmt1LYRxNmdK0","is_local":false,"is_playable":true,"name":"Zwoele Zomernachten","track_number":1,"type":"track","uri":"spotify:track:6JVKEpB8VQmt1LYRxNmdK0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1u7uShzlA1tXJeox3jMFPq"},"href":"https://api.spotify.com/v1/artists/1u7uShzlA1tXJeox3jMFPq","id":"1u7uShzlA1tXJeox3jMFPq","name":"De Jeugd Van Tegenwoordig","type":"artist","uri":"spotify:artist:1u7uShzlA1tXJeox3jMFPq"}],"external_urls":{"spotify":"https://open.spotify.com/album/29Fo0IBU1ZuyZD5ozPkjAs"},"href":"https://api.spotify.com/v1/albums/29Fo0IBU1ZuyZD5ozPkjAs","id":"29Fo0IBU1ZuyZD5ozPkjAs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f55d4578fe7043336238574"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f55d4578fe7043336238574"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f55d4578fe7043336238574"}],"is_playable":true,"name":"Parels Voor De Zwijnen","release_date":"2005-09-30","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:29Fo0IBU1ZuyZD5ozPkjAs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1u7uShzlA1tXJeox3jMFPq"},"href":"https://api.spotify.com/v1/artists/1u7uShzlA1tXJeox3jMFPq","id":"1u7uShzlA1tXJeox3jMFPq","name":"De Jeugd Van Tegenwoordig","type":"artist","uri":"spotify:artist:1u7uShzlA1tXJeox3jMFPq"}],"disc_number":1,"duration_ms":357866,"explicit":true,"external_ids":{"isrc":"NLG660500048"},"external_urls":{"spotify":"https://open.spotify.com/track/7hv0wyEgvGTTMe9ycOVwPV"},"href":"https://api.spotify.com/v1/tracks/7hv0wyEgvGTTMe9ycOVwPV","id":"7hv0wyEgvGTTMe9ycOVwPV","is_local":false,"is_playable":true,"name":"De Stofzuiger","track_number":9,"type":"track","uri":"spotify:track:7hv0wyEgvGTTMe9ycOVwPV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"external_urls":{"spotify":"https://open.spotify.com/album/260VIHFdGNsHL3DKUZYYkc"},"href":"https://api.spotify.com/v1/albums/260VIHFdGNsHL3DKUZYYkc","id":"260VIHFdGNsHL3DKUZYYkc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335d98894d7f97dc12c1df28a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235d98894d7f97dc12c1df28a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135d98894d7f97dc12c1df28a"}],"is_playable":true,"name":"Albino","release_date":"2019-01-18","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:260VIHFdGNsHL3DKUZYYkc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23mbvDIZJjSK4y4KhwlnHi"},"href":"https://api.spotify.com/v1/artists/23mbvDIZJjSK4y4KhwlnHi","id":"23mbvDIZJjSK4y4KhwlnHi","name":"Mick Spek","type":"artist","uri":"spotify:artist:23mbvDIZJjSK4y4KhwlnHi"}],"disc_number":1,"duration_ms":174312,"explicit":false,"external_ids":{"isrc":"NL1MC1900009"},"external_urls":{"spotify":"https://open.spotify.com/track/7nLwUujLMjEw6khA97N6I2"},"href":"https://api.spotify.com/v1/tracks/7nLwUujLMjEw6khA97N6I2","id":"7nLwUujLMjEw6khA97N6I2","is_local":false,"is_playable":true,"name":"Guus Meeuwis","track_number":12,"type":"track","uri":"spotify:track:7nLwUujLMjEw6khA97N6I2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"external_urls":{"spotify":"https://open.spotify.com/album/1rqWKBAcc4xCZxYKqVsMBA"},"href":"https://api.spotify.com/v1/albums/1rqWKBAcc4xCZxYKqVsMBA","id":"1rqWKBAcc4xCZxYKqVsMBA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e97bcf717cb2e202ce357fc5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e97bcf717cb2e202ce357fc5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e97bcf717cb2e202ce357fc5"}],"is_playable":true,"name":"Gevoel Van Samen Zijn","release_date":"2017-06-16","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:1rqWKBAcc4xCZxYKqVsMBA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"disc_number":1,"duration_ms":210896,"explicit":false,"external_ids":{"isrc":"NLN8T1700017"},"external_urls":{"spotify":"https://open.spotify.com/track/0dbcDMk3DAyHXfrC3t50l8"},"href":"https://api.spotify.com/v1/tracks/0dbcDMk3DAyHXfrC3t50l8","id":"0dbcDMk3DAyHXfrC3t50l8","is_local":false,"is_playable":true,"name":"Naar De Zevende Hemel","track_number":5,"type":"track","uri":"spotify:track:0dbcDMk3DAyHXfrC3t50l8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ebpOg0Pbtycq3ssZ4Y77z"},"href":"https://api.spotify.com/v1/artists/2ebpOg0Pbtycq3ssZ4Y77z","id":"2ebpOg0Pbtycq3ssZ4Y77z","name":"Kruk","type":"artist","uri":"spotify:artist:2ebpOg0Pbtycq3ssZ4Y77z"}],"external_urls":{"spotify":"https://open.spotify.com/album/4FqT9aEhCq75AvYgrO97RL"},"href":"https://api.spotify.com/v1/albums/4FqT9aEhCq75AvYgrO97RL","id":"4FqT9aEhCq75AvYgrO97RL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cb89725fc1e398f823d9559a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cb89725fc1e398f823d9559a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cb89725fc1e398f823d9559a"}],"is_playable":true,"name":"Nacht Gedachte","release_date":"2024-09-16","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:4FqT9aEhCq75AvYgrO97RL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ebpOg0Pbtycq3ssZ4Y77z"},"href":"https://api.spotify.com/v1/artists/2ebpOg0Pbtycq3ssZ4Y77z","id":"2ebpOg0Pbtycq3ssZ4Y77z","name":"Kruk","type":"artist","uri":"spotify:artist:2ebpOg0Pbtycq3ssZ4Y77z"}],"disc_number":1,"duration_ms":232734,"explicit":true,"external_ids":{"isrc":"QZTBE2428470"},"external_urls":{"spotify":"https://open.spotify.com/track/2AbqnQve3NRGIUUbNDHHk5"},"href":"https://api.spotify.com/v1/tracks/2AbqnQve3NRGIUUbNDHHk5","id":"2AbqnQve3NRGIUUbNDHHk5","is_local":false,"is_playable":true,"name":"Kruk","track_number":11,"type":"track","uri":"spotify:track:2AbqnQve3NRGIUUbNDHHk5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7BqE4BXcOntGJ2oyvSGGWB"},"href":"https://api.spotify.com/v1/artists/7BqE4BXcOntGJ2oyvSGGWB","id":"7BqE4BXcOntGJ2oyvSGGWB","name":"Djumbo","type":"artist","uri":"spotify:artist:7BqE4BXcOntGJ2oyvSGGWB"}],"external_urls":{"spotify":"https://open.spotify.com/album/4P0iDOPx5PmjG14MJEiduZ"},"href":"https://api.spotify.com/v1/albums/4P0iDOPx5PmjG14MJEiduZ","id":"4P0iDOPx5PmjG14MJEiduZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732e73724a2956f474e8312e0f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022e73724a2956f474e8312e0f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512e73724a2956f474e8312e0f"}],"is_playable":true,"name":"Jump","release_date":"2010","release_date_precision":"year","total_tracks":14,"type":"album","uri":"spotify:album:4P0iDOPx5PmjG14MJEiduZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7BqE4BXcOntGJ2oyvSGGWB"},"href":"https://api.spotify.com/v1/artists/7BqE4BXcOntGJ2oyvSGGWB","id":"7BqE4BXcOntGJ2oyvSGGWB","name":"Djumbo","type":"artist","uri":"spotify:artist:7BqE4BXcOntGJ2oyvSGGWB"}],"disc_number":1,"duration_ms":189466,"explicit":false,"external_ids":{"isrc":"NLKY50900046"},"external_urls":{"spotify":"https://open.spotify.com/track/0dnypasvt5F9lZOd56wo2t"},"href":"https://api.spotify.com/v1/tracks/0dnypasvt5F9lZOd56wo2t","id":"0dnypasvt5F9lZOd56wo2t","is_local":false,"is_playable":true,"name":"Bye Bye Bye","track_number":6,"type":"track","uri":"spotify:track:0dnypasvt5F9lZOd56wo2t"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"external_urls":{"spotify":"https://open.spotify.com/album/1T0v6QW9JPefRP9w4Eepvk"},"href":"https://api.spotify.com/v1/albums/1T0v6QW9JPefRP9w4Eepvk","id":"1T0v6QW9JPefRP9w4Eepvk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731eff57df322ccbe21697c96c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021eff57df322ccbe21697c96c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511eff57df322ccbe21697c96c"}],"is_playable":true,"name":"Live In Gelredome: 15 Jaar Fans & Friends (Jubileumconcert 2017)","release_date":"2018-03-16","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:1T0v6QW9JPefRP9w4Eepvk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"disc_number":1,"duration_ms":210426,"explicit":false,"external_ids":{"isrc":"NLN8T1700043"},"external_urls":{"spotify":"https://open.spotify.com/track/4SyItK8WXdKuwiS5uzsk6H"},"href":"https://api.spotify.com/v1/tracks/4SyItK8WXdKuwiS5uzsk6H","id":"4SyItK8WXdKuwiS5uzsk6H","is_local":false,"is_playable":true,"name":"Naar De Zevende Hemel - Live In Gelredome","track_number":13,"type":"track","uri":"spotify:track:4SyItK8WXdKuwiS5uzsk6H"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4VwgQydZI8WymoBhW2n83K"},"href":"https://api.spotify.com/v1/artists/4VwgQydZI8WymoBhW2n83K","id":"4VwgQydZI8WymoBhW2n83K","name":"Ali\u00e7o","type":"artist","uri":"spotify:artist:4VwgQydZI8WymoBhW2n83K"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ybg8oj4uCzYXdIrXe7NMs"},"href":"https://api.spotify.com/v1/albums/3ybg8oj4uCzYXdIrXe7NMs","id":"3ybg8oj4uCzYXdIrXe7NMs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27334012d03352d8ef9ab4ec42a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0234012d03352d8ef9ab4ec42a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485134012d03352d8ef9ab4ec42a"}],"is_playable":true,"name":"Waarom","release_date":"2025-05-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3ybg8oj4uCzYXdIrXe7NMs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4VwgQydZI8WymoBhW2n83K"},"href":"https://api.spotify.com/v1/artists/4VwgQydZI8WymoBhW2n83K","id":"4VwgQydZI8WymoBhW2n83K","name":"Ali\u00e7o","type":"artist","uri":"spotify:artist:4VwgQydZI8WymoBhW2n83K"}],"disc_number":1,"duration_ms":138591,"explicit":true,"external_ids":{"isrc":"QZRP42537932"},"external_urls":{"spotify":"https://open.spotify.com/track/6QqSNZTN4V9RslfjOR5Gio"},"href":"https://api.spotify.com/v1/tracks/6QqSNZTN4V9RslfjOR5Gio","id":"6QqSNZTN4V9RslfjOR5Gio","is_local":false,"is_playable":true,"name":"Waarom","track_number":1,"type":"track","uri":"spotify:track:6QqSNZTN4V9RslfjOR5Gio"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"external_urls":{"spotify":"https://open.spotify.com/album/7bHxQ9f0jeO7XctP1COw2u"},"href":"https://api.spotify.com/v1/albums/7bHxQ9f0jeO7XctP1COw2u","id":"7bHxQ9f0jeO7XctP1COw2u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b2881490f54fa9675062e2a2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b2881490f54fa9675062e2a2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b2881490f54fa9675062e2a2"}],"is_playable":true,"name":"Naar De Zevende Hemel","release_date":"2017-09-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7bHxQ9f0jeO7XctP1COw2u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"disc_number":1,"duration_ms":210896,"explicit":false,"external_ids":{"isrc":"NLN8T1700017"},"external_urls":{"spotify":"https://open.spotify.com/track/3TaWm3bBvLhZU3BajYTDM4"},"href":"https://api.spotify.com/v1/tracks/3TaWm3bBvLhZU3BajYTDM4","id":"3TaWm3bBvLhZU3BajYTDM4","is_local":false,"is_playable":true,"name":"Naar De Zevende Hemel","track_number":1,"type":"track","uri":"spotify:track:3TaWm3bBvLhZU3BajYTDM4"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Vlieg%20Met%20Me%20Mee%20Guus%20Meeuwis&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Vlieg%20Met%20Me%20Mee%20Guus%20Meeuwis&type=track","offset":0,"previous":null,"total":20,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5N0fvYueADU53qanvPfmV7"},"href":"https://api.spotify.com/v1/artists/5N0fvYueADU53qanvPfmV7","id":"5N0fvYueADU53qanvPfmV7","name":"Rutger van Barneveld","type":"artist","uri":"spotify:artist:5N0fvYueADU53qanvPfmV7"}],"external_urls":{"spotify":"https://open.spotify.com/album/1tosO6LN7sy2lKJ0Hx4dmT"},"href":"https://api.spotify.com/v1/albums/1tosO6LN7sy2lKJ0Hx4dmT","id":"1tosO6LN7sy2lKJ0Hx4dmT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f3d6500bd1308c865515edc5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f3d6500bd1308c865515edc5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f3d6500bd1308c865515edc5"}],"is_playable":true,"name":"Zwoele Zomernachten","release_date":"2026-05-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1tosO6LN7sy2lKJ0Hx4dmT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5N0fvYueADU53qanvPfmV7"},"href":"https://api.spotify.com/v1/artists/5N0fvYueADU53qanvPfmV7","id":"5N0fvYueADU53qanvPfmV7","name":"Rutger van Barneveld","type":"artist","uri":"spotify:artist:5N0fvYueADU53qanvPfmV7"}],"disc_number":1,"duration_ms":195454,"explicit":false,"external_ids":{"isrc":"NLAAE2600001"},"external_urls":{"spotify":"https://open.spotify.com/track/6gtGFybqydN4OMfy8M6M4b"},"href":"https://api.spotify.com/v1/tracks/6gtGFybqydN4OMfy8M6M4b","id":"6gtGFybqydN4OMfy8M6M4b","is_local":false,"is_playable":true,"name":"Zwoele Zomernachten","track_number":1,"type":"track","uri":"spotify:track:6gtGFybqydN4OMfy8M6M4b"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5N0fvYueADU53qanvPfmV7"},"href":"https://api.spotify.com/v1/artists/5N0fvYueADU53qanvPfmV7","id":"5N0fvYueADU53qanvPfmV7","name":"Rutger van Barneveld","type":"artist","uri":"spotify:artist:5N0fvYueADU53qanvPfmV7"}],"external_urls":{"spotify":"https://open.spotify.com/album/7E835zbKECtCXNKrKhLRVo"},"href":"https://api.spotify.com/v1/albums/7E835zbKECtCXNKrKhLRVo","id":"7E835zbKECtCXNKrKhLRVo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733efeddc55568b29b14f39885"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023efeddc55568b29b14f39885"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513efeddc55568b29b14f39885"}],"is_playable":true,"name":"Zwoele Zomernachten","release_date":"2026-05-21","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7E835zbKECtCXNKrKhLRVo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5N0fvYueADU53qanvPfmV7"},"href":"https://api.spotify.com/v1/artists/5N0fvYueADU53qanvPfmV7","id":"5N0fvYueADU53qanvPfmV7","name":"Rutger van Barneveld","type":"artist","uri":"spotify:artist:5N0fvYueADU53qanvPfmV7"}],"disc_number":1,"duration_ms":195454,"explicit":false,"external_ids":{"isrc":"QT6FH2688866"},"external_urls":{"spotify":"https://open.spotify.com/track/6JVKEpB8VQmt1LYRxNmdK0"},"href":"https://api.spotify.com/v1/tracks/6JVKEpB8VQmt1LYRxNmdK0","id":"6JVKEpB8VQmt1LYRxNmdK0","is_local":false,"is_playable":true,"name":"Zwoele Zomernachten","track_number":1,"type":"track","uri":"spotify:track:6JVKEpB8VQmt1LYRxNmdK0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1u7uShzlA1tXJeox3jMFPq"},"href":"https://api.spotify.com/v1/artists/1u7uShzlA1tXJeox3jMFPq","id":"1u7uShzlA1tXJeox3jMFPq","name":"De Jeugd Van Tegenwoordig","type":"artist","uri":"spotify:artist:1u7uShzlA1tXJeox3jMFPq"}],"external_urls":{"spotify":"https://open.spotify.com/album/29Fo0IBU1ZuyZD5ozPkjAs"},"href":"https://api.spotify.com/v1/albums/29Fo0IBU1ZuyZD5ozPkjAs","id":"29Fo0IBU1ZuyZD5ozPkjAs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f55d4578fe7043336238574"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f55d4578fe7043336238574"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f55d4578fe7043336238574"}],"is_playable":true,"name":"Parels Voor De Zwijnen","release_date":"2005-09-30","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:29Fo0IBU1ZuyZD5ozPkjAs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1u7uShzlA1tXJeox3jMFPq"},"href":"https://api.spotify.com/v1/artists/1u7uShzlA1tXJeox3jMFPq","id":"1u7uShzlA1tXJeox3jMFPq","name":"De Jeugd Van Tegenwoordig","type":"artist","uri":"spotify:artist:1u7uShzlA1tXJeox3jMFPq"}],"disc_number":1,"duration_ms":357866,"explicit":true,"external_ids":{"isrc":"NLG660500048"},"external_urls":{"spotify":"https://open.spotify.com/track/7hv0wyEgvGTTMe9ycOVwPV"},"href":"https://api.spotify.com/v1/tracks/7hv0wyEgvGTTMe9ycOVwPV","id":"7hv0wyEgvGTTMe9ycOVwPV","is_local":false,"is_playable":true,"name":"De Stofzuiger","track_number":9,"type":"track","uri":"spotify:track:7hv0wyEgvGTTMe9ycOVwPV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"}],"external_urls":{"spotify":"https://open.spotify.com/album/260VIHFdGNsHL3DKUZYYkc"},"href":"https://api.spotify.com/v1/albums/260VIHFdGNsHL3DKUZYYkc","id":"260VIHFdGNsHL3DKUZYYkc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335d98894d7f97dc12c1df28a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235d98894d7f97dc12c1df28a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135d98894d7f97dc12c1df28a"}],"is_playable":true,"name":"Albino","release_date":"2019-01-18","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:260VIHFdGNsHL3DKUZYYkc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6s5ubAp65wXoTZefE01RNR"},"href":"https://api.spotify.com/v1/artists/6s5ubAp65wXoTZefE01RNR","id":"6s5ubAp65wXoTZefE01RNR","name":"Joost","type":"artist","uri":"spotify:artist:6s5ubAp65wXoTZefE01RNR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/23mbvDIZJjSK4y4KhwlnHi"},"href":"https://api.spotify.com/v1/artists/23mbvDIZJjSK4y4KhwlnHi","id":"23mbvDIZJjSK4y4KhwlnHi","name":"Mick Spek","type":"artist","uri":"spotify:artist:23mbvDIZJjSK4y4KhwlnHi"}],"disc_number":1,"duration_ms":174312,"explicit":false,"external_ids":{"isrc":"NL1MC1900009"},"external_urls":{"spotify":"https://open.spotify.com/track/7nLwUujLMjEw6khA97N6I2"},"href":"https://api.spotify.com/v1/tracks/7nLwUujLMjEw6khA97N6I2","id":"7nLwUujLMjEw6khA97N6I2","is_local":false,"is_playable":true,"name":"Guus Meeuwis","track_number":12,"type":"track","uri":"spotify:track:7nLwUujLMjEw6khA97N6I2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"external_urls":{"spotify":"https://open.spotify.com/album/1rqWKBAcc4xCZxYKqVsMBA"},"href":"https://api.spotify.com/v1/albums/1rqWKBAcc4xCZxYKqVsMBA","id":"1rqWKBAcc4xCZxYKqVsMBA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e97bcf717cb2e202ce357fc5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e97bcf717cb2e202ce357fc5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e97bcf717cb2e202ce357fc5"}],"is_playable":true,"name":"Gevoel Van Samen Zijn","release_date":"2017-06-16","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:1rqWKBAcc4xCZxYKqVsMBA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"disc_number":1,"duration_ms":210896,"explicit":false,"external_ids":{"isrc":"NLN8T1700017"},"external_urls":{"spotify":"https://open.spotify.com/track/0dbcDMk3DAyHXfrC3t50l8"},"href":"https://api.spotify.com/v1/tracks/0dbcDMk3DAyHXfrC3t50l8","id":"0dbcDMk3DAyHXfrC3t50l8","is_local":false,"is_playable":true,"name":"Naar De Zevende Hemel","track_number":5,"type":"track","uri":"spotify:track:0dbcDMk3DAyHXfrC3t50l8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ebpOg0Pbtycq3ssZ4Y77z"},"href":"https://api.spotify.com/v1/artists/2ebpOg0Pbtycq3ssZ4Y77z","id":"2ebpOg0Pbtycq3ssZ4Y77z","name":"Kruk","type":"artist","uri":"spotify:artist:2ebpOg0Pbtycq3ssZ4Y77z"}],"external_urls":{"spotify":"https://open.spotify.com/album/4FqT9aEhCq75AvYgrO97RL"},"href":"https://api.spotify.com/v1/albums/4FqT9aEhCq75AvYgrO97RL","id":"4FqT9aEhCq75AvYgrO97RL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cb89725fc1e398f823d9559a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cb89725fc1e398f823d9559a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cb89725fc1e398f823d9559a"}],"is_playable":true,"name":"Nacht Gedachte","release_date":"2024-09-16","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:4FqT9aEhCq75AvYgrO97RL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ebpOg0Pbtycq3ssZ4Y77z"},"href":"https://api.spotify.com/v1/artists/2ebpOg0Pbtycq3ssZ4Y77z","id":"2ebpOg0Pbtycq3ssZ4Y77z","name":"Kruk","type":"artist","uri":"spotify:artist:2ebpOg0Pbtycq3ssZ4Y77z"}],"disc_number":1,"duration_ms":232734,"explicit":true,"external_ids":{"isrc":"QZTBE2428470"},"external_urls":{"spotify":"https://open.spotify.com/track/2AbqnQve3NRGIUUbNDHHk5"},"href":"https://api.spotify.com/v1/tracks/2AbqnQve3NRGIUUbNDHHk5","id":"2AbqnQve3NRGIUUbNDHHk5","is_local":false,"is_playable":true,"name":"Kruk","track_number":11,"type":"track","uri":"spotify:track:2AbqnQve3NRGIUUbNDHHk5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7BqE4BXcOntGJ2oyvSGGWB"},"href":"https://api.spotify.com/v1/artists/7BqE4BXcOntGJ2oyvSGGWB","id":"7BqE4BXcOntGJ2oyvSGGWB","name":"Djumbo","type":"artist","uri":"spotify:artist:7BqE4BXcOntGJ2oyvSGGWB"}],"external_urls":{"spotify":"https://open.spotify.com/album/4P0iDOPx5PmjG14MJEiduZ"},"href":"https://api.spotify.com/v1/albums/4P0iDOPx5PmjG14MJEiduZ","id":"4P0iDOPx5PmjG14MJEiduZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732e73724a2956f474e8312e0f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022e73724a2956f474e8312e0f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512e73724a2956f474e8312e0f"}],"is_playable":true,"name":"Jump","release_date":"2010","release_date_precision":"year","total_tracks":14,"type":"album","uri":"spotify:album:4P0iDOPx5PmjG14MJEiduZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7BqE4BXcOntGJ2oyvSGGWB"},"href":"https://api.spotify.com/v1/artists/7BqE4BXcOntGJ2oyvSGGWB","id":"7BqE4BXcOntGJ2oyvSGGWB","name":"Djumbo","type":"artist","uri":"spotify:artist:7BqE4BXcOntGJ2oyvSGGWB"}],"disc_number":1,"duration_ms":189466,"explicit":false,"external_ids":{"isrc":"NLKY50900046"},"external_urls":{"spotify":"https://open.spotify.com/track/0dnypasvt5F9lZOd56wo2t"},"href":"https://api.spotify.com/v1/tracks/0dnypasvt5F9lZOd56wo2t","id":"0dnypasvt5F9lZOd56wo2t","is_local":false,"is_playable":true,"name":"Bye Bye Bye","track_number":6,"type":"track","uri":"spotify:track:0dnypasvt5F9lZOd56wo2t"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"external_urls":{"spotify":"https://open.spotify.com/album/1T0v6QW9JPefRP9w4Eepvk"},"href":"https://api.spotify.com/v1/albums/1T0v6QW9JPefRP9w4Eepvk","id":"1T0v6QW9JPefRP9w4Eepvk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731eff57df322ccbe21697c96c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021eff57df322ccbe21697c96c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511eff57df322ccbe21697c96c"}],"is_playable":true,"name":"Live In Gelredome: 15 Jaar Fans & Friends (Jubileumconcert 2017)","release_date":"2018-03-16","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:1T0v6QW9JPefRP9w4Eepvk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"disc_number":1,"duration_ms":210426,"explicit":false,"external_ids":{"isrc":"NLN8T1700043"},"external_urls":{"spotify":"https://open.spotify.com/track/4SyItK8WXdKuwiS5uzsk6H"},"href":"https://api.spotify.com/v1/tracks/4SyItK8WXdKuwiS5uzsk6H","id":"4SyItK8WXdKuwiS5uzsk6H","is_local":false,"is_playable":true,"name":"Naar De Zevende Hemel - Live In Gelredome","track_number":13,"type":"track","uri":"spotify:track:4SyItK8WXdKuwiS5uzsk6H"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4VwgQydZI8WymoBhW2n83K"},"href":"https://api.spotify.com/v1/artists/4VwgQydZI8WymoBhW2n83K","id":"4VwgQydZI8WymoBhW2n83K","name":"Ali\u00e7o","type":"artist","uri":"spotify:artist:4VwgQydZI8WymoBhW2n83K"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ybg8oj4uCzYXdIrXe7NMs"},"href":"https://api.spotify.com/v1/albums/3ybg8oj4uCzYXdIrXe7NMs","id":"3ybg8oj4uCzYXdIrXe7NMs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27334012d03352d8ef9ab4ec42a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0234012d03352d8ef9ab4ec42a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485134012d03352d8ef9ab4ec42a"}],"is_playable":true,"name":"Waarom","release_date":"2025-05-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3ybg8oj4uCzYXdIrXe7NMs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4VwgQydZI8WymoBhW2n83K"},"href":"https://api.spotify.com/v1/artists/4VwgQydZI8WymoBhW2n83K","id":"4VwgQydZI8WymoBhW2n83K","name":"Ali\u00e7o","type":"artist","uri":"spotify:artist:4VwgQydZI8WymoBhW2n83K"}],"disc_number":1,"duration_ms":138591,"explicit":true,"external_ids":{"isrc":"QZRP42537932"},"external_urls":{"spotify":"https://open.spotify.com/track/6QqSNZTN4V9RslfjOR5Gio"},"href":"https://api.spotify.com/v1/tracks/6QqSNZTN4V9RslfjOR5Gio","id":"6QqSNZTN4V9RslfjOR5Gio","is_local":false,"is_playable":true,"name":"Waarom","track_number":1,"type":"track","uri":"spotify:track:6QqSNZTN4V9RslfjOR5Gio"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"external_urls":{"spotify":"https://open.spotify.com/album/7bHxQ9f0jeO7XctP1COw2u"},"href":"https://api.spotify.com/v1/albums/7bHxQ9f0jeO7XctP1COw2u","id":"7bHxQ9f0jeO7XctP1COw2u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b2881490f54fa9675062e2a2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b2881490f54fa9675062e2a2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b2881490f54fa9675062e2a2"}],"is_playable":true,"name":"Naar De Zevende Hemel","release_date":"2017-09-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7bHxQ9f0jeO7XctP1COw2u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02ydjJPvRKpejxRzZyHdaq"},"href":"https://api.spotify.com/v1/artists/02ydjJPvRKpejxRzZyHdaq","id":"02ydjJPvRKpejxRzZyHdaq","name":"Jannes","type":"artist","uri":"spotify:artist:02ydjJPvRKpejxRzZyHdaq"}],"disc_number":1,"duration_ms":210896,"explicit":false,"external_ids":{"isrc":"NLN8T1700017"},"external_urls":{"spotify":"https://open.spotify.com/track/3TaWm3bBvLhZU3BajYTDM4"},"href":"https://api.spotify.com/v1/tracks/3TaWm3bBvLhZU3BajYTDM4","id":"3TaWm3bBvLhZU3BajYTDM4","is_local":false,"is_playable":true,"name":"Naar De Zevende Hemel","track_number":1,"type":"track","uri":"spotify:track:3TaWm3bBvLhZU3BajYTDM4"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Vlieg+Met+Me+Mee+Guus+Meeuwis&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldvbmRlcmxhbmQlMjIlMjBhcnRpc3QlM0ElMjJDaGVmJTI3U3BlY2lhbCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldvbmRlcmxhbmQlMjIlMjBhcnRpc3QlM0ElMjJDaGVmJTI3U3BlY2lhbCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Wonderland%22+artist%3A%22Chef%27Special%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Ba-Ba-Ba%20Nielson&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Ba-Ba-Ba%20Nielson&type=track","offset":0,"previous":null,"total":22,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/00x1fYSGhdqScXBRpSj3DW"},"href":"https://api.spotify.com/v1/artists/00x1fYSGhdqScXBRpSj3DW","id":"00x1fYSGhdqScXBRpSj3DW","name":"Olivia Dean","type":"artist","uri":"spotify:artist:00x1fYSGhdqScXBRpSj3DW"}],"external_urls":{"spotify":"https://open.spotify.com/album/74sFrKGdI7ZBBVKrT9jtdV"},"href":"https://api.spotify.com/v1/albums/74sFrKGdI7ZBBVKrT9jtdV","id":"74sFrKGdI7ZBBVKrT9jtdV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a9e75099d7065c71cc7ede72"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a9e75099d7065c71cc7ede72"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a9e75099d7065c71cc7ede72"}],"is_playable":true,"name":"Nice To Each Other","release_date":"2025-05-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:74sFrKGdI7ZBBVKrT9jtdV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/00x1fYSGhdqScXBRpSj3DW"},"href":"https://api.spotify.com/v1/artists/00x1fYSGhdqScXBRpSj3DW","id":"00x1fYSGhdqScXBRpSj3DW","name":"Olivia Dean","type":"artist","uri":"spotify:artist:00x1fYSGhdqScXBRpSj3DW"}],"disc_number":1,"duration_ms":209000,"explicit":false,"external_ids":{"isrc":"GBUM72502230"},"external_urls":{"spotify":"https://open.spotify.com/track/7gKxCvTDWwV9wBhdeBbr3l"},"href":"https://api.spotify.com/v1/tracks/7gKxCvTDWwV9wBhdeBbr3l","id":"7gKxCvTDWwV9wBhdeBbr3l","is_local":false,"is_playable":true,"name":"Nice To Each Other","track_number":1,"type":"track","uri":"spotify:track:7gKxCvTDWwV9wBhdeBbr3l"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/00x1fYSGhdqScXBRpSj3DW"},"href":"https://api.spotify.com/v1/artists/00x1fYSGhdqScXBRpSj3DW","id":"00x1fYSGhdqScXBRpSj3DW","name":"Olivia Dean","type":"artist","uri":"spotify:artist:00x1fYSGhdqScXBRpSj3DW"}],"external_urls":{"spotify":"https://open.spotify.com/album/0l8zYqoUeBYg47Gmevq9HZ"},"href":"https://api.spotify.com/v1/albums/0l8zYqoUeBYg47Gmevq9HZ","id":"0l8zYqoUeBYg47Gmevq9HZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739a336bfb6d40bbd90a507417"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029a336bfb6d40bbd90a507417"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519a336bfb6d40bbd90a507417"}],"is_playable":true,"name":"The Art of Loving","release_date":"2025-09-26","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:0l8zYqoUeBYg47Gmevq9HZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/00x1fYSGhdqScXBRpSj3DW"},"href":"https://api.spotify.com/v1/artists/00x1fYSGhdqScXBRpSj3DW","id":"00x1fYSGhdqScXBRpSj3DW","name":"Olivia Dean","type":"artist","uri":"spotify:artist:00x1fYSGhdqScXBRpSj3DW"}],"disc_number":1,"duration_ms":197000,"explicit":false,"external_ids":{"isrc":"GBUM72503092"},"external_urls":{"spotify":"https://open.spotify.com/track/5SruEBX3KpgpDvEcIuN53P"},"href":"https://api.spotify.com/v1/tracks/5SruEBX3KpgpDvEcIuN53P","id":"5SruEBX3KpgpDvEcIuN53P","is_local":false,"is_playable":true,"name":"Baby Steps","track_number":10,"type":"track","uri":"spotify:track:5SruEBX3KpgpDvEcIuN53P"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6KImCVD70vtIoJWnq6nGn3"},"href":"https://api.spotify.com/v1/artists/6KImCVD70vtIoJWnq6nGn3","id":"6KImCVD70vtIoJWnq6nGn3","name":"Harry Styles","type":"artist","uri":"spotify:artist:6KImCVD70vtIoJWnq6nGn3"}],"external_urls":{"spotify":"https://open.spotify.com/album/5r36AJ6VOJtp00oxSkBZ5h"},"href":"https://api.spotify.com/v1/albums/5r36AJ6VOJtp00oxSkBZ5h","id":"5r36AJ6VOJtp00oxSkBZ5h","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27382ce362511fb3d9dda6578ee"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0282ce362511fb3d9dda6578ee"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485182ce362511fb3d9dda6578ee"}],"is_playable":true,"name":"Harry's House","release_date":"2022-05-20","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:5r36AJ6VOJtp00oxSkBZ5h"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6KImCVD70vtIoJWnq6nGn3"},"href":"https://api.spotify.com/v1/artists/6KImCVD70vtIoJWnq6nGn3","id":"6KImCVD70vtIoJWnq6nGn3","name":"Harry Styles","type":"artist","uri":"spotify:artist:6KImCVD70vtIoJWnq6nGn3"}],"disc_number":1,"duration_ms":193813,"explicit":false,"external_ids":{"isrc":"USSM12200609"},"external_urls":{"spotify":"https://open.spotify.com/track/5LYMamLv12UPbemOaTPyeV"},"href":"https://api.spotify.com/v1/tracks/5LYMamLv12UPbemOaTPyeV","id":"5LYMamLv12UPbemOaTPyeV","is_local":false,"is_playable":true,"name":"Music For a Sushi Restaurant","track_number":1,"type":"track","uri":"spotify:track:5LYMamLv12UPbemOaTPyeV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02kJSzxNuaWGqwubyUba0Z"},"href":"https://api.spotify.com/v1/artists/02kJSzxNuaWGqwubyUba0Z","id":"02kJSzxNuaWGqwubyUba0Z","name":"G-Eazy","type":"artist","uri":"spotify:artist:02kJSzxNuaWGqwubyUba0Z"}],"external_urls":{"spotify":"https://open.spotify.com/album/09Q3WwGYsQe5ognkvVkmCu"},"href":"https://api.spotify.com/v1/albums/09Q3WwGYsQe5ognkvVkmCu","id":"09Q3WwGYsQe5ognkvVkmCu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bf34660a2cc3f4d83966b1e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bf34660a2cc3f4d83966b1e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bf34660a2cc3f4d83966b1e7"}],"is_playable":true,"name":"When It's Dark Out","release_date":"2015-12-04","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:09Q3WwGYsQe5ognkvVkmCu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/02kJSzxNuaWGqwubyUba0Z"},"href":"https://api.spotify.com/v1/artists/02kJSzxNuaWGqwubyUba0Z","id":"02kJSzxNuaWGqwubyUba0Z","name":"G-Eazy","type":"artist","uri":"spotify:artist:02kJSzxNuaWGqwubyUba0Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/64M6ah0SkkRsnPGtGiRAbb"},"href":"https://api.spotify.com/v1/artists/64M6ah0SkkRsnPGtGiRAbb","id":"64M6ah0SkkRsnPGtGiRAbb","name":"Bebe Rexha","type":"artist","uri":"spotify:artist:64M6ah0SkkRsnPGtGiRAbb"}],"disc_number":1,"duration_ms":251465,"explicit":true,"external_ids":{"isrc":"USRC11502210"},"external_urls":{"spotify":"https://open.spotify.com/track/40YcuQysJ0KlGQTeGUosTC"},"href":"https://api.spotify.com/v1/tracks/40YcuQysJ0KlGQTeGUosTC","id":"40YcuQysJ0KlGQTeGUosTC","is_local":false,"is_playable":true,"name":"Me, Myself & I","track_number":3,"type":"track","uri":"spotify:track:40YcuQysJ0KlGQTeGUosTC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/00x1fYSGhdqScXBRpSj3DW"},"href":"https://api.spotify.com/v1/artists/00x1fYSGhdqScXBRpSj3DW","id":"00x1fYSGhdqScXBRpSj3DW","name":"Olivia Dean","type":"artist","uri":"spotify:artist:00x1fYSGhdqScXBRpSj3DW"}],"external_urls":{"spotify":"https://open.spotify.com/album/0l8zYqoUeBYg47Gmevq9HZ"},"href":"https://api.spotify.com/v1/albums/0l8zYqoUeBYg47Gmevq9HZ","id":"0l8zYqoUeBYg47Gmevq9HZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739a336bfb6d40bbd90a507417"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029a336bfb6d40bbd90a507417"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519a336bfb6d40bbd90a507417"}],"is_playable":true,"name":"The Art of Loving","release_date":"2025-09-26","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:0l8zYqoUeBYg47Gmevq9HZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/00x1fYSGhdqScXBRpSj3DW"},"href":"https://api.spotify.com/v1/artists/00x1fYSGhdqScXBRpSj3DW","id":"00x1fYSGhdqScXBRpSj3DW","name":"Olivia Dean","type":"artist","uri":"spotify:artist:00x1fYSGhdqScXBRpSj3DW"}],"disc_number":1,"duration_ms":209000,"explicit":false,"external_ids":{"isrc":"GBUM72502230"},"external_urls":{"spotify":"https://open.spotify.com/track/7qEiBWlztvDFrILdizFULx"},"href":"https://api.spotify.com/v1/tracks/7qEiBWlztvDFrILdizFULx","id":"7qEiBWlztvDFrILdizFULx","is_local":false,"is_playable":true,"name":"Nice To Each Other","track_number":2,"type":"track","uri":"spotify:track:7qEiBWlztvDFrILdizFULx"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4ktBrNjagCGftyuBLJkATq"},"href":"https://api.spotify.com/v1/artists/4ktBrNjagCGftyuBLJkATq","id":"4ktBrNjagCGftyuBLJkATq","name":"Wes Nelson","type":"artist","uri":"spotify:artist:4ktBrNjagCGftyuBLJkATq"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AbLpsnTQVNB3OEadYiVrK"},"href":"https://api.spotify.com/v1/artists/5AbLpsnTQVNB3OEadYiVrK","id":"5AbLpsnTQVNB3OEadYiVrK","name":"Yxng Bane","type":"artist","uri":"spotify:artist:5AbLpsnTQVNB3OEadYiVrK"}],"external_urls":{"spotify":"https://open.spotify.com/album/5lSwDdPjMSQk27KwUYlC2r"},"href":"https://api.spotify.com/v1/albums/5lSwDdPjMSQk27KwUYlC2r","id":"5lSwDdPjMSQk27KwUYlC2r","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735fc5b7906062fad8268f33c4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025fc5b7906062fad8268f33c4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515fc5b7906062fad8268f33c4"}],"is_playable":true,"name":"Nice To Meet Ya (feat. Yxng Bane)","release_date":"2021-04-01","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5lSwDdPjMSQk27KwUYlC2r"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4ktBrNjagCGftyuBLJkATq"},"href":"https://api.spotify.com/v1/artists/4ktBrNjagCGftyuBLJkATq","id":"4ktBrNjagCGftyuBLJkATq","name":"Wes Nelson","type":"artist","uri":"spotify:artist:4ktBrNjagCGftyuBLJkATq"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AbLpsnTQVNB3OEadYiVrK"},"href":"https://api.spotify.com/v1/artists/5AbLpsnTQVNB3OEadYiVrK","id":"5AbLpsnTQVNB3OEadYiVrK","name":"Yxng Bane","type":"artist","uri":"spotify:artist:5AbLpsnTQVNB3OEadYiVrK"}],"disc_number":1,"duration_ms":181918,"explicit":false,"external_ids":{"isrc":"GBUM72101848"},"external_urls":{"spotify":"https://open.spotify.com/track/1YHjRAptXqPdsdx3g6FNJL"},"href":"https://api.spotify.com/v1/tracks/1YHjRAptXqPdsdx3g6FNJL","id":"1YHjRAptXqPdsdx3g6FNJL","is_local":false,"is_playable":true,"name":"Nice To Meet Ya (feat. Yxng Bane)","track_number":1,"type":"track","uri":"spotify:track:1YHjRAptXqPdsdx3g6FNJL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3RTzAwFprBqiskp550eSJX"},"href":"https://api.spotify.com/v1/artists/3RTzAwFprBqiskp550eSJX","id":"3RTzAwFprBqiskp550eSJX","name":"Harry Nilsson","type":"artist","uri":"spotify:artist:3RTzAwFprBqiskp550eSJX"}],"external_urls":{"spotify":"https://open.spotify.com/album/0H3v4snD6xhworsjXndsai"},"href":"https://api.spotify.com/v1/albums/0H3v4snD6xhworsjXndsai","id":"0H3v4snD6xhworsjXndsai","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27388cc28f05b794489ef278abd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0288cc28f05b794489ef278abd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485188cc28f05b794489ef278abd"}],"is_playable":true,"name":"Aerial Ballet","release_date":"1968-07-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:0H3v4snD6xhworsjXndsai"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3RTzAwFprBqiskp550eSJX"},"href":"https://api.spotify.com/v1/artists/3RTzAwFprBqiskp550eSJX","id":"3RTzAwFprBqiskp550eSJX","name":"Harry Nilsson","type":"artist","uri":"spotify:artist:3RTzAwFprBqiskp550eSJX"}],"disc_number":1,"duration_ms":164089,"explicit":false,"external_ids":{"isrc":"USRC19901102"},"external_urls":{"spotify":"https://open.spotify.com/track/1jcPcDu2YawPfLhwjYnqK2"},"href":"https://api.spotify.com/v1/tracks/1jcPcDu2YawPfLhwjYnqK2","id":"1jcPcDu2YawPfLhwjYnqK2","is_local":false,"is_playable":true,"name":"Everybody's Talkin' - From \"Midnight Cowboy\"","track_number":7,"type":"track","uri":"spotify:track:1jcPcDu2YawPfLhwjYnqK2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5iXYJYmMcjlTFL1qA8UfgY"},"href":"https://api.spotify.com/v1/artists/5iXYJYmMcjlTFL1qA8UfgY","id":"5iXYJYmMcjlTFL1qA8UfgY","name":"Lukas Nelson and Promise of the Real","type":"artist","uri":"spotify:artist:5iXYJYmMcjlTFL1qA8UfgY"}],"external_urls":{"spotify":"https://open.spotify.com/album/6aI5mg4gKsjIoFLvqPONC4"},"href":"https://api.spotify.com/v1/albums/6aI5mg4gKsjIoFLvqPONC4","id":"6aI5mg4gKsjIoFLvqPONC4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c377ebd89faf1894c072cfee"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c377ebd89faf1894c072cfee"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c377ebd89faf1894c072cfee"}],"is_playable":true,"name":"Promise of the Real","release_date":"2010-12-21","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6aI5mg4gKsjIoFLvqPONC4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5iXYJYmMcjlTFL1qA8UfgY"},"href":"https://api.spotify.com/v1/artists/5iXYJYmMcjlTFL1qA8UfgY","id":"5iXYJYmMcjlTFL1qA8UfgY","name":"Lukas Nelson and Promise of the Real","type":"artist","uri":"spotify:artist:5iXYJYmMcjlTFL1qA8UfgY"}],"disc_number":1,"duration_ms":318826,"explicit":false,"external_ids":{"isrc":"TCAAT1053334"},"external_urls":{"spotify":"https://open.spotify.com/track/0JT0D83NTt3o2VbZSI3f5K"},"href":"https://api.spotify.com/v1/tracks/0JT0D83NTt3o2VbZSI3f5K","id":"0JT0D83NTt3o2VbZSI3f5K","is_local":false,"is_playable":true,"name":"Pali Gap / Hey Baby (New Rising Sun)","track_number":5,"type":"track","uri":"spotify:track:0JT0D83NTt3o2VbZSI3f5K"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sSFVlM6pkweLXE8qw1OS"},"href":"https://api.spotify.com/v1/artists/73sSFVlM6pkweLXE8qw1OS","id":"73sSFVlM6pkweLXE8qw1OS","name":"Ricky Nelson","type":"artist","uri":"spotify:artist:73sSFVlM6pkweLXE8qw1OS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4VPrTgtrZqcXCy5nGYKDAe"},"href":"https://api.spotify.com/v1/artists/4VPrTgtrZqcXCy5nGYKDAe","id":"4VPrTgtrZqcXCy5nGYKDAe","name":"The Stone Canyon Band","type":"artist","uri":"spotify:artist:4VPrTgtrZqcXCy5nGYKDAe"}],"external_urls":{"spotify":"https://open.spotify.com/album/76BrDrAEcQhjvXehCVMpWv"},"href":"https://api.spotify.com/v1/albums/76BrDrAEcQhjvXehCVMpWv","id":"76BrDrAEcQhjvXehCVMpWv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a03dddeb460e37ecc8abe718"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a03dddeb460e37ecc8abe718"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a03dddeb460e37ecc8abe718"}],"is_playable":true,"name":"Garden Party","release_date":"1972","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:76BrDrAEcQhjvXehCVMpWv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sSFVlM6pkweLXE8qw1OS"},"href":"https://api.spotify.com/v1/artists/73sSFVlM6pkweLXE8qw1OS","id":"73sSFVlM6pkweLXE8qw1OS","name":"Ricky Nelson","type":"artist","uri":"spotify:artist:73sSFVlM6pkweLXE8qw1OS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4VPrTgtrZqcXCy5nGYKDAe"},"href":"https://api.spotify.com/v1/artists/4VPrTgtrZqcXCy5nGYKDAe","id":"4VPrTgtrZqcXCy5nGYKDAe","name":"The Stone Canyon Band","type":"artist","uri":"spotify:artist:4VPrTgtrZqcXCy5nGYKDAe"}],"disc_number":1,"duration_ms":229800,"explicit":false,"external_ids":{"isrc":"USMC17216079"},"external_urls":{"spotify":"https://open.spotify.com/track/7J5tyfg3OYVNR97KH66ovw"},"href":"https://api.spotify.com/v1/tracks/7J5tyfg3OYVNR97KH66ovw","id":"7J5tyfg3OYVNR97KH66ovw","is_local":false,"is_playable":true,"name":"Garden Party","track_number":2,"type":"track","uri":"spotify:track:7J5tyfg3OYVNR97KH66ovw"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PmC63uE7ZLY5TI3p0PGd3"},"href":"https://api.spotify.com/v1/artists/4PmC63uE7ZLY5TI3p0PGd3","id":"4PmC63uE7ZLY5TI3p0PGd3","name":"Tami Neilson","type":"artist","uri":"spotify:artist:4PmC63uE7ZLY5TI3p0PGd3"}],"external_urls":{"spotify":"https://open.spotify.com/album/4HBZRDJTyBsxnHSpDuigNB"},"href":"https://api.spotify.com/v1/albums/4HBZRDJTyBsxnHSpDuigNB","id":"4HBZRDJTyBsxnHSpDuigNB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739fdf9d3faa6ce8b075ecb3cd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029fdf9d3faa6ce8b075ecb3cd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519fdf9d3faa6ce8b075ecb3cd"}],"is_playable":true,"name":"Dynamite!","release_date":"2014-03-21","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4HBZRDJTyBsxnHSpDuigNB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4PmC63uE7ZLY5TI3p0PGd3"},"href":"https://api.spotify.com/v1/artists/4PmC63uE7ZLY5TI3p0PGd3","id":"4PmC63uE7ZLY5TI3p0PGd3","name":"Tami Neilson","type":"artist","uri":"spotify:artist:4PmC63uE7ZLY5TI3p0PGd3"}],"disc_number":1,"duration_ms":164666,"explicit":false,"external_ids":{"isrc":"NZRI11302943"},"external_urls":{"spotify":"https://open.spotify.com/track/4YDMaSvtnw0yxNSJcDylMd"},"href":"https://api.spotify.com/v1/tracks/4YDMaSvtnw0yxNSJcDylMd","id":"4YDMaSvtnw0yxNSJcDylMd","is_local":false,"is_playable":true,"name":"Walk (Back to Your Arms)","track_number":1,"type":"track","uri":"spotify:track:4YDMaSvtnw0yxNSJcDylMd"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1CYS1CYS1CYSUyME5pZWxzb24mdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MTAmbGltaXQ9MTAmcXVlcnk9QmEtQmEtQmElMjBOaWVsc29uJnR5cGU9dHJhY2siLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MjIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wMHgxZllTR2hkcVNjWEJScFNqM0RXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzAweDFmWVNHaGRxU2NYQlJwU2ozRFciLCJpZCI6IjAweDFmWVNHaGRxU2NYQlJwU2ozRFciLCJuYW1lIjoiT2xpdmlhIERlYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDB4MWZZU0doZHFTY1hCUnBTajNEVyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc0c0ZyS0dkSTdaQkJWS3JUOWp0ZFYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83NHNGcktHZEk3WkJCVktyVDlqdGRWIiwiaWQiOiI3NHNGcktHZEk3WkJCVktyVDlqdGRWIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2E5ZTc1MDk5ZDcwNjVjNzFjYzdlZGU3MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhOWU3NTA5OWQ3MDY1YzcxY2M3ZWRlNzIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWE5ZTc1MDk5ZDcwNjVjNzFjYzdlZGU3MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOaWNlIFRvIEVhY2ggT3RoZXIiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA1LTMwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3NHNGcktHZEk3WkJCVktyVDlqdGRWIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDB4MWZZU0doZHFTY1hCUnBTajNEVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdg==", + "MS9hcnRpc3RzLzAweDFmWVNHaGRxU2NYQlJwU2ozRFciLCJpZCI6IjAweDFmWVNHaGRxU2NYQlJwU2ozRFciLCJuYW1lIjoiT2xpdmlhIERlYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDB4MWZZU0doZHFTY1hCUnBTajNEVyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDkwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlVNNzI1MDIyMzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdnS3hDdlREV3dWOXdCaGRlQmJyM2wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83Z0t4Q3ZURFd3Vjl3QmhkZUJicjNsIiwiaWQiOiI3Z0t4Q3ZURFd3Vjl3QmhkZUJicjNsIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5pY2UgVG8gRWFjaCBPdGhlciIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3Z0t4Q3ZURFd3Vjl3QmhkZUJicjNsIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzAweDFmWVNHaGRxU2NYQlJwU2ozRFcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDB4MWZZU0doZHFTY1hCUnBTajNEVyIsImlkIjoiMDB4MWZZU0doZHFTY1hCUnBTajNEVyIsIm5hbWUiOiJPbGl2aWEgRGVhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowMHgxZllTR2hkcVNjWEJScFNqM0RXIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMGw4ellxb1VlQllnNDdHbWV2cTlIWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBsOHpZcW9VZUJZZzQ3R21ldnE5SFoiLCJpZCI6IjBsOHpZcW9VZUJZZzQ3R21ldnE5SFoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWEzMzZiZmI2ZDQwYmJkOTBhNTA3NDE3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjlhMzM2YmZiNmQ0MGJiZDkwYTUwNzQxNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWEzMzZiZmI2ZDQwYmJkOTBhNTA3NDE3In1dLCJpc19wbGF5YWJsZSI6dA==", + "cnVlLCJuYW1lIjoiVGhlIEFydCBvZiBMb3ZpbmciLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA5LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MGw4ellxb1VlQllnNDdHbWV2cTlIWiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzAweDFmWVNHaGRxU2NYQlJwU2ozRFcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDB4MWZZU0doZHFTY1hCUnBTajNEVyIsImlkIjoiMDB4MWZZU0doZHFTY1hCUnBTajNEVyIsIm5hbWUiOiJPbGl2aWEgRGVhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowMHgxZllTR2hkcVNjWEJScFNqM0RXIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NzAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MjUwMzA5MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVNydUVCWDNLcGdwRHZFY0l1TjUzUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVTcnVFQlgzS3BncER2RWNJdU41M1AiLCJpZCI6IjVTcnVFQlgzS3BncER2RWNJdU41M1AiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmFieSBTdGVwcyIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NVNydUVCWDNLcGdwRHZFY0l1TjUzUCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82S0ltQ1ZENzB2dElvSlducTZuR24zIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZLSW1DVkQ3MHZ0SW9KV25xNm5HbjMiLCJpZCI6IjZLSW1DVkQ3MHZ0SW9KV25xNm5HbjMiLCJuYW1lIjoiSGFycnkgU3R5bGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZLSW1DVkQ3MHZ0SW9KV25xNm5HbjMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81cjM2QUo2Vk9KdHAwMG94U2tCWjVoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNXIzNkFKNlZPSnRwMDBveFNrQlo1aCIsImlkIjoiNXIzNkFKNlZPSnRwMDBveFNrQlo1aCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIg==", + "OjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzgyY2UzNjI1MTFmYjNkOWRkYTY1NzhlZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4MmNlMzYyNTExZmIzZDlkZGE2NTc4ZWUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTgyY2UzNjI1MTFmYjNkOWRkYTY1NzhlZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIYXJyeSdzIEhvdXNlIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0wNS0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVyMzZBSjZWT0p0cDAwb3hTa0JaNWgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82S0ltQ1ZENzB2dElvSlducTZuR24zIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZLSW1DVkQ3MHZ0SW9KV25xNm5HbjMiLCJpZCI6IjZLSW1DVkQ3MHZ0SW9KV25xNm5HbjMiLCJuYW1lIjoiSGFycnkgU3R5bGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZLSW1DVkQ3MHZ0SW9KV25xNm5HbjMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTkzODEzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEyMjAwNjA5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81TFlNYW1MdjEyVVBiZW1PYVRQeWVWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUxZTWFtTHYxMlVQYmVtT2FUUHllViIsImlkIjoiNUxZTWFtTHYxMlVQYmVtT2FUUHllViIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNdXNpYyBGb3IgYSBTdXNoaSBSZXN0YXVyYW50IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVMWU1hbUx2MTJVUGJlbU9hVFB5ZVYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDJrSlN6eE51YVdHcXd1YnlVYmEwWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wMmtKU3p4TnVhV0dxd3VieVViYTBaIiwiaWQiOiIwMmtKU3p4TnVhV0dxdw==", + "dWJ5VWJhMFoiLCJuYW1lIjoiRy1FYXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjAya0pTenhOdWFXR3F3dWJ5VWJhMFoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wOVEzV3dHWXNRZTVvZ25rdlZrbUN1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDlRM1d3R1lzUWU1b2dua3ZWa21DdSIsImlkIjoiMDlRM1d3R1lzUWU1b2dua3ZWa21DdSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiZjM0NjYwYTJjYzNmNGQ4Mzk2NmIxZTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmYzNDY2MGEyY2MzZjRkODM5NjZiMWU3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiZjM0NjYwYTJjYzNmNGQ4Mzk2NmIxZTcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2hlbiBJdCdzIERhcmsgT3V0IiwicmVsZWFzZV9kYXRlIjoiMjAxNS0xMi0wNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjA5UTNXd0dZc1FlNW9nbmt2VmttQ3UifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wMmtKU3p4TnVhV0dxd3VieVViYTBaIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzAya0pTenhOdWFXR3F3dWJ5VWJhMFoiLCJpZCI6IjAya0pTenhOdWFXR3F3dWJ5VWJhMFoiLCJuYW1lIjoiRy1FYXp5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjAya0pTenhOdWFXR3F3dWJ5VWJhMFoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNjRNNmFoMFNra1JzblBHdEdpUkFiYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82NE02YWgwU2trUnNuUEd0R2lSQWJiIiwiaWQiOiI2NE02YWgwU2trUnNuUEd0R2lSQWJiIiwibmFtZSI6IkJlYmUgUmV4aGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjRNNmFoMFNra1JzblBHdEdpUkFiYiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTE0NjUsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYw==", + "IjoiVVNSQzExNTAyMjEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80MFljdVF5c0owS2xHUVRlR1Vvc1RDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDBZY3VReXNKMEtsR1FUZUdVb3NUQyIsImlkIjoiNDBZY3VReXNKMEtsR1FUZUdVb3NUQyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNZSwgTXlzZWxmICYgSSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0MFljdVF5c0owS2xHUVRlR1Vvc1RDIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzAweDFmWVNHaGRxU2NYQlJwU2ozRFcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDB4MWZZU0doZHFTY1hCUnBTajNEVyIsImlkIjoiMDB4MWZZU0doZHFTY1hCUnBTajNEVyIsIm5hbWUiOiJPbGl2aWEgRGVhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowMHgxZllTR2hkcVNjWEJScFNqM0RXIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMGw4ellxb1VlQllnNDdHbWV2cTlIWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBsOHpZcW9VZUJZZzQ3R21ldnE5SFoiLCJpZCI6IjBsOHpZcW9VZUJZZzQ3R21ldnE5SFoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWEzMzZiZmI2ZDQwYmJkOTBhNTA3NDE3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjlhMzM2YmZiNmQ0MGJiZDkwYTUwNzQxNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWEzMzZiZmI2ZDQwYmJkOTBhNTA3NDE3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBBcnQgb2YgTG92aW5nIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wOS0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBsOHpZcW9VZUJZZzQ3R21ldnE5SFoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZg==", + "eS5jb20vYXJ0aXN0LzAweDFmWVNHaGRxU2NYQlJwU2ozRFcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDB4MWZZU0doZHFTY1hCUnBTajNEVyIsImlkIjoiMDB4MWZZU0doZHFTY1hCUnBTajNEVyIsIm5hbWUiOiJPbGl2aWEgRGVhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowMHgxZllTR2hkcVNjWEJScFNqM0RXIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwOTAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MjUwMjIzMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN3FFaUJXbHp0dkRGcklMZGl6RlVMeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdxRWlCV2x6dHZERnJJTGRpekZVTHgiLCJpZCI6IjdxRWlCV2x6dHZERnJJTGRpekZVTHgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmljZSBUbyBFYWNoIE90aGVyIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdxRWlCV2x6dHZERnJJTGRpekZVTHgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRrdEJyTmphZ0NHZnR5dUJMSmtBVHEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGt0QnJOamFnQ0dmdHl1QkxKa0FUcSIsImlkIjoiNGt0QnJOamFnQ0dmdHl1QkxKa0FUcSIsIm5hbWUiOiJXZXMgTmVsc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRrdEJyTmphZ0NHZnR5dUJMSmtBVHEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUFiTHBzblRRVk5CM09FYWRZaVZySyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81QWJMcHNuVFFWTkIzT0VhZFlpVnJLIiwiaWQiOiI1QWJMcHNuVFFWTkIzT0VhZFlpVnJLIiwibmFtZSI6Ill4bmcgQmFuZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1QWJMcHNuVFFWTkIzT0VhZFlpVnJLIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNWxTd0RkUGpNU1FrMjdLd1VZbEMyciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVsU3dEZFBqTVNRazI3S3dVWWxDMnIiLCJpZCI6IjVsU3dEZFBqTVNRaw==", + "MjdLd1VZbEMyciIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1ZmM1Yjc5MDYwNjJmYWQ4MjY4ZjMzYzQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWZjNWI3OTA2MDYyZmFkODI2OGYzM2M0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1ZmM1Yjc5MDYwNjJmYWQ4MjY4ZjMzYzQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmljZSBUbyBNZWV0IFlhIChmZWF0LiBZeG5nIEJhbmUpIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wNC0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWxTd0RkUGpNU1FrMjdLd1VZbEMyciJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRrdEJyTmphZ0NHZnR5dUJMSmtBVHEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGt0QnJOamFnQ0dmdHl1QkxKa0FUcSIsImlkIjoiNGt0QnJOamFnQ0dmdHl1QkxKa0FUcSIsIm5hbWUiOiJXZXMgTmVsc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRrdEJyTmphZ0NHZnR5dUJMSmtBVHEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUFiTHBzblRRVk5CM09FYWRZaVZySyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81QWJMcHNuVFFWTkIzT0VhZFlpVnJLIiwiaWQiOiI1QWJMcHNuVFFWTkIzT0VhZFlpVnJLIiwibmFtZSI6Ill4bmcgQmFuZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1QWJMcHNuVFFWTkIzT0VhZFlpVnJLIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4MTkxOCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MjEwMTg0OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVlIalJBcHRYcVBkc2R4M2c2Rk5KTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFZSGpSQXB0WHFQZHNkeDNnNkZOSkwiLCJpZCI6IjFZSGpSQXB0WHFQZHNkeDNnNkZOSkwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIg==", + "OiJOaWNlIFRvIE1lZXQgWWEgKGZlYXQuIFl4bmcgQmFuZSkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MVlIalJBcHRYcVBkc2R4M2c2Rk5KTCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zUlR6QXdGcHJCcWlza3A1NTBlU0pYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNSVHpBd0ZwckJxaXNrcDU1MGVTSlgiLCJpZCI6IjNSVHpBd0ZwckJxaXNrcDU1MGVTSlgiLCJuYW1lIjoiSGFycnkgTmlsc3NvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozUlR6QXdGcHJCcWlza3A1NTBlU0pYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMEgzdjRzbkQ2eGh3b3JzalhuZHNhaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBIM3Y0c25ENnhod29yc2pYbmRzYWkiLCJpZCI6IjBIM3Y0c25ENnhod29yc2pYbmRzYWkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODhjYzI4ZjA1Yjc5NDQ4OWVmMjc4YWJkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjg4Y2MyOGYwNWI3OTQ0ODllZjI3OGFiZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODhjYzI4ZjA1Yjc5NDQ4OWVmMjc4YWJkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFlcmlhbCBCYWxsZXQiLCJyZWxlYXNlX2RhdGUiOiIxOTY4LTA3LTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MEgzdjRzbkQ2eGh3b3JzalhuZHNhaSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNSVHpBd0ZwckJxaXNrcDU1MGVTSlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM1JUekF3RnByQnFpc2twNTUwZVNKWCIsImlkIjoiM1JUekF3RnByQnFpc2twNTUwZVNKWCIsIm5hbWUiOiJIYXJyeSBOaWxzc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNSVHpBd0ZwckJxaXNrcDU1MGVTSlgifV0sIg==", + "ZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjQwODksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JDMTk5MDExMDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFqY1BjRHUyWWF3UGZMaHdqWW5xSzIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xamNQY0R1Mllhd1BmTGh3allucUsyIiwiaWQiOiIxamNQY0R1Mllhd1BmTGh3allucUsyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkV2ZXJ5Ym9keSdzIFRhbGtpbicgLSBGcm9tIFwiTWlkbmlnaHQgQ293Ym95XCIiLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MWpjUGNEdTJZYXdQZkxod2pZbnFLMiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81aVhZSlltTWNqbFRGTDFxQThVZmdZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVpWFlKWW1NY2psVEZMMXFBOFVmZ1kiLCJpZCI6IjVpWFlKWW1NY2psVEZMMXFBOFVmZ1kiLCJuYW1lIjoiTHVrYXMgTmVsc29uIGFuZCBQcm9taXNlIG9mIHRoZSBSZWFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVpWFlKWW1NY2psVEZMMXFBOFVmZ1kifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82YUk1bWc0Z0tzaklvRkx2cVBPTkM0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNmFJNW1nNGdLc2pJb0ZMdnFQT05DNCIsImlkIjoiNmFJNW1nNGdLc2pJb0ZMdnFQT05DNCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjMzc3ZWJkODlmYWYxODk0YzA3MmNmZWUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzM3N2ViZDg5ZmFmMTg5NGMwNzJjZmVlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjMzc3ZWJkODlmYWYxODk0YzA3MmNmZWUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUHJvbWlzZSBvZiB0aGUgUmVhbCIsInJlbGVhc2VfZGF0ZSI6IjIwMTAtMTItMjEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YQ==", + "bF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZhSTVtZzRnS3NqSW9GTHZxUE9OQzQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81aVhZSlltTWNqbFRGTDFxQThVZmdZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVpWFlKWW1NY2psVEZMMXFBOFVmZ1kiLCJpZCI6IjVpWFlKWW1NY2psVEZMMXFBOFVmZ1kiLCJuYW1lIjoiTHVrYXMgTmVsc29uIGFuZCBQcm9taXNlIG9mIHRoZSBSZWFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVpWFlKWW1NY2psVEZMMXFBOFVmZ1kifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzE4ODI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVENBQVQxMDUzMzM0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wSlQwRDgzTlR0M28yVmJaU0kzZjVLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMEpUMEQ4M05UdDNvMlZiWlNJM2Y1SyIsImlkIjoiMEpUMEQ4M05UdDNvMlZiWlNJM2Y1SyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQYWxpIEdhcCAvIEhleSBCYWJ5IChOZXcgUmlzaW5nIFN1bikiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MEpUMEQ4M05UdDNvMlZiWlNJM2Y1SyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NTRlZsTTZwa3dlTFhFOHF3MU9TIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc1NGVmxNNnBrd2VMWEU4cXcxT1MiLCJpZCI6Ijczc1NGVmxNNnBrd2VMWEU4cXcxT1MiLCJuYW1lIjoiUmlja3kgTmVsc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc1NGVmxNNnBrd2VMWEU4cXcxT1MifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFZQclRndHJacWNYQ3k1bkdZS0RBZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80VlByVGd0clpxY1hDeTVuR1lLREFlIiwiaWQiOiI0VlByVGd0clpxY1hDeTVuR1lLREFlIiwibmFtZSI6IlRoZSBTdG9uZSBDYW55b24gQmFuZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0VlByVA==", + "Z3RyWnFjWEN5NW5HWUtEQWUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83NkJyRHJBRWNRaGp2WGVoQ1ZNcFd2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzZCckRyQUVjUWhqdlhlaENWTXBXdiIsImlkIjoiNzZCckRyQUVjUWhqdlhlaENWTXBXdiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhMDNkZGRlYjQ2MGUzN2VjYzhhYmU3MTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTAzZGRkZWI0NjBlMzdlY2M4YWJlNzE4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhMDNkZGRlYjQ2MGUzN2VjYzhhYmU3MTgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR2FyZGVuIFBhcnR5IiwicmVsZWFzZV9kYXRlIjoiMTk3MiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3NkJyRHJBRWNRaGp2WGVoQ1ZNcFd2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzU0ZWbE02cGt3ZUxYRThxdzFPUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NTRlZsTTZwa3dlTFhFOHF3MU9TIiwiaWQiOiI3M3NTRlZsTTZwa3dlTFhFOHF3MU9TIiwibmFtZSI6IlJpY2t5IE5lbHNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NTRlZsTTZwa3dlTFhFOHF3MU9TIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRWUHJUZ3RyWnFjWEN5NW5HWUtEQWUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFZQclRndHJacWNYQ3k1bkdZS0RBZSIsImlkIjoiNFZQclRndHJacWNYQ3k1bkdZS0RBZSIsIm5hbWUiOiJUaGUgU3RvbmUgQ2FueW9uIEJhbmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJp", + "Ijoic3BvdGlmeTphcnRpc3Q6NFZQclRndHJacWNYQ3k1bkdZS0RBZSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjk4MDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU01DMTcyMTYwNzkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdKNXR5ZmczT1lWTlI5N0tINjZvdncifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83SjV0eWZnM09ZVk5SOTdLSDY2b3Z3IiwiaWQiOiI3SjV0eWZnM09ZVk5SOTdLSDY2b3Z3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdhcmRlbiBQYXJ0eSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3SjV0eWZnM09ZVk5SOTdLSDY2b3Z3In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRQbUM2M3VFN1pMWTVUSTNwMFBHZDMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFBtQzYzdUU3WkxZNVRJM3AwUEdkMyIsImlkIjoiNFBtQzYzdUU3WkxZNVRJM3AwUEdkMyIsIm5hbWUiOiJUYW1pIE5laWxzb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFBtQzYzdUU3WkxZNVRJM3AwUEdkMyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRIQlpSREpUeUJzeG5IU3BEdWlnTkIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80SEJaUkRKVHlCc3huSFNwRHVpZ05CIiwiaWQiOiI0SEJaUkRKVHlCc3huSFNwRHVpZ05CIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzlmZGY5ZDNmYWE2Y2U4YjA3NWVjYjNjZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5ZmRmOWQzZmFhNmNlOGIwNzVlY2IzY2QifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTlmZGY5ZDNmYWE2Y2U4YjA3NWVjYjNjZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEeW5hbWl0ZSEiLCJyZWxlYXNlX2RhdGUiOiIyMDE0LTAzLTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbA==", + "YnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0SEJaUkRKVHlCc3huSFNwRHVpZ05CIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFBtQzYzdUU3WkxZNVRJM3AwUEdkMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80UG1DNjN1RTdaTFk1VEkzcDBQR2QzIiwiaWQiOiI0UG1DNjN1RTdaTFk1VEkzcDBQR2QzIiwibmFtZSI6IlRhbWkgTmVpbHNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0UG1DNjN1RTdaTFk1VEkzcDBQR2QzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2NDY2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5aUkkxMTMwMjk0MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFlETWFTdnRudzB5eE5TSmNEeWxNZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRZRE1hU3Z0bncweXhOU0pjRHlsTWQiLCJpZCI6IjRZRE1hU3Z0bncweXhOU0pjRHlsTWQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2FsayAoQmFjayB0byBZb3VyIEFybXMpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRZRE1hU3Z0bncweXhOU0pjRHlsTWQifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Ba-Ba-Ba+Nielson&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Liefs%20Uit%20Amsterdam%20Lange%20Frans&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Liefs%20Uit%20Amsterdam%20Lange%20Frans&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/6um3VlGOcC7PWzcKeYidCV"},"href":"https://api.spotify.com/v1/albums/6um3VlGOcC7PWzcKeYidCV","id":"6um3VlGOcC7PWzcKeYidCV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e2e4b4cf54573a895f7defa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e2e4b4cf54573a895f7defa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e2e4b4cf54573a895f7defa"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-08-10","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:6um3VlGOcC7PWzcKeYidCV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":230440,"explicit":false,"external_ids":{"isrc":"NLG270500124"},"external_urls":{"spotify":"https://open.spotify.com/track/0wMAsL98TGuI6eWUEocd1O"},"href":"https://api.spotify.com/v1/tracks/0wMAsL98TGuI6eWUEocd1O","id":"0wMAsL98TGuI6eWUEocd1O","is_local":false,"is_playable":true,"name":"Het Land Van","track_number":2,"type":"track","uri":"spotify:track:0wMAsL98TGuI6eWUEocd1O"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l5sWxJhBcsUTN00u33vgf"},"href":"https://api.spotify.com/v1/albums/4l5sWxJhBcsUTN00u33vgf","id":"4l5sWxJhBcsUTN00u33vgf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6376faaee805193164ae229"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6376faaee805193164ae229"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6376faaee805193164ae229"}],"is_playable":true,"name":"Supervisie","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4l5sWxJhBcsUTN00u33vgf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":199746,"explicit":false,"external_ids":{"isrc":"NLG270400037"},"external_urls":{"spotify":"https://open.spotify.com/track/3xJFoFhytOgP1qnJrPT9Qk"},"href":"https://api.spotify.com/v1/tracks/3xJFoFhytOgP1qnJrPT9Qk","id":"3xJFoFhytOgP1qnJrPT9Qk","is_local":false,"is_playable":true,"name":"Supervisie","track_number":11,"type":"track","uri":"spotify:track:3xJFoFhytOgP1qnJrPT9Qk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iSpJp1RScZ4Afk8BkVp9v"},"href":"https://api.spotify.com/v1/artists/0iSpJp1RScZ4Afk8BkVp9v","id":"0iSpJp1RScZ4Afk8BkVp9v","name":"Ron van Zalmsaus","type":"artist","uri":"spotify:artist:0iSpJp1RScZ4Afk8BkVp9v"}],"external_urls":{"spotify":"https://open.spotify.com/album/2XpPlzSf2J0B8KRfG1aEvk"},"href":"https://api.spotify.com/v1/albums/2XpPlzSf2J0B8KRfG1aEvk","id":"2XpPlzSf2J0B8KRfG1aEvk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27340431815bda117512a9e0a47"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0240431815bda117512a9e0a47"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485140431815bda117512a9e0a47"}],"is_playable":true,"name":"De Zalmsound","release_date":"2022-08-04","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:2XpPlzSf2J0B8KRfG1aEvk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iSpJp1RScZ4Afk8BkVp9v"},"href":"https://api.spotify.com/v1/artists/0iSpJp1RScZ4Afk8BkVp9v","id":"0iSpJp1RScZ4Afk8BkVp9v","name":"Ron van Zalmsaus","type":"artist","uri":"spotify:artist:0iSpJp1RScZ4Afk8BkVp9v"}],"disc_number":1,"duration_ms":312700,"explicit":true,"external_ids":{"isrc":"QZMEP2213380"},"external_urls":{"spotify":"https://open.spotify.com/track/4QLBQIjBxZRJlj2wsALTh2"},"href":"https://api.spotify.com/v1/tracks/4QLBQIjBxZRJlj2wsALTh2","id":"4QLBQIjBxZRJlj2wsALTh2","is_local":false,"is_playable":true,"name":"Gagigagek","track_number":11,"type":"track","uri":"spotify:track:4QLBQIjBxZRJlj2wsALTh2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l5sWxJhBcsUTN00u33vgf"},"href":"https://api.spotify.com/v1/albums/4l5sWxJhBcsUTN00u33vgf","id":"4l5sWxJhBcsUTN00u33vgf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6376faaee805193164ae229"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6376faaee805193164ae229"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6376faaee805193164ae229"}],"is_playable":true,"name":"Supervisie","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4l5sWxJhBcsUTN00u33vgf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":231466,"explicit":false,"external_ids":{"isrc":"NLG270400030"},"external_urls":{"spotify":"https://open.spotify.com/track/1U7vbqdORXtMCMEa0p0R1i"},"href":"https://api.spotify.com/v1/tracks/1U7vbqdORXtMCMEa0p0R1i","id":"1U7vbqdORXtMCMEa0p0R1i","is_local":false,"is_playable":true,"name":"Represent","track_number":1,"type":"track","uri":"spotify:track:1U7vbqdORXtMCMEa0p0R1i"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l5sWxJhBcsUTN00u33vgf"},"href":"https://api.spotify.com/v1/albums/4l5sWxJhBcsUTN00u33vgf","id":"4l5sWxJhBcsUTN00u33vgf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6376faaee805193164ae229"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6376faaee805193164ae229"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6376faaee805193164ae229"}],"is_playable":true,"name":"Supervisie","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4l5sWxJhBcsUTN00u33vgf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":253640,"explicit":false,"external_ids":{"isrc":"NLG270400033"},"external_urls":{"spotify":"https://open.spotify.com/track/0OISylSRvzoaaTfajh8rKe"},"href":"https://api.spotify.com/v1/tracks/0OISylSRvzoaaTfajh8rKe","id":"0OISylSRvzoaaTfajh8rKe","is_local":false,"is_playable":true,"name":"Ver Van Je Bed-Show","track_number":5,"type":"track","uri":"spotify:track:0OISylSRvzoaaTfajh8rKe"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6OL2KDr0EilFLoiuOrrC4G"},"href":"https://api.spotify.com/v1/albums/6OL2KDr0EilFLoiuOrrC4G","id":"6OL2KDr0EilFLoiuOrrC4G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e61ab3a6d9706cd68ae144e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e61ab3a6d9706cd68ae144e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e61ab3a6d9706cd68ae144e"}],"is_playable":true,"name":"F*CK KLEINE","release_date":"2026-04-02","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6OL2KDr0EilFLoiuOrrC4G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":91659,"explicit":true,"external_ids":{"isrc":"QM4TX2643215"},"external_urls":{"spotify":"https://open.spotify.com/track/0zIrkycTJJ9sM6yYODziN2"},"href":"https://api.spotify.com/v1/tracks/0zIrkycTJJ9sM6yYODziN2","id":"0zIrkycTJJ9sM6yYODziN2","is_local":false,"is_playable":true,"name":"Lekker voor je","track_number":2,"type":"track","uri":"spotify:track:0zIrkycTJJ9sM6yYODziN2"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LcUpNlXFEleaLlelmkv2R"},"href":"https://api.spotify.com/v1/artists/4LcUpNlXFEleaLlelmkv2R","id":"4LcUpNlXFEleaLlelmkv2R","name":"Kris Kross Amsterdam","type":"artist","uri":"spotify:artist:4LcUpNlXFEleaLlelmkv2R"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5l2Xy4aUoJDRSpsYHyOumD"},"href":"https://api.spotify.com/v1/artists/5l2Xy4aUoJDRSpsYHyOumD","id":"5l2Xy4aUoJDRSpsYHyOumD","name":"Andr\u00e9 Hazes Jr.","type":"artist","uri":"spotify:artist:5l2Xy4aUoJDRSpsYHyOumD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7iBY1RLWDV5zX9NDNQxurm"},"href":"https://api.spotify.com/v1/artists/7iBY1RLWDV5zX9NDNQxurm","id":"7iBY1RLWDV5zX9NDNQxurm","name":"Tabitha","type":"artist","uri":"spotify:artist:7iBY1RLWDV5zX9NDNQxurm"}],"external_urls":{"spotify":"https://open.spotify.com/album/5aKbiaSUuJPZ1uX7SUXcDx"},"href":"https://api.spotify.com/v1/albums/5aKbiaSUuJPZ1uX7SUXcDx","id":"5aKbiaSUuJPZ1uX7SUXcDx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b5f7a810d9727370cce419df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b5f7a810d9727370cce419df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b5f7a810d9727370cce419df"}],"is_playable":true,"name":"Ze Komt Uit Amsterdam","release_date":"2025-06-12","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5aKbiaSUuJPZ1uX7SUXcDx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LcUpNlXFEleaLlelmkv2R"},"href":"https://api.spotify.com/v1/artists/4LcUpNlXFEleaLlelmkv2R","id":"4LcUpNlXFEleaLlelmkv2R","name":"Kris Kross Amsterdam","type":"artist","uri":"spotify:artist:4LcUpNlXFEleaLlelmkv2R"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5l2Xy4aUoJDRSpsYHyOumD"},"href":"https://api.spotify.com/v1/artists/5l2Xy4aUoJDRSpsYHyOumD","id":"5l2Xy4aUoJDRSpsYHyOumD","name":"Andr\u00e9 Hazes Jr.","type":"artist","uri":"spotify:artist:5l2Xy4aUoJDRSpsYHyOumD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7iBY1RLWDV5zX9NDNQxurm"},"href":"https://api.spotify.com/v1/artists/7iBY1RLWDV5zX9NDNQxurm","id":"7iBY1RLWDV5zX9NDNQxurm","name":"Tabitha","type":"artist","uri":"spotify:artist:7iBY1RLWDV5zX9NDNQxurm"}],"disc_number":1,"duration_ms":152727,"explicit":false,"external_ids":{"isrc":"NLS242500087"},"external_urls":{"spotify":"https://open.spotify.com/track/2xJIY9JQQdNzFVAumSXsIF"},"href":"https://api.spotify.com/v1/tracks/2xJIY9JQQdNzFVAumSXsIF","id":"2xJIY9JQQdNzFVAumSXsIF","is_local":false,"is_playable":true,"name":"Ze Komt Uit Amsterdam","track_number":1,"type":"track","uri":"spotify:track:2xJIY9JQQdNzFVAumSXsIF"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MvyMusqNikgVgkKHLc3pb"},"href":"https://api.spotify.com/v1/artists/5MvyMusqNikgVgkKHLc3pb","id":"5MvyMusqNikgVgkKHLc3pb","name":"Rene Froger","type":"artist","uri":"spotify:artist:5MvyMusqNikgVgkKHLc3pb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/1jX6gMEqq4bjLldidR0Pnk"},"href":"https://api.spotify.com/v1/albums/1jX6gMEqq4bjLldidR0Pnk","id":"1jX6gMEqq4bjLldidR0Pnk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738fe4cb0eb3f1ee38d745ef26"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028fe4cb0eb3f1ee38d745ef26"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518fe4cb0eb3f1ee38d745ef26"}],"is_playable":true,"name":"Amsterdam, Amsterdam","release_date":"2025-06-06","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1jX6gMEqq4bjLldidR0Pnk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MvyMusqNikgVgkKHLc3pb"},"href":"https://api.spotify.com/v1/artists/5MvyMusqNikgVgkKHLc3pb","id":"5MvyMusqNikgVgkKHLc3pb","name":"Rene Froger","type":"artist","uri":"spotify:artist:5MvyMusqNikgVgkKHLc3pb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":148375,"explicit":false,"external_ids":{"isrc":"NLQ272500069"},"external_urls":{"spotify":"https://open.spotify.com/track/1FpAv3Krz2Qe2b5RP9PFMp"},"href":"https://api.spotify.com/v1/tracks/1FpAv3Krz2Qe2b5RP9PFMp","id":"1FpAv3Krz2Qe2b5RP9PFMp","is_local":false,"is_playable":true,"name":"Amsterdam, Amsterdam","track_number":1,"type":"track","uri":"spotify:track:1FpAv3Krz2Qe2b5RP9PFMp"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4sf0XtUsKwVtg6YK72Dx2C"},"href":"https://api.spotify.com/v1/artists/4sf0XtUsKwVtg6YK72Dx2C","id":"4sf0XtUsKwVtg6YK72Dx2C","name":"Steen","type":"artist","uri":"spotify:artist:4sf0XtUsKwVtg6YK72Dx2C"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0mJmP5PtashnU2L2BkBn28"},"href":"https://api.spotify.com/v1/artists/0mJmP5PtashnU2L2BkBn28","id":"0mJmP5PtashnU2L2BkBn28","name":"Spinal","type":"artist","uri":"spotify:artist:0mJmP5PtashnU2L2BkBn28"}],"external_urls":{"spotify":"https://open.spotify.com/album/7vFRuRZwFX14kfFhUgUcMO"},"href":"https://api.spotify.com/v1/albums/7vFRuRZwFX14kfFhUgUcMO","id":"7vFRuRZwFX14kfFhUgUcMO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273883771562d09651bb93e70bf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02883771562d09651bb93e70bf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851883771562d09651bb93e70bf"}],"is_playable":true,"name":"Kadaverrap","release_date":"2007-04-09","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:7vFRuRZwFX14kfFhUgUcMO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4sf0XtUsKwVtg6YK72Dx2C"},"href":"https://api.spotify.com/v1/artists/4sf0XtUsKwVtg6YK72Dx2C","id":"4sf0XtUsKwVtg6YK72Dx2C","name":"Steen","type":"artist","uri":"spotify:artist:4sf0XtUsKwVtg6YK72Dx2C"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0mJmP5PtashnU2L2BkBn28"},"href":"https://api.spotify.com/v1/artists/0mJmP5PtashnU2L2BkBn28","id":"0mJmP5PtashnU2L2BkBn28","name":"Spinal","type":"artist","uri":"spotify:artist:0mJmP5PtashnU2L2BkBn28"}],"disc_number":1,"duration_ms":264746,"explicit":true,"external_ids":{"isrc":"NLSR31100063"},"external_urls":{"spotify":"https://open.spotify.com/track/1Ylpok7SisyLxvkTmpwvPD"},"href":"https://api.spotify.com/v1/tracks/1Ylpok7SisyLxvkTmpwvPD","id":"1Ylpok7SisyLxvkTmpwvPD","is_local":false,"is_playable":true,"name":"Haat","track_number":4,"type":"track","uri":"spotify:track:1Ylpok7SisyLxvkTmpwvPD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/30WLe30YBfDFoIkJS0Tml9"},"href":"https://api.spotify.com/v1/artists/30WLe30YBfDFoIkJS0Tml9","id":"30WLe30YBfDFoIkJS0Tml9","name":"Ares","type":"artist","uri":"spotify:artist:30WLe30YBfDFoIkJS0Tml9"}],"external_urls":{"spotify":"https://open.spotify.com/album/5l48SLlgx8pZ3IlNFGgHF1"},"href":"https://api.spotify.com/v1/albums/5l48SLlgx8pZ3IlNFGgHF1","id":"5l48SLlgx8pZ3IlNFGgHF1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b163130290369b3e14cd05f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b163130290369b3e14cd05f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b163130290369b3e14cd05f5"}],"is_playable":true,"name":"Alice","release_date":"2018-09-14","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5l48SLlgx8pZ3IlNFGgHF1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/30WLe30YBfDFoIkJS0Tml9"},"href":"https://api.spotify.com/v1/artists/30WLe30YBfDFoIkJS0Tml9","id":"30WLe30YBfDFoIkJS0Tml9","name":"Ares","type":"artist","uri":"spotify:artist:30WLe30YBfDFoIkJS0Tml9"}],"disc_number":1,"duration_ms":176158,"explicit":true,"external_ids":{"isrc":"TCADU1845299"},"external_urls":{"spotify":"https://open.spotify.com/track/0pmYKHYiYfu772iiuLRGCq"},"href":"https://api.spotify.com/v1/tracks/0pmYKHYiYfu772iiuLRGCq","id":"0pmYKHYiYfu772iiuLRGCq","is_local":false,"is_playable":true,"name":"Alice","track_number":5,"type":"track","uri":"spotify:track:0pmYKHYiYfu772iiuLRGCq"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Liefs%20Uit%20Amsterdam%20Lange%20Frans&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Liefs%20Uit%20Amsterdam%20Lange%20Frans&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/6um3VlGOcC7PWzcKeYidCV"},"href":"https://api.spotify.com/v1/albums/6um3VlGOcC7PWzcKeYidCV","id":"6um3VlGOcC7PWzcKeYidCV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e2e4b4cf54573a895f7defa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e2e4b4cf54573a895f7defa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e2e4b4cf54573a895f7defa"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-08-10","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:6um3VlGOcC7PWzcKeYidCV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":230440,"explicit":false,"external_ids":{"isrc":"NLG270500124"},"external_urls":{"spotify":"https://open.spotify.com/track/0wMAsL98TGuI6eWUEocd1O"},"href":"https://api.spotify.com/v1/tracks/0wMAsL98TGuI6eWUEocd1O","id":"0wMAsL98TGuI6eWUEocd1O","is_local":false,"is_playable":true,"name":"Het Land Van","track_number":2,"type":"track","uri":"spotify:track:0wMAsL98TGuI6eWUEocd1O"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l5sWxJhBcsUTN00u33vgf"},"href":"https://api.spotify.com/v1/albums/4l5sWxJhBcsUTN00u33vgf","id":"4l5sWxJhBcsUTN00u33vgf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6376faaee805193164ae229"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6376faaee805193164ae229"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6376faaee805193164ae229"}],"is_playable":true,"name":"Supervisie","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4l5sWxJhBcsUTN00u33vgf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":199746,"explicit":false,"external_ids":{"isrc":"NLG270400037"},"external_urls":{"spotify":"https://open.spotify.com/track/3xJFoFhytOgP1qnJrPT9Qk"},"href":"https://api.spotify.com/v1/tracks/3xJFoFhytOgP1qnJrPT9Qk","id":"3xJFoFhytOgP1qnJrPT9Qk","is_local":false,"is_playable":true,"name":"Supervisie","track_number":11,"type":"track","uri":"spotify:track:3xJFoFhytOgP1qnJrPT9Qk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iSpJp1RScZ4Afk8BkVp9v"},"href":"https://api.spotify.com/v1/artists/0iSpJp1RScZ4Afk8BkVp9v","id":"0iSpJp1RScZ4Afk8BkVp9v","name":"Ron van Zalmsaus","type":"artist","uri":"spotify:artist:0iSpJp1RScZ4Afk8BkVp9v"}],"external_urls":{"spotify":"https://open.spotify.com/album/2XpPlzSf2J0B8KRfG1aEvk"},"href":"https://api.spotify.com/v1/albums/2XpPlzSf2J0B8KRfG1aEvk","id":"2XpPlzSf2J0B8KRfG1aEvk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27340431815bda117512a9e0a47"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0240431815bda117512a9e0a47"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485140431815bda117512a9e0a47"}],"is_playable":true,"name":"De Zalmsound","release_date":"2022-08-04","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:2XpPlzSf2J0B8KRfG1aEvk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iSpJp1RScZ4Afk8BkVp9v"},"href":"https://api.spotify.com/v1/artists/0iSpJp1RScZ4Afk8BkVp9v","id":"0iSpJp1RScZ4Afk8BkVp9v","name":"Ron van Zalmsaus","type":"artist","uri":"spotify:artist:0iSpJp1RScZ4Afk8BkVp9v"}],"disc_number":1,"duration_ms":312700,"explicit":true,"external_ids":{"isrc":"QZMEP2213380"},"external_urls":{"spotify":"https://open.spotify.com/track/4QLBQIjBxZRJlj2wsALTh2"},"href":"https://api.spotify.com/v1/tracks/4QLBQIjBxZRJlj2wsALTh2","id":"4QLBQIjBxZRJlj2wsALTh2","is_local":false,"is_playable":true,"name":"Gagigagek","track_number":11,"type":"track","uri":"spotify:track:4QLBQIjBxZRJlj2wsALTh2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l5sWxJhBcsUTN00u33vgf"},"href":"https://api.spotify.com/v1/albums/4l5sWxJhBcsUTN00u33vgf","id":"4l5sWxJhBcsUTN00u33vgf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6376faaee805193164ae229"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6376faaee805193164ae229"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6376faaee805193164ae229"}],"is_playable":true,"name":"Supervisie","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4l5sWxJhBcsUTN00u33vgf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":231466,"explicit":false,"external_ids":{"isrc":"NLG270400030"},"external_urls":{"spotify":"https://open.spotify.com/track/1U7vbqdORXtMCMEa0p0R1i"},"href":"https://api.spotify.com/v1/tracks/1U7vbqdORXtMCMEa0p0R1i","id":"1U7vbqdORXtMCMEa0p0R1i","is_local":false,"is_playable":true,"name":"Represent","track_number":1,"type":"track","uri":"spotify:track:1U7vbqdORXtMCMEa0p0R1i"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l5sWxJhBcsUTN00u33vgf"},"href":"https://api.spotify.com/v1/albums/4l5sWxJhBcsUTN00u33vgf","id":"4l5sWxJhBcsUTN00u33vgf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6376faaee805193164ae229"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6376faaee805193164ae229"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6376faaee805193164ae229"}],"is_playable":true,"name":"Supervisie","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4l5sWxJhBcsUTN00u33vgf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":253640,"explicit":false,"external_ids":{"isrc":"NLG270400033"},"external_urls":{"spotify":"https://open.spotify.com/track/0OISylSRvzoaaTfajh8rKe"},"href":"https://api.spotify.com/v1/tracks/0OISylSRvzoaaTfajh8rKe","id":"0OISylSRvzoaaTfajh8rKe","is_local":false,"is_playable":true,"name":"Ver Van Je Bed-Show","track_number":5,"type":"track","uri":"spotify:track:0OISylSRvzoaaTfajh8rKe"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6OL2KDr0EilFLoiuOrrC4G"},"href":"https://api.spotify.com/v1/albums/6OL2KDr0EilFLoiuOrrC4G","id":"6OL2KDr0EilFLoiuOrrC4G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e61ab3a6d9706cd68ae144e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e61ab3a6d9706cd68ae144e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e61ab3a6d9706cd68ae144e"}],"is_playable":true,"name":"F*CK KLEINE","release_date":"2026-04-02","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6OL2KDr0EilFLoiuOrrC4G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3AlRiyjMywTVNzTcHbf9QT"},"href":"https://api.spotify.com/v1/artists/3AlRiyjMywTVNzTcHbf9QT","id":"3AlRiyjMywTVNzTcHbf9QT","name":"Lil Kleine","type":"artist","uri":"spotify:artist:3AlRiyjMywTVNzTcHbf9QT"}],"disc_number":1,"duration_ms":91659,"explicit":true,"external_ids":{"isrc":"QM4TX2643215"},"external_urls":{"spotify":"https://open.spotify.com/track/0zIrkycTJJ9sM6yYODziN2"},"href":"https://api.spotify.com/v1/tracks/0zIrkycTJJ9sM6yYODziN2","id":"0zIrkycTJJ9sM6yYODziN2","is_local":false,"is_playable":true,"name":"Lekker voor je","track_number":2,"type":"track","uri":"spotify:track:0zIrkycTJJ9sM6yYODziN2"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LcUpNlXFEleaLlelmkv2R"},"href":"https://api.spotify.com/v1/artists/4LcUpNlXFEleaLlelmkv2R","id":"4LcUpNlXFEleaLlelmkv2R","name":"Kris Kross Amsterdam","type":"artist","uri":"spotify:artist:4LcUpNlXFEleaLlelmkv2R"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5l2Xy4aUoJDRSpsYHyOumD"},"href":"https://api.spotify.com/v1/artists/5l2Xy4aUoJDRSpsYHyOumD","id":"5l2Xy4aUoJDRSpsYHyOumD","name":"Andr\u00e9 Hazes Jr.","type":"artist","uri":"spotify:artist:5l2Xy4aUoJDRSpsYHyOumD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7iBY1RLWDV5zX9NDNQxurm"},"href":"https://api.spotify.com/v1/artists/7iBY1RLWDV5zX9NDNQxurm","id":"7iBY1RLWDV5zX9NDNQxurm","name":"Tabitha","type":"artist","uri":"spotify:artist:7iBY1RLWDV5zX9NDNQxurm"}],"external_urls":{"spotify":"https://open.spotify.com/album/5aKbiaSUuJPZ1uX7SUXcDx"},"href":"https://api.spotify.com/v1/albums/5aKbiaSUuJPZ1uX7SUXcDx","id":"5aKbiaSUuJPZ1uX7SUXcDx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b5f7a810d9727370cce419df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b5f7a810d9727370cce419df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b5f7a810d9727370cce419df"}],"is_playable":true,"name":"Ze Komt Uit Amsterdam","release_date":"2025-06-12","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5aKbiaSUuJPZ1uX7SUXcDx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LcUpNlXFEleaLlelmkv2R"},"href":"https://api.spotify.com/v1/artists/4LcUpNlXFEleaLlelmkv2R","id":"4LcUpNlXFEleaLlelmkv2R","name":"Kris Kross Amsterdam","type":"artist","uri":"spotify:artist:4LcUpNlXFEleaLlelmkv2R"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5l2Xy4aUoJDRSpsYHyOumD"},"href":"https://api.spotify.com/v1/artists/5l2Xy4aUoJDRSpsYHyOumD","id":"5l2Xy4aUoJDRSpsYHyOumD","name":"Andr\u00e9 Hazes Jr.","type":"artist","uri":"spotify:artist:5l2Xy4aUoJDRSpsYHyOumD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7iBY1RLWDV5zX9NDNQxurm"},"href":"https://api.spotify.com/v1/artists/7iBY1RLWDV5zX9NDNQxurm","id":"7iBY1RLWDV5zX9NDNQxurm","name":"Tabitha","type":"artist","uri":"spotify:artist:7iBY1RLWDV5zX9NDNQxurm"}],"disc_number":1,"duration_ms":152727,"explicit":false,"external_ids":{"isrc":"NLS242500087"},"external_urls":{"spotify":"https://open.spotify.com/track/2xJIY9JQQdNzFVAumSXsIF"},"href":"https://api.spotify.com/v1/tracks/2xJIY9JQQdNzFVAumSXsIF","id":"2xJIY9JQQdNzFVAumSXsIF","is_local":false,"is_playable":true,"name":"Ze Komt Uit Amsterdam","track_number":1,"type":"track","uri":"spotify:track:2xJIY9JQQdNzFVAumSXsIF"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MvyMusqNikgVgkKHLc3pb"},"href":"https://api.spotify.com/v1/artists/5MvyMusqNikgVgkKHLc3pb","id":"5MvyMusqNikgVgkKHLc3pb","name":"Rene Froger","type":"artist","uri":"spotify:artist:5MvyMusqNikgVgkKHLc3pb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/1jX6gMEqq4bjLldidR0Pnk"},"href":"https://api.spotify.com/v1/albums/1jX6gMEqq4bjLldidR0Pnk","id":"1jX6gMEqq4bjLldidR0Pnk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738fe4cb0eb3f1ee38d745ef26"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028fe4cb0eb3f1ee38d745ef26"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518fe4cb0eb3f1ee38d745ef26"}],"is_playable":true,"name":"Amsterdam, Amsterdam","release_date":"2025-06-06","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1jX6gMEqq4bjLldidR0Pnk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5MvyMusqNikgVgkKHLc3pb"},"href":"https://api.spotify.com/v1/artists/5MvyMusqNikgVgkKHLc3pb","id":"5MvyMusqNikgVgkKHLc3pb","name":"Rene Froger","type":"artist","uri":"spotify:artist:5MvyMusqNikgVgkKHLc3pb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":148375,"explicit":false,"external_ids":{"isrc":"NLQ272500069"},"external_urls":{"spotify":"https://open.spotify.com/track/1FpAv3Krz2Qe2b5RP9PFMp"},"href":"https://api.spotify.com/v1/tracks/1FpAv3Krz2Qe2b5RP9PFMp","id":"1FpAv3Krz2Qe2b5RP9PFMp","is_local":false,"is_playable":true,"name":"Amsterdam, Amsterdam","track_number":1,"type":"track","uri":"spotify:track:1FpAv3Krz2Qe2b5RP9PFMp"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4sf0XtUsKwVtg6YK72Dx2C"},"href":"https://api.spotify.com/v1/artists/4sf0XtUsKwVtg6YK72Dx2C","id":"4sf0XtUsKwVtg6YK72Dx2C","name":"Steen","type":"artist","uri":"spotify:artist:4sf0XtUsKwVtg6YK72Dx2C"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0mJmP5PtashnU2L2BkBn28"},"href":"https://api.spotify.com/v1/artists/0mJmP5PtashnU2L2BkBn28","id":"0mJmP5PtashnU2L2BkBn28","name":"Spinal","type":"artist","uri":"spotify:artist:0mJmP5PtashnU2L2BkBn28"}],"external_urls":{"spotify":"https://open.spotify.com/album/7vFRuRZwFX14kfFhUgUcMO"},"href":"https://api.spotify.com/v1/albums/7vFRuRZwFX14kfFhUgUcMO","id":"7vFRuRZwFX14kfFhUgUcMO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273883771562d09651bb93e70bf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02883771562d09651bb93e70bf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851883771562d09651bb93e70bf"}],"is_playable":true,"name":"Kadaverrap","release_date":"2007-04-09","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:7vFRuRZwFX14kfFhUgUcMO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4sf0XtUsKwVtg6YK72Dx2C"},"href":"https://api.spotify.com/v1/artists/4sf0XtUsKwVtg6YK72Dx2C","id":"4sf0XtUsKwVtg6YK72Dx2C","name":"Steen","type":"artist","uri":"spotify:artist:4sf0XtUsKwVtg6YK72Dx2C"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0mJmP5PtashnU2L2BkBn28"},"href":"https://api.spotify.com/v1/artists/0mJmP5PtashnU2L2BkBn28","id":"0mJmP5PtashnU2L2BkBn28","name":"Spinal","type":"artist","uri":"spotify:artist:0mJmP5PtashnU2L2BkBn28"}],"disc_number":1,"duration_ms":264746,"explicit":true,"external_ids":{"isrc":"NLSR31100063"},"external_urls":{"spotify":"https://open.spotify.com/track/1Ylpok7SisyLxvkTmpwvPD"},"href":"https://api.spotify.com/v1/tracks/1Ylpok7SisyLxvkTmpwvPD","id":"1Ylpok7SisyLxvkTmpwvPD","is_local":false,"is_playable":true,"name":"Haat","track_number":4,"type":"track","uri":"spotify:track:1Ylpok7SisyLxvkTmpwvPD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/30WLe30YBfDFoIkJS0Tml9"},"href":"https://api.spotify.com/v1/artists/30WLe30YBfDFoIkJS0Tml9","id":"30WLe30YBfDFoIkJS0Tml9","name":"Ares","type":"artist","uri":"spotify:artist:30WLe30YBfDFoIkJS0Tml9"}],"external_urls":{"spotify":"https://open.spotify.com/album/5l48SLlgx8pZ3IlNFGgHF1"},"href":"https://api.spotify.com/v1/albums/5l48SLlgx8pZ3IlNFGgHF1","id":"5l48SLlgx8pZ3IlNFGgHF1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b163130290369b3e14cd05f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b163130290369b3e14cd05f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b163130290369b3e14cd05f5"}],"is_playable":true,"name":"Alice","release_date":"2018-09-14","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5l48SLlgx8pZ3IlNFGgHF1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/30WLe30YBfDFoIkJS0Tml9"},"href":"https://api.spotify.com/v1/artists/30WLe30YBfDFoIkJS0Tml9","id":"30WLe30YBfDFoIkJS0Tml9","name":"Ares","type":"artist","uri":"spotify:artist:30WLe30YBfDFoIkJS0Tml9"}],"disc_number":1,"duration_ms":176158,"explicit":true,"external_ids":{"isrc":"TCADU1845299"},"external_urls":{"spotify":"https://open.spotify.com/track/0pmYKHYiYfu772iiuLRGCq"},"href":"https://api.spotify.com/v1/tracks/0pmYKHYiYfu772iiuLRGCq","id":"0pmYKHYiYfu772iiuLRGCq","is_local":false,"is_playable":true,"name":"Alice","track_number":5,"type":"track","uri":"spotify:track:0pmYKHYiYfu772iiuLRGCq"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Liefs+Uit+Amsterdam+Lange+Frans&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Toen%20Ik%20Je%20Zag%20Nielson&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Toen%20Ik%20Je%20Zag%20Nielson&type=track","offset":0,"previous":null,"total":16,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5m5Fh8zrb0uHM85qwkIkVT"},"href":"https://api.spotify.com/v1/artists/5m5Fh8zrb0uHM85qwkIkVT","id":"5m5Fh8zrb0uHM85qwkIkVT","name":"Nielson","type":"artist","uri":"spotify:artist:5m5Fh8zrb0uHM85qwkIkVT"}],"external_urls":{"spotify":"https://open.spotify.com/album/1HWYzaevKQh0f5aIC2tlxe"},"href":"https://api.spotify.com/v1/albums/1HWYzaevKQh0f5aIC2tlxe","id":"1HWYzaevKQh0f5aIC2tlxe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27383cc4431dd0c40bc3c25ba07"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0283cc4431dd0c40bc3c25ba07"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485183cc4431dd0c40bc3c25ba07"}],"is_playable":true,"name":"Zo Van Ah Yeah","release_date":"2014-03-07","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:1HWYzaevKQh0f5aIC2tlxe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5m5Fh8zrb0uHM85qwkIkVT"},"href":"https://api.spotify.com/v1/artists/5m5Fh8zrb0uHM85qwkIkVT","id":"5m5Fh8zrb0uHM85qwkIkVT","name":"Nielson","type":"artist","uri":"spotify:artist:5m5Fh8zrb0uHM85qwkIkVT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/06eTdzI1FA6c2cPQAeVHY2"},"href":"https://api.spotify.com/v1/artists/06eTdzI1FA6c2cPQAeVHY2","id":"06eTdzI1FA6c2cPQAeVHY2","name":"Miss Montreal","type":"artist","uri":"spotify:artist:06eTdzI1FA6c2cPQAeVHY2"}],"disc_number":1,"duration_ms":172080,"explicit":false,"external_ids":{"isrc":"NLG901300012"},"external_urls":{"spotify":"https://open.spotify.com/track/55KrYr6pJ5880OIY09potb"},"href":"https://api.spotify.com/v1/tracks/55KrYr6pJ5880OIY09potb","id":"55KrYr6pJ5880OIY09potb","is_local":false,"is_playable":true,"name":"Hoe","track_number":11,"type":"track","uri":"spotify:track:55KrYr6pJ5880OIY09potb"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/15E5Lo5HxDSnNhUac2LUKo"},"href":"https://api.spotify.com/v1/artists/15E5Lo5HxDSnNhUac2LUKo","id":"15E5Lo5HxDSnNhUac2LUKo","name":"Hero","type":"artist","uri":"spotify:artist:15E5Lo5HxDSnNhUac2LUKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/6iCv06DkaZBWf9roR0beI8"},"href":"https://api.spotify.com/v1/albums/6iCv06DkaZBWf9roR0beI8","id":"6iCv06DkaZBWf9roR0beI8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739ebcd20153ba18a2eea9d42f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029ebcd20153ba18a2eea9d42f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519ebcd20153ba18a2eea9d42f"}],"is_playable":true,"name":"Jam","release_date":"1998-01-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:6iCv06DkaZBWf9roR0beI8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/15E5Lo5HxDSnNhUac2LUKo"},"href":"https://api.spotify.com/v1/artists/15E5Lo5HxDSnNhUac2LUKo","id":"15E5Lo5HxDSnNhUac2LUKo","name":"Hero","type":"artist","uri":"spotify:artist:15E5Lo5HxDSnNhUac2LUKo"}],"disc_number":1,"duration_ms":205093,"explicit":false,"external_ids":{"isrc":"NLA319700007"},"external_urls":{"spotify":"https://open.spotify.com/track/0PynPGqWuKWpxoAKZvRA0t"},"href":"https://api.spotify.com/v1/tracks/0PynPGqWuKWpxoAKZvRA0t","id":"0PynPGqWuKWpxoAKZvRA0t","is_local":false,"is_playable":true,"name":"Toen Ik Je Zag - Single Version","track_number":4,"type":"track","uri":"spotify:track:0PynPGqWuKWpxoAKZvRA0t"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5m5Fh8zrb0uHM85qwkIkVT"},"href":"https://api.spotify.com/v1/artists/5m5Fh8zrb0uHM85qwkIkVT","id":"5m5Fh8zrb0uHM85qwkIkVT","name":"Nielson","type":"artist","uri":"spotify:artist:5m5Fh8zrb0uHM85qwkIkVT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/06eTdzI1FA6c2cPQAeVHY2"},"href":"https://api.spotify.com/v1/artists/06eTdzI1FA6c2cPQAeVHY2","id":"06eTdzI1FA6c2cPQAeVHY2","name":"Miss Montreal","type":"artist","uri":"spotify:artist:06eTdzI1FA6c2cPQAeVHY2"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ZdxQ7He0LE8J2ouNcYpd2"},"href":"https://api.spotify.com/v1/albums/4ZdxQ7He0LE8J2ouNcYpd2","id":"4ZdxQ7He0LE8J2ouNcYpd2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27312c9aee016a417113907637d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0212c9aee016a417113907637d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485112c9aee016a417113907637d"}],"is_playable":true,"name":"Hoe","release_date":"2013-11-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4ZdxQ7He0LE8J2ouNcYpd2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5m5Fh8zrb0uHM85qwkIkVT"},"href":"https://api.spotify.com/v1/artists/5m5Fh8zrb0uHM85qwkIkVT","id":"5m5Fh8zrb0uHM85qwkIkVT","name":"Nielson","type":"artist","uri":"spotify:artist:5m5Fh8zrb0uHM85qwkIkVT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/06eTdzI1FA6c2cPQAeVHY2"},"href":"https://api.spotify.com/v1/artists/06eTdzI1FA6c2cPQAeVHY2","id":"06eTdzI1FA6c2cPQAeVHY2","name":"Miss Montreal","type":"artist","uri":"spotify:artist:06eTdzI1FA6c2cPQAeVHY2"}],"disc_number":1,"duration_ms":169288,"explicit":false,"external_ids":{"isrc":"NLC282400430"},"external_urls":{"spotify":"https://open.spotify.com/track/0i4b99kb0hqaHALhoq4U3k"},"href":"https://api.spotify.com/v1/tracks/0i4b99kb0hqaHALhoq4U3k","id":"0i4b99kb0hqaHALhoq4U3k","is_local":false,"is_playable":true,"name":"Hoe","track_number":1,"type":"track","uri":"spotify:track:0i4b99kb0hqaHALhoq4U3k"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/15E5Lo5HxDSnNhUac2LUKo"},"href":"https://api.spotify.com/v1/artists/15E5Lo5HxDSnNhUac2LUKo","id":"15E5Lo5HxDSnNhUac2LUKo","name":"Hero","type":"artist","uri":"spotify:artist:15E5Lo5HxDSnNhUac2LUKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/3dIaI0iPa9ja1dXCyBPHoL"},"href":"https://api.spotify.com/v1/albums/3dIaI0iPa9ja1dXCyBPHoL","id":"3dIaI0iPa9ja1dXCyBPHoL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27368cc7a20035252139191155a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0268cc7a20035252139191155a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485168cc7a20035252139191155a"}],"is_playable":true,"name":"Toen Ik Je Zag","release_date":"1997-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:3dIaI0iPa9ja1dXCyBPHoL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/15E5Lo5HxDSnNhUac2LUKo"},"href":"https://api.spotify.com/v1/artists/15E5Lo5HxDSnNhUac2LUKo","id":"15E5Lo5HxDSnNhUac2LUKo","name":"Hero","type":"artist","uri":"spotify:artist:15E5Lo5HxDSnNhUac2LUKo"}],"disc_number":1,"duration_ms":201733,"explicit":false,"external_ids":{"isrc":"NLA319700007"},"external_urls":{"spotify":"https://open.spotify.com/track/6Ff8YmQ1Gc9d03q9JYe7sT"},"href":"https://api.spotify.com/v1/tracks/6Ff8YmQ1Gc9d03q9JYe7sT","id":"6Ff8YmQ1Gc9d03q9JYe7sT","is_local":false,"is_playable":true,"name":"Toen Ik Je Zag","track_number":1,"type":"track","uri":"spotify:track:6Ff8YmQ1Gc9d03q9JYe7sT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"external_urls":{"spotify":"https://open.spotify.com/album/1AiSzH7IpBmv9O9Y6oObXc"},"href":"https://api.spotify.com/v1/albums/1AiSzH7IpBmv9O9Y6oObXc","id":"1AiSzH7IpBmv9O9Y6oObXc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b66e39036b107d8397cc6a8d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b66e39036b107d8397cc6a8d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b66e39036b107d8397cc6a8d"}],"is_playable":true,"name":"Iemand Van Vroeger","release_date":"2023-09-22","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:1AiSzH7IpBmv9O9Y6oObXc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77IW5ZK1smDQYYKDCQugXh"},"href":"https://api.spotify.com/v1/artists/77IW5ZK1smDQYYKDCQugXh","id":"77IW5ZK1smDQYYKDCQugXh","name":"Suzan & Freek","type":"artist","uri":"spotify:artist:77IW5ZK1smDQYYKDCQugXh"}],"disc_number":1,"duration_ms":204923,"explicit":false,"external_ids":{"isrc":"NL1CK2300007"},"external_urls":{"spotify":"https://open.spotify.com/track/1b4EY1iGSNPRIW2fulM8Lj"},"href":"https://api.spotify.com/v1/tracks/1b4EY1iGSNPRIW2fulM8Lj","id":"1b4EY1iGSNPRIW2fulM8Lj","is_local":false,"is_playable":true,"name":"De Helft Van Mij","track_number":2,"type":"track","uri":"spotify:track:1b4EY1iGSNPRIW2fulM8Lj"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5vmwWgrlwCfHm1P0vdDFbU"},"href":"https://api.spotify.com/v1/artists/5vmwWgrlwCfHm1P0vdDFbU","id":"5vmwWgrlwCfHm1P0vdDFbU","name":"Maan","type":"artist","uri":"spotify:artist:5vmwWgrlwCfHm1P0vdDFbU"}],"external_urls":{"spotify":"https://open.spotify.com/album/2DkSiYMFLEXL3WK1m4hqR7"},"href":"https://api.spotify.com/v1/albums/2DkSiYMFLEXL3WK1m4hqR7","id":"2DkSiYMFLEXL3WK1m4hqR7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27382fadeb6f61b7b785304abf1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0282fadeb6f61b7b785304abf1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485182fadeb6f61b7b785304abf1"}],"is_playable":true,"name":"Leven","release_date":"2022-11-04","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2DkSiYMFLEXL3WK1m4hqR7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5vmwWgrlwCfHm1P0vdDFbU"},"href":"https://api.spotify.com/v1/artists/5vmwWgrlwCfHm1P0vdDFbU","id":"5vmwWgrlwCfHm1P0vdDFbU","name":"Maan","type":"artist","uri":"spotify:artist:5vmwWgrlwCfHm1P0vdDFbU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1u7uShzlA1tXJeox3jMFPq"},"href":"https://api.spotify.com/v1/artists/1u7uShzlA1tXJeox3jMFPq","id":"1u7uShzlA1tXJeox3jMFPq","name":"De Jeugd Van Tegenwoordig","type":"artist","uri":"spotify:artist:1u7uShzlA1tXJeox3jMFPq"}],"disc_number":1,"duration_ms":188486,"explicit":false,"external_ids":{"isrc":"NLZ292200077"},"external_urls":{"spotify":"https://open.spotify.com/track/0NrNX1WgfwTbJDYNdMCLYH"},"href":"https://api.spotify.com/v1/tracks/0NrNX1WgfwTbJDYNdMCLYH","id":"0NrNX1WgfwTbJDYNdMCLYH","is_local":false,"is_playable":true,"name":"Naar De Maan","track_number":11,"type":"track","uri":"spotify:track:0NrNX1WgfwTbJDYNdMCLYH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7B8OrK1A5meEjyWiojf5ee"},"href":"https://api.spotify.com/v1/albums/7B8OrK1A5meEjyWiojf5ee","id":"7B8OrK1A5meEjyWiojf5ee","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27373c6db7cbd8ad1cd47d1b954"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0273c6db7cbd8ad1cd47d1b954"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485173c6db7cbd8ad1cd47d1b954"}],"is_playable":true,"name":"De Regenboog Serie: De Grootste Hits - De Vergeten Piraten Hits, Vol. 2","release_date":"2010-07-09","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:7B8OrK1A5meEjyWiojf5ee"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1X9X5hVCOmcKF65TvjhPe3"},"href":"https://api.spotify.com/v1/artists/1X9X5hVCOmcKF65TvjhPe3","id":"1X9X5hVCOmcKF65TvjhPe3","name":"Silvertop","type":"artist","uri":"spotify:artist:1X9X5hVCOmcKF65TvjhPe3"}],"disc_number":1,"duration_ms":161202,"explicit":false,"external_ids":{"isrc":"NLA340927734"},"external_urls":{"spotify":"https://open.spotify.com/track/65mECpeub33Aeyh6M9YUfQ"},"href":"https://api.spotify.com/v1/tracks/65mECpeub33Aeyh6M9YUfQ","id":"65mECpeub33Aeyh6M9YUfQ","is_local":false,"is_playable":true,"name":"Toen Ik Jou Zag","track_number":4,"type":"track","uri":"spotify:track:65mECpeub33Aeyh6M9YUfQ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/06eTdzI1FA6c2cPQAeVHY2"},"href":"https://api.spotify.com/v1/artists/06eTdzI1FA6c2cPQAeVHY2","id":"06eTdzI1FA6c2cPQAeVHY2","name":"Miss Montreal","type":"artist","uri":"spotify:artist:06eTdzI1FA6c2cPQAeVHY2"}],"external_urls":{"spotify":"https://open.spotify.com/album/2prXTVSfudeaj7v8MFPCJa"},"href":"https://api.spotify.com/v1/albums/2prXTVSfudeaj7v8MFPCJa","id":"2prXTVSfudeaj7v8MFPCJa","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ddf86f52140da7820717c800"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ddf86f52140da7820717c800"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ddf86f52140da7820717c800"}],"is_playable":true,"name":"The Singles Collection (Deluxe Version)","release_date":"2015-02-13","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:2prXTVSfudeaj7v8MFPCJa"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5m5Fh8zrb0uHM85qwkIkVT"},"href":"https://api.spotify.com/v1/artists/5m5Fh8zrb0uHM85qwkIkVT","id":"5m5Fh8zrb0uHM85qwkIkVT","name":"Nielson","type":"artist","uri":"spotify:artist:5m5Fh8zrb0uHM85qwkIkVT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/06eTdzI1FA6c2cPQAeVHY2"},"href":"https://api.spotify.com/v1/artists/06eTdzI1FA6c2cPQAeVHY2","id":"06eTdzI1FA6c2cPQAeVHY2","name":"Miss Montreal","type":"artist","uri":"spotify:artist:06eTdzI1FA6c2cPQAeVHY2"}],"disc_number":1,"duration_ms":171080,"explicit":false,"external_ids":{"isrc":"NLG901300012"},"external_urls":{"spotify":"https://open.spotify.com/track/3TLVHtesnk0puSAdiCjg79"},"href":"https://api.spotify.com/v1/tracks/3TLVHtesnk0puSAdiCjg79","id":"3TLVHtesnk0puSAdiCjg79","is_local":false,"is_playable":true,"name":"Hoe","track_number":11,"type":"track","uri":"spotify:track:3TLVHtesnk0puSAdiCjg79"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Np3tBLhkFCcJPun4KhrDQ"},"href":"https://api.spotify.com/v1/artists/2Np3tBLhkFCcJPun4KhrDQ","id":"2Np3tBLhkFCcJPun4KhrDQ","name":"Dio","type":"artist","uri":"spotify:artist:2Np3tBLhkFCcJPun4KhrDQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/78zhc4bB3FYASBaDlilWC4"},"href":"https://api.spotify.com/v1/albums/78zhc4bB3FYASBaDlilWC4","id":"78zhc4bB3FYASBaDlilWC4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733294ab211444f42b6c4b7dfa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023294ab211444f42b6c4b7dfa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513294ab211444f42b6c4b7dfa"}],"is_playable":true,"name":"de vluGtlaan","release_date":"2025-02-28","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:78zhc4bB3FYASBaDlilWC4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Np3tBLhkFCcJPun4KhrDQ"},"href":"https://api.spotify.com/v1/artists/2Np3tBLhkFCcJPun4KhrDQ","id":"2Np3tBLhkFCcJPun4KhrDQ","name":"Dio","type":"artist","uri":"spotify:artist:2Np3tBLhkFCcJPun4KhrDQ"}],"disc_number":1,"duration_ms":165026,"explicit":true,"external_ids":{"isrc":"NL5B62400003"},"external_urls":{"spotify":"https://open.spotify.com/track/4lZts0FFxJ8l8p5EcFVRi3"},"href":"https://api.spotify.com/v1/tracks/4lZts0FFxJ8l8p5EcFVRi3","id":"4lZts0FFxJ8l8p5EcFVRi3","is_local":false,"is_playable":true,"name":"HOSSELAAR","track_number":4,"type":"track","uri":"spotify:track:4lZts0FFxJ8l8p5EcFVRi3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FWWBkIJD4tvlDzB4O8XT7"},"href":"https://api.spotify.com/v1/artists/0FWWBkIJD4tvlDzB4O8XT7","id":"0FWWBkIJD4tvlDzB4O8XT7","name":"Kempi","type":"artist","uri":"spotify:artist:0FWWBkIJD4tvlDzB4O8XT7"}],"external_urls":{"spotify":"https://open.spotify.com/album/5XtKjZcO6XO1OiCuONGyJS"},"href":"https://api.spotify.com/v1/albums/5XtKjZcO6XO1OiCuONGyJS","id":"5XtKjZcO6XO1OiCuONGyJS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273edafefa0834c345a6997c253"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02edafefa0834c345a6997c253"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851edafefa0834c345a6997c253"}],"is_playable":true,"name":"Mixtape 2, Rap 'N Borie","release_date":"2007-01-01","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:5XtKjZcO6XO1OiCuONGyJS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0FWWBkIJD4tvlDzB4O8XT7"},"href":"https://api.spotify.com/v1/artists/0FWWBkIJD4tvlDzB4O8XT7","id":"0FWWBkIJD4tvlDzB4O8XT7","name":"Kempi","type":"artist","uri":"spotify:artist:0FWWBkIJD4tvlDzB4O8XT7"}],"disc_number":1,"duration_ms":262533,"explicit":true,"external_ids":{"isrc":"NLG660700040"},"external_urls":{"spotify":"https://open.spotify.com/track/68gkB9GBHeTotKGqtPMGUX"},"href":"https://api.spotify.com/v1/tracks/68gkB9GBHeTotKGqtPMGUX","id":"68gkB9GBHeTotKGqtPMGUX","is_local":false,"is_playable":true,"name":"Zoveel Stress","track_number":20,"type":"track","uri":"spotify:track:68gkB9GBHeTotKGqtPMGUX"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1Ub2VuJTIwSWslMjBKZSUyMFphZyUyME5pZWxzb24mdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MTAmbGltaXQ9MTAmcXVlcnk9VG9lbiUyMElrJTIwSmUlMjBaYWclMjBOaWVsc29uJnR5cGU9dHJhY2siLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MTYsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVtNUZoOHpyYjB1SE04NXF3a0lrVlQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNW01Rmg4enJiMHVITTg1cXdrSWtWVCIsImlkIjoiNW01Rmg4enJiMHVITTg1cXdrSWtWVCIsIm5hbWUiOiJOaWVsc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVtNUZoOHpyYjB1SE04NXF3a0lrVlQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xSFdZemFldktRaDBmNWFJQzJ0bHhlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUhXWXphZXZLUWgwZjVhSUMydGx4ZSIsImlkIjoiMUhXWXphZXZLUWgwZjVhSUMydGx4ZSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4M2NjNDQzMWRkMGM0MGJjM2MyNWJhMDcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODNjYzQ0MzFkZDBjNDBiYzNjMjViYTA3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4M2NjNDQzMWRkMGM0MGJjM2MyNWJhMDcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWm8gVmFuIEFoIFllYWgiLCJyZWxlYXNlX2RhdGUiOiIyMDE0LTAzLTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MUhXWXphZXZLUWgwZjVhSUMydGx4ZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVtNUZoOHpyYjB1SE04NXF3a0lrVlQifSwiaHJlZiI6Imh0dHBzOi8vYQ==", + "cGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81bTVGaDh6cmIwdUhNODVxd2tJa1ZUIiwiaWQiOiI1bTVGaDh6cmIwdUhNODVxd2tJa1ZUIiwibmFtZSI6Ik5pZWxzb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NW01Rmg4enJiMHVITTg1cXdrSWtWVCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNmVUZHpJMUZBNmMyY1BRQWVWSFkyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA2ZVRkekkxRkE2YzJjUFFBZVZIWTIiLCJpZCI6IjA2ZVRkekkxRkE2YzJjUFFBZVZIWTIiLCJuYW1lIjoiTWlzcyBNb250cmVhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNmVUZHpJMUZBNmMyY1BRQWVWSFkyIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3MjA4MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzkwMTMwMDAxMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNTVLcllyNnBKNTg4ME9JWTA5cG90YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzU1S3JZcjZwSjU4ODBPSVkwOXBvdGIiLCJpZCI6IjU1S3JZcjZwSjU4ODBPSVkwOXBvdGIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9lIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1NUtyWXI2cEo1ODgwT0lZMDlwb3RiIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzE1RTVMbzVIeERTbk5oVWFjMkxVS28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTVFNUxvNUh4RFNuTmhVYWMyTFVLbyIsImlkIjoiMTVFNUxvNUh4RFNuTmhVYWMyTFVLbyIsIm5hbWUiOiJIZXJvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE1RTVMbzVIeERTbk5oVWFjMkxVS28ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82aUN2MDZEa2FaQldmOXJvUjBiZUk4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNmlDdjA2RGthWkJXZjlyb1IwYmVJOCIsImlkIjoiNmlDdjA2RGthWkJXZjlyb1IwYmVJOCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLg==", + "Y28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzllYmNkMjAxNTNiYTE4YTJlZWE5ZDQyZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5ZWJjZDIwMTUzYmExOGEyZWVhOWQ0MmYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTllYmNkMjAxNTNiYTE4YTJlZWE5ZDQyZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJKYW0iLCJyZWxlYXNlX2RhdGUiOiIxOTk4LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NmlDdjA2RGthWkJXZjlyb1IwYmVJOCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzE1RTVMbzVIeERTbk5oVWFjMkxVS28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTVFNUxvNUh4RFNuTmhVYWMyTFVLbyIsImlkIjoiMTVFNUxvNUh4RFNuTmhVYWMyTFVLbyIsIm5hbWUiOiJIZXJvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE1RTVMbzVIeERTbk5oVWFjMkxVS28ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA1MDkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxBMzE5NzAwMDA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wUHluUEdxV3VLV3B4b0FLWnZSQTB0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMFB5blBHcVd1S1dweG9BS1p2UkEwdCIsImlkIjoiMFB5blBHcVd1S1dweG9BS1p2UkEwdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUb2VuIElrIEplIFphZyAtIFNpbmdsZSBWZXJzaW9uIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBQeW5QR3FXdUtXcHhvQUtadlJBMHQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVtNUZoOHpyYjB1SE04NXF3a0lrVlQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNW01Rmg4enJiMHVITTg1cXdrSWtWVCIsImlkIjoiNW01Rmg4enJiMHVITTg1cXdrSWtWVCIsIm5hbWUiOiJOaWVsc29uIiwidHlwZSI6ImFydGlzdA==", + "IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NW01Rmg4enJiMHVITTg1cXdrSWtWVCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNmVUZHpJMUZBNmMyY1BRQWVWSFkyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA2ZVRkekkxRkE2YzJjUFFBZVZIWTIiLCJpZCI6IjA2ZVRkekkxRkE2YzJjUFFBZVZIWTIiLCJuYW1lIjoiTWlzcyBNb250cmVhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNmVUZHpJMUZBNmMyY1BRQWVWSFkyIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFpkeFE3SGUwTEU4SjJvdU5jWXBkMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRaZHhRN0hlMExFOEoyb3VOY1lwZDIiLCJpZCI6IjRaZHhRN0hlMExFOEoyb3VOY1lwZDIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMTJjOWFlZTAxNmE0MTcxMTM5MDc2MzdkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjEyYzlhZWUwMTZhNDE3MTEzOTA3NjM3ZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTJjOWFlZTAxNmE0MTcxMTM5MDc2MzdkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhvZSIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMTEtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRaZHhRN0hlMExFOEoyb3VOY1lwZDIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81bTVGaDh6cmIwdUhNODVxd2tJa1ZUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVtNUZoOHpyYjB1SE04NXF3a0lrVlQiLCJpZCI6IjVtNUZoOHpyYjB1SE04NXF3a0lrVlQiLCJuYW1lIjoiTmllbHNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1bTVGaDh6cmIwdUhNODVxd2tJa1ZUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA2ZVRkekkxRkE2YzJjUFFBZVZIWTIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdA==", + "cy8wNmVUZHpJMUZBNmMyY1BRQWVWSFkyIiwiaWQiOiIwNmVUZHpJMUZBNmMyY1BRQWVWSFkyIiwibmFtZSI6Ik1pc3MgTW9udHJlYWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDZlVGR6STFGQTZjMmNQUUFlVkhZMiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjkyODgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEMyODI0MDA0MzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBpNGI5OWtiMGhxYUhBTGhvcTRVM2sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8waTRiOTlrYjBocWFIQUxob3E0VTNrIiwiaWQiOiIwaTRiOTlrYjBocWFIQUxob3E0VTNrIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhvZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowaTRiOTlrYjBocWFIQUxob3E0VTNrIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xNUU1TG81SHhEU25OaFVhYzJMVUtvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzE1RTVMbzVIeERTbk5oVWFjMkxVS28iLCJpZCI6IjE1RTVMbzVIeERTbk5oVWFjMkxVS28iLCJuYW1lIjoiSGVybyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxNUU1TG81SHhEU25OaFVhYzJMVUtvIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2RJYUkwaVBhOWphMWRYQ3lCUEhvTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNkSWFJMGlQYTlqYTFkWEN5QlBIb0wiLCJpZCI6IjNkSWFJMGlQYTlqYTFkWEN5QlBIb0wiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNjhjYzdhMjAwMzUyNTIxMzkxOTExNTVhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjY4Y2M3YTIwMDM1MjUyMTM5MTkxMTU1YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjhjYzdhMjAwMzUyNTIxMzkxOTExNTVhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvZW4gSWsgSmUgWmFnIg==", + "LCJyZWxlYXNlX2RhdGUiOiIxOTk3LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozZElhSTBpUGE5amExZFhDeUJQSG9MIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTVFNUxvNUh4RFNuTmhVYWMyTFVLbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xNUU1TG81SHhEU25OaFVhYzJMVUtvIiwiaWQiOiIxNUU1TG81SHhEU25OaFVhYzJMVUtvIiwibmFtZSI6Ikhlcm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTVFNUxvNUh4RFNuTmhVYWMyTFVLbyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDE3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEEzMTk3MDAwMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZGZjhZbVExR2M5ZDAzcTlKWWU3c1QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82RmY4WW1RMUdjOWQwM3E5SlllN3NUIiwiaWQiOiI2RmY4WW1RMUdjOWQwM3E5SlllN3NUIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvZW4gSWsgSmUgWmFnIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZGZjhZbVExR2M5ZDAzcTlKWWU3c1QifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdJVzVaSzFzbURRWVlLRENRdWdYaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIiwiaWQiOiI3N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIiwibmFtZSI6IlN1emFuICYgRnJlZWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzdJVzVaSzFzbURRWVlLRENRdWdYaCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFBaVN6SDdJcEJtdjlPOVk2b09iWGMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xQWlTekg3SXBCbXY5TzlZNm9PYlhjIiwiaWQiOiIxQWlTekg3SXBCbXY5TzlZNm9PYlhjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZw==", + "ZS9hYjY3NjE2ZDAwMDBiMjczYjY2ZTM5MDM2YjEwN2Q4Mzk3Y2M2YThkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmI2NmUzOTAzNmIxMDdkODM5N2NjNmE4ZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjY2ZTM5MDM2YjEwN2Q4Mzk3Y2M2YThkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkllbWFuZCBWYW4gVnJvZWdlciIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDktMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxQWlTekg3SXBCbXY5TzlZNm9PYlhjIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdJVzVaSzFzbURRWVlLRENRdWdYaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIiwiaWQiOiI3N0lXNVpLMXNtRFFZWUtEQ1F1Z1hoIiwibmFtZSI6IlN1emFuICYgRnJlZWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzdJVzVaSzFzbURRWVlLRENRdWdYaCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDQ5MjMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTDFDSzIzMDAwMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFiNEVZMWlHU05QUklXMmZ1bE04TGoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xYjRFWTFpR1NOUFJJVzJmdWxNOExqIiwiaWQiOiIxYjRFWTFpR1NOUFJJVzJmdWxNOExqIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlIEhlbGZ0IFZhbiBNaWoiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MWI0RVkxaUdTTlBSSVcyZnVsTThMaiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81dm13V2dybHdDZkhtMVAwdmRERmJVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV2bXdXZ3Jsd0NmSG0xUDB2ZERGYlUiLCJpZCI6IjV2bXdXZ3Jsd0NmSG0xUDB2ZERGYlUiLCJuYW1lIjoiTWFhbiIsInR5cGUiOiJhcnRpc3QiLA==", + "InVyaSI6InNwb3RpZnk6YXJ0aXN0OjV2bXdXZ3Jsd0NmSG0xUDB2ZERGYlUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yRGtTaVlNRkxFWEwzV0sxbTRocVI3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMkRrU2lZTUZMRVhMM1dLMW00aHFSNyIsImlkIjoiMkRrU2lZTUZMRVhMM1dLMW00aHFSNyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4MmZhZGViNmY2MWI3Yjc4NTMwNGFiZjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODJmYWRlYjZmNjFiN2I3ODUzMDRhYmYxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4MmZhZGViNmY2MWI3Yjc4NTMwNGFiZjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGV2ZW4iLCJyZWxlYXNlX2RhdGUiOiIyMDIyLTExLTA0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MkRrU2lZTUZMRVhMM1dLMW00aHFSNyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV2bXdXZ3Jsd0NmSG0xUDB2ZERGYlUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXZtd1dncmx3Q2ZIbTFQMHZkREZiVSIsImlkIjoiNXZtd1dncmx3Q2ZIbTFQMHZkREZiVSIsIm5hbWUiOiJNYWFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV2bXdXZ3Jsd0NmSG0xUDB2ZERGYlUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXU3dVNoemxBMXRYSmVveDNqTUZQcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xdTd1U2h6bEExdFhKZW94M2pNRlBxIiwiaWQiOiIxdTd1U2h6bEExdFhKZW94M2pNRlBxIiwibmFtZSI6IkRlIEpldWdkIFZhbiBUZWdlbndvb3JkaWciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXU3dVNoemxBMXRYSmVveDNqTUZQcSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODg0ODYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFoyOTIyMDAwNzcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aQ==", + "ZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svME5yTlgxV2dmd1RiSkRZTmRNQ0xZSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBOck5YMVdnZndUYkpEWU5kTUNMWUgiLCJpZCI6IjBOck5YMVdnZndUYkpEWU5kTUNMWUgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmFhciBEZSBNYWFuIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowTnJOWDFXZ2Z3VGJKRFlOZE1DTFlIIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdCOE9ySzFBNW1lRWp5V2lvamY1ZWUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83QjhPcksxQTVtZUVqeVdpb2pmNWVlIiwiaWQiOiI3QjhPcksxQTVtZUVqeVdpb2pmNWVlIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzczYzZkYjdjYmQ4YWQxY2Q0N2QxYjk1NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3M2M2ZGI3Y2JkOGFkMWNkNDdkMWI5NTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTczYzZkYjdjYmQ4YWQxY2Q0N2QxYjk1NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZSBSZWdlbmJvb2cgU2VyaWU6IERlIEdyb290c3RlIEhpdHMgLSBEZSBWZXJnZXRlbiBQaXJhdGVuIEhpdHMsIFZvbC4gMiIsInJlbGVhc2VfZGF0ZSI6IjIwMTAtMDctMDkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3QjhPcksxQTVtZUVqeVdpb2pmNWVlIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeQ==", + "IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xWDlYNWhWQ09tY0tGNjVUdmpoUGUzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFYOVg1aFZDT21jS0Y2NVR2amhQZTMiLCJpZCI6IjFYOVg1aFZDT21jS0Y2NVR2amhQZTMiLCJuYW1lIjoiU2lsdmVydG9wIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFYOVg1aFZDT21jS0Y2NVR2amhQZTMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTYxMjAyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxBMzQwOTI3NzM0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82NW1FQ3BldWIzM0FleWg2TTlZVWZRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNjVtRUNwZXViMzNBZXloNk05WVVmUSIsImlkIjoiNjVtRUNwZXViMzNBZXloNk05WVVmUSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUb2VuIElrIEpvdSBaYWciLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NjVtRUNwZXViMzNBZXloNk05WVVmUSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNmVUZHpJMUZBNmMyY1BRQWVWSFkyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA2ZVRkekkxRkE2YzJjUFFBZVZIWTIiLCJpZCI6IjA2ZVRkekkxRkE2YzJjUFFBZVZIWTIiLCJuYW1lIjoiTWlzcyBNb250cmVhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNmVUZHpJMUZBNmMyY1BRQWVWSFkyIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMnByWFRWU2Z1ZGVhajd2OE1GUENKYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJwclhUVlNmdWRlYWo3djhNRlBDSmEiLCJpZCI6IjJwclhUVlNmdWRlYWo3djhNRlBDSmEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZGRmODZmNTIxNDBkYTc4MjA3MTdjODAwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmRkZjg2ZjUyMTQwZGE3ODIwNzE3YzgwMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdA==", + "aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkZGY4NmY1MjE0MGRhNzgyMDcxN2M4MDAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIFNpbmdsZXMgQ29sbGVjdGlvbiAoRGVsdXhlIFZlcnNpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAxNS0wMi0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJwclhUVlNmdWRlYWo3djhNRlBDSmEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81bTVGaDh6cmIwdUhNODVxd2tJa1ZUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVtNUZoOHpyYjB1SE04NXF3a0lrVlQiLCJpZCI6IjVtNUZoOHpyYjB1SE04NXF3a0lrVlQiLCJuYW1lIjoiTmllbHNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1bTVGaDh6cmIwdUhNODVxd2tJa1ZUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA2ZVRkekkxRkE2YzJjUFFBZVZIWTIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDZlVGR6STFGQTZjMmNQUUFlVkhZMiIsImlkIjoiMDZlVGR6STFGQTZjMmNQUUFlVkhZMiIsIm5hbWUiOiJNaXNzIE1vbnRyZWFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA2ZVRkekkxRkE2YzJjUFFBZVZIWTIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTcxMDgwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHOTAxMzAwMDEyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zVExWSHRlc25rMHB1U0FkaUNqZzc5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM1RMVkh0ZXNuazBwdVNBZGlDamc3OSIsImlkIjoiM1RMVkh0ZXNuazBwdVNBZGlDamc3OSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb2UiLCJ0cmFja19udW1iZXIiOjExLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNUTFZIdGVzbmswcHVTQWRpQ2pnNzkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk5wM3RCTGhrRkNjSlB1bjRLaHJEUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcA==", + "aS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJOcDN0Qkxoa0ZDY0pQdW40S2hyRFEiLCJpZCI6IjJOcDN0Qkxoa0ZDY0pQdW40S2hyRFEiLCJuYW1lIjoiRGlvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJOcDN0Qkxoa0ZDY0pQdW40S2hyRFEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83OHpoYzRiQjNGWUFTQmFEbGlsV0M0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzh6aGM0YkIzRllBU0JhRGxpbFdDNCIsImlkIjoiNzh6aGM0YkIzRllBU0JhRGxpbFdDNCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzMjk0YWIyMTE0NDRmNDJiNmM0YjdkZmEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzI5NGFiMjExNDQ0ZjQyYjZjNGI3ZGZhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzMjk0YWIyMTE0NDRmNDJiNmM0YjdkZmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiZGUgdmx1R3RsYWFuIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMi0yOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc4emhjNGJCM0ZZQVNCYURsaWxXQzQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTnAzdEJMaGtGQ2NKUHVuNEtockRRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJOcDN0Qkxoa0ZDY0pQdW40S2hyRFEiLCJpZCI6IjJOcDN0Qkxoa0ZDY0pQdW40S2hyRFEiLCJuYW1lIjoiRGlvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJOcDN0Qkxoa0ZDY0pQdW40S2hyRFEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTY1MDI2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTDVCNjI0MDAwMDMifSwiZXh0ZXJuYWxf", + "dXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRsWnRzMEZGeEo4bDhwNUVjRlZSaTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80bFp0czBGRnhKOGw4cDVFY0ZWUmkzIiwiaWQiOiI0bFp0czBGRnhKOGw4cDVFY0ZWUmkzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhPU1NFTEFBUiIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0bFp0czBGRnhKOGw4cDVFY0ZWUmkzIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBGV1dCa0lKRDR0dmxEekI0TzhYVDcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEZXV0JrSUpENHR2bER6QjRPOFhUNyIsImlkIjoiMEZXV0JrSUpENHR2bER6QjRPOFhUNyIsIm5hbWUiOiJLZW1waSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowRldXQmtJSkQ0dHZsRHpCNE84WFQ3In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVh0S2paY082WE8xT2lDdU9OR3lKUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVYdEtqWmNPNlhPMU9pQ3VPTkd5SlMiLCJpZCI6IjVYdEtqWmNPNlhPMU9pQ3VPTkd5SlMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZWRhZmVmYTA4MzRjMzQ1YTY5OTdjMjUzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmVkYWZlZmEwODM0YzM0NWE2OTk3YzI1MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZWRhZmVmYTA4MzRjMzQ1YTY5OTdjMjUzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1peHRhcGUgMiwgUmFwICdOIEJvcmllIiwicmVsZWFzZV9kYXRlIjoiMjAwNy0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVYdEtqWmNPNlhPMU9pQ3VPTkd5SlMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wRldXQmtJSkQ0dHZsRHpCNE84WA==", + "VDcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEZXV0JrSUpENHR2bER6QjRPOFhUNyIsImlkIjoiMEZXV0JrSUpENHR2bER6QjRPOFhUNyIsIm5hbWUiOiJLZW1waSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowRldXQmtJSkQ0dHZsRHpCNE84WFQ3In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2MjUzMywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHNjYwNzAwMDQwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82OGdrQjlHQkhlVG90S0dxdFBNR1VYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNjhna0I5R0JIZVRvdEtHcXRQTUdVWCIsImlkIjoiNjhna0I5R0JIZVRvdEtHcXRQTUdVWCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJab3ZlZWwgU3RyZXNzIiwidHJhY2tfbnVtYmVyIjoyMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2OGdrQjlHQkhlVG90S0dxdFBNR1VYIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Toen+Ik+Je+Zag+Nielson&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Dromen%20Zijn%20Bedrog%20Frans%20Bauer&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Dromen%20Zijn%20Bedrog%20Frans%20Bauer&type=track","offset":0,"previous":null,"total":11,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OELFWvZ1tR4wKREmndcEJ"},"href":"https://api.spotify.com/v1/albums/0OELFWvZ1tR4wKREmndcEJ","id":"0OELFWvZ1tR4wKREmndcEJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c81c59d560502cd89d5bf1a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c81c59d560502cd89d5bf1a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c81c59d560502cd89d5bf1a"}],"is_playable":true,"name":"Marco","release_date":"1994-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0OELFWvZ1tR4wKREmndcEJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":242733,"explicit":false,"external_ids":{"isrc":"NLA319400194"},"external_urls":{"spotify":"https://open.spotify.com/track/2o4iWZOFE8kkl0tK66WADw"},"href":"https://api.spotify.com/v1/tracks/2o4iWZOFE8kkl0tK66WADw","id":"2o4iWZOFE8kkl0tK66WADw","is_local":false,"is_playable":true,"name":"Dromen Zijn Bedrog","track_number":1,"type":"track","uri":"spotify:track:2o4iWZOFE8kkl0tK66WADw"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6zEaCvF0CqEHs7kFyBkLHi"},"href":"https://api.spotify.com/v1/artists/6zEaCvF0CqEHs7kFyBkLHi","id":"6zEaCvF0CqEHs7kFyBkLHi","name":"Mula","type":"artist","uri":"spotify:artist:6zEaCvF0CqEHs7kFyBkLHi"}],"external_urls":{"spotify":"https://open.spotify.com/album/0YMGslfOd6IH0DiBVv6rfI"},"href":"https://api.spotify.com/v1/albums/0YMGslfOd6IH0DiBVv6rfI","id":"0YMGslfOd6IH0DiBVv6rfI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d1817821b4ebbc310fe03d4c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d1817821b4ebbc310fe03d4c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d1817821b4ebbc310fe03d4c"}],"is_playable":true,"name":"Narcopop","release_date":"2023-12-08","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0YMGslfOd6IH0DiBVv6rfI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6zEaCvF0CqEHs7kFyBkLHi"},"href":"https://api.spotify.com/v1/artists/6zEaCvF0CqEHs7kFyBkLHi","id":"6zEaCvF0CqEHs7kFyBkLHi","name":"Mula","type":"artist","uri":"spotify:artist:6zEaCvF0CqEHs7kFyBkLHi"}],"disc_number":1,"duration_ms":182621,"explicit":true,"external_ids":{"isrc":"DGA0H2301056"},"external_urls":{"spotify":"https://open.spotify.com/track/4qeOw74SOl3Dj9iCtAG5QK"},"href":"https://api.spotify.com/v1/tracks/4qeOw74SOl3Dj9iCtAG5QK","id":"4qeOw74SOl3Dj9iCtAG5QK","is_local":false,"is_playable":true,"name":"Ik Kijk Soms Naar Jou","track_number":2,"type":"track","uri":"spotify:track:4qeOw74SOl3Dj9iCtAG5QK"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rBMW23ztdIPx3poh9Z0G0"},"href":"https://api.spotify.com/v1/artists/3rBMW23ztdIPx3poh9Z0G0","id":"3rBMW23ztdIPx3poh9Z0G0","name":"Fons Veurink","type":"artist","uri":"spotify:artist:3rBMW23ztdIPx3poh9Z0G0"}],"external_urls":{"spotify":"https://open.spotify.com/album/7sRm9vPIyEaT7qxmWTdccG"},"href":"https://api.spotify.com/v1/albums/7sRm9vPIyEaT7qxmWTdccG","id":"7sRm9vPIyEaT7qxmWTdccG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b66ef2491d654d068ceaef29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b66ef2491d654d068ceaef29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b66ef2491d654d068ceaef29"}],"is_playable":true,"name":"Stoutste Droom","release_date":"2024-08-04","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7sRm9vPIyEaT7qxmWTdccG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rBMW23ztdIPx3poh9Z0G0"},"href":"https://api.spotify.com/v1/artists/3rBMW23ztdIPx3poh9Z0G0","id":"3rBMW23ztdIPx3poh9Z0G0","name":"Fons Veurink","type":"artist","uri":"spotify:artist:3rBMW23ztdIPx3poh9Z0G0"}],"disc_number":1,"duration_ms":177000,"explicit":false,"external_ids":{"isrc":"QZTAW2477071"},"external_urls":{"spotify":"https://open.spotify.com/track/1VE0zXSdwGoREfXbhnQwXo"},"href":"https://api.spotify.com/v1/tracks/1VE0zXSdwGoREfXbhnQwXo","id":"1VE0zXSdwGoREfXbhnQwXo","is_local":false,"is_playable":true,"name":"Stoutste Droom","track_number":1,"type":"track","uri":"spotify:track:1VE0zXSdwGoREfXbhnQwXo"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6zEaCvF0CqEHs7kFyBkLHi"},"href":"https://api.spotify.com/v1/artists/6zEaCvF0CqEHs7kFyBkLHi","id":"6zEaCvF0CqEHs7kFyBkLHi","name":"Mula","type":"artist","uri":"spotify:artist:6zEaCvF0CqEHs7kFyBkLHi"}],"external_urls":{"spotify":"https://open.spotify.com/album/3GjyYmdr4NyQStCXM3iyWx"},"href":"https://api.spotify.com/v1/albums/3GjyYmdr4NyQStCXM3iyWx","id":"3GjyYmdr4NyQStCXM3iyWx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27309700a448a06267af3e43072"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0209700a448a06267af3e43072"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485109700a448a06267af3e43072"}],"is_playable":true,"name":"Ik Kijk Soms Naar Jou","release_date":"2023-10-13","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:3GjyYmdr4NyQStCXM3iyWx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6zEaCvF0CqEHs7kFyBkLHi"},"href":"https://api.spotify.com/v1/artists/6zEaCvF0CqEHs7kFyBkLHi","id":"6zEaCvF0CqEHs7kFyBkLHi","name":"Mula","type":"artist","uri":"spotify:artist:6zEaCvF0CqEHs7kFyBkLHi"}],"disc_number":1,"duration_ms":182621,"explicit":true,"external_ids":{"isrc":"DGA0H2301056"},"external_urls":{"spotify":"https://open.spotify.com/track/7jBqqJNT5aOCkuyvrd7scH"},"href":"https://api.spotify.com/v1/tracks/7jBqqJNT5aOCkuyvrd7scH","id":"7jBqqJNT5aOCkuyvrd7scH","is_local":false,"is_playable":true,"name":"Ik Kijk Soms Naar Jou","track_number":1,"type":"track","uri":"spotify:track:7jBqqJNT5aOCkuyvrd7scH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"external_urls":{"spotify":"https://open.spotify.com/album/6P8MGrO5WKfHnrXOw45jfR"},"href":"https://api.spotify.com/v1/albums/6P8MGrO5WKfHnrXOw45jfR","id":"6P8MGrO5WKfHnrXOw45jfR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c189fdd3cf3ad54e6b8344d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c189fdd3cf3ad54e6b8344d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c189fdd3cf3ad54e6b8344d7"}],"is_playable":true,"name":"#1","release_date":"2011-11-25","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:6P8MGrO5WKfHnrXOw45jfR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3D2GUXbtlL3r2d5HJEnsFD"},"href":"https://api.spotify.com/v1/artists/3D2GUXbtlL3r2d5HJEnsFD","id":"3D2GUXbtlL3r2d5HJEnsFD","name":"Marco Borsato","type":"artist","uri":"spotify:artist:3D2GUXbtlL3r2d5HJEnsFD"}],"disc_number":1,"duration_ms":242853,"explicit":false,"external_ids":{"isrc":"NLA319400194"},"external_urls":{"spotify":"https://open.spotify.com/track/3E0avb6egc4A7M9sVBTJwi"},"href":"https://api.spotify.com/v1/tracks/3E0avb6egc4A7M9sVBTJwi","id":"3E0avb6egc4A7M9sVBTJwi","is_local":false,"is_playable":true,"name":"Dromen Zijn Bedrog","track_number":1,"type":"track","uri":"spotify:track:3E0avb6egc4A7M9sVBTJwi"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rBMW23ztdIPx3poh9Z0G0"},"href":"https://api.spotify.com/v1/artists/3rBMW23ztdIPx3poh9Z0G0","id":"3rBMW23ztdIPx3poh9Z0G0","name":"Fons Veurink","type":"artist","uri":"spotify:artist:3rBMW23ztdIPx3poh9Z0G0"}],"external_urls":{"spotify":"https://open.spotify.com/album/2D8WSfZUORzOeQzsAQbI2g"},"href":"https://api.spotify.com/v1/albums/2D8WSfZUORzOeQzsAQbI2g","id":"2D8WSfZUORzOeQzsAQbI2g","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c25bcaf29d918f924ba098a8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c25bcaf29d918f924ba098a8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c25bcaf29d918f924ba098a8"}],"is_playable":true,"name":"Stoutste Droom","release_date":"2024-08-02","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2D8WSfZUORzOeQzsAQbI2g"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3rBMW23ztdIPx3poh9Z0G0"},"href":"https://api.spotify.com/v1/artists/3rBMW23ztdIPx3poh9Z0G0","id":"3rBMW23ztdIPx3poh9Z0G0","name":"Fons Veurink","type":"artist","uri":"spotify:artist:3rBMW23ztdIPx3poh9Z0G0"}],"disc_number":1,"duration_ms":177667,"explicit":false,"external_ids":{"isrc":"QZTAW2477071"},"external_urls":{"spotify":"https://open.spotify.com/track/4Qot64LVblLTzvEISfO6N4"},"href":"https://api.spotify.com/v1/tracks/4Qot64LVblLTzvEISfO6N4","id":"4Qot64LVblLTzvEISfO6N4","is_local":false,"is_playable":true,"name":"Stoutste Droom","track_number":1,"type":"track","uri":"spotify:track:4Qot64LVblLTzvEISfO6N4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/58hFVpwYRp8sQdtANcMpiE"},"href":"https://api.spotify.com/v1/artists/58hFVpwYRp8sQdtANcMpiE","id":"58hFVpwYRp8sQdtANcMpiE","name":"Doe Maar","type":"artist","uri":"spotify:artist:58hFVpwYRp8sQdtANcMpiE"}],"external_urls":{"spotify":"https://open.spotify.com/album/5dEuc3PFwHlw3OR2IwCX4S"},"href":"https://api.spotify.com/v1/albums/5dEuc3PFwHlw3OR2IwCX4S","id":"5dEuc3PFwHlw3OR2IwCX4S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732b2a5261d9454e4d2b232b13"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022b2a5261d9454e4d2b232b13"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512b2a5261d9454e4d2b232b13"}],"is_playable":true,"name":"Doe Maar - De Singles (Het Complete Singles Overzicht)","release_date":"2008-07-01","release_date_precision":"day","total_tracks":31,"type":"album","uri":"spotify:album:5dEuc3PFwHlw3OR2IwCX4S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/58hFVpwYRp8sQdtANcMpiE"},"href":"https://api.spotify.com/v1/artists/58hFVpwYRp8sQdtANcMpiE","id":"58hFVpwYRp8sQdtANcMpiE","name":"Doe Maar","type":"artist","uri":"spotify:artist:58hFVpwYRp8sQdtANcMpiE"}],"disc_number":1,"duration_ms":288057,"explicit":false,"external_ids":{"isrc":"NLA340000060"},"external_urls":{"spotify":"https://open.spotify.com/track/3JYnLfDMyfsSxyiMEN318T"},"href":"https://api.spotify.com/v1/tracks/3JYnLfDMyfsSxyiMEN318T","id":"3JYnLfDMyfsSxyiMEN318T","is_local":false,"is_playable":true,"name":"Alles Gaat Voorbij","track_number":14,"type":"track","uri":"spotify:track:3JYnLfDMyfsSxyiMEN318T"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/58hFVpwYRp8sQdtANcMpiE"},"href":"https://api.spotify.com/v1/artists/58hFVpwYRp8sQdtANcMpiE","id":"58hFVpwYRp8sQdtANcMpiE","name":"Doe Maar","type":"artist","uri":"spotify:artist:58hFVpwYRp8sQdtANcMpiE"}],"external_urls":{"spotify":"https://open.spotify.com/album/1d27T3U7K7WixFp0Ja6pLz"},"href":"https://api.spotify.com/v1/albums/1d27T3U7K7WixFp0Ja6pLz","id":"1d27T3U7K7WixFp0Ja6pLz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27352adca8774ee4d782a53facf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0252adca8774ee4d782a53facf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485152adca8774ee4d782a53facf"}],"is_playable":true,"name":"4us","release_date":"1983-03-11","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1d27T3U7K7WixFp0Ja6pLz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/58hFVpwYRp8sQdtANcMpiE"},"href":"https://api.spotify.com/v1/artists/58hFVpwYRp8sQdtANcMpiE","id":"58hFVpwYRp8sQdtANcMpiE","name":"Doe Maar","type":"artist","uri":"spotify:artist:58hFVpwYRp8sQdtANcMpiE"}],"disc_number":1,"duration_ms":212760,"explicit":false,"external_ids":{"isrc":"NLAX70922375"},"external_urls":{"spotify":"https://open.spotify.com/track/1TrOzZEdo4nCsF3HOqDP7v"},"href":"https://api.spotify.com/v1/tracks/1TrOzZEdo4nCsF3HOqDP7v","id":"1TrOzZEdo4nCsF3HOqDP7v","is_local":false,"is_playable":true,"name":"Alles Gaat Voorbij","track_number":11,"type":"track","uri":"spotify:track:1TrOzZEdo4nCsF3HOqDP7v"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0v4CvkMzWBQ1wZIMl2BqQW"},"href":"https://api.spotify.com/v1/artists/0v4CvkMzWBQ1wZIMl2BqQW","id":"0v4CvkMzWBQ1wZIMl2BqQW","name":"Frans Bauer","type":"artist","uri":"spotify:artist:0v4CvkMzWBQ1wZIMl2BqQW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2onmCslqboJDdDoCo7ZPd2"},"href":"https://api.spotify.com/v1/artists/2onmCslqboJDdDoCo7ZPd2","id":"2onmCslqboJDdDoCo7ZPd2","name":"Django Wagner","type":"artist","uri":"spotify:artist:2onmCslqboJDdDoCo7ZPd2"}],"external_urls":{"spotify":"https://open.spotify.com/album/117kAFARQi7isHGwFh9gYA"},"href":"https://api.spotify.com/v1/albums/117kAFARQi7isHGwFh9gYA","id":"117kAFARQi7isHGwFh9gYA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376b916fdd8e00d0a77849739"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276b916fdd8e00d0a77849739"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176b916fdd8e00d0a77849739"}],"is_playable":true,"name":"Heb Je Al Genoeg Genoten","release_date":"2025-08-08","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:117kAFARQi7isHGwFh9gYA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0v4CvkMzWBQ1wZIMl2BqQW"},"href":"https://api.spotify.com/v1/artists/0v4CvkMzWBQ1wZIMl2BqQW","id":"0v4CvkMzWBQ1wZIMl2BqQW","name":"Frans Bauer","type":"artist","uri":"spotify:artist:0v4CvkMzWBQ1wZIMl2BqQW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2onmCslqboJDdDoCo7ZPd2"},"href":"https://api.spotify.com/v1/artists/2onmCslqboJDdDoCo7ZPd2","id":"2onmCslqboJDdDoCo7ZPd2","name":"Django Wagner","type":"artist","uri":"spotify:artist:2onmCslqboJDdDoCo7ZPd2"}],"disc_number":1,"duration_ms":139628,"explicit":false,"external_ids":{"isrc":"NLE872518301"},"external_urls":{"spotify":"https://open.spotify.com/track/52Ki7PzFYiyPbRnxtpZMc7"},"href":"https://api.spotify.com/v1/tracks/52Ki7PzFYiyPbRnxtpZMc7","id":"52Ki7PzFYiyPbRnxtpZMc7","is_local":false,"is_playable":true,"name":"Heb Je Al Genoeg Genoten","track_number":1,"type":"track","uri":"spotify:track:52Ki7PzFYiyPbRnxtpZMc7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6zEaCvF0CqEHs7kFyBkLHi"},"href":"https://api.spotify.com/v1/artists/6zEaCvF0CqEHs7kFyBkLHi","id":"6zEaCvF0CqEHs7kFyBkLHi","name":"Mula","type":"artist","uri":"spotify:artist:6zEaCvF0CqEHs7kFyBkLHi"}],"external_urls":{"spotify":"https://open.spotify.com/album/2mrF1rnFP0l4vm7ZIvXZE7"},"href":"https://api.spotify.com/v1/albums/2mrF1rnFP0l4vm7ZIvXZE7","id":"2mrF1rnFP0l4vm7ZIvXZE7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f8d39ac21282443bfd54b32"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f8d39ac21282443bfd54b32"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f8d39ac21282443bfd54b32"}],"is_playable":true,"name":"Blokke Gepikt","release_date":"2023-11-24","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:2mrF1rnFP0l4vm7ZIvXZE7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6zEaCvF0CqEHs7kFyBkLHi"},"href":"https://api.spotify.com/v1/artists/6zEaCvF0CqEHs7kFyBkLHi","id":"6zEaCvF0CqEHs7kFyBkLHi","name":"Mula","type":"artist","uri":"spotify:artist:6zEaCvF0CqEHs7kFyBkLHi"}],"disc_number":1,"duration_ms":182621,"explicit":true,"external_ids":{"isrc":"DGA0H2301056"},"external_urls":{"spotify":"https://open.spotify.com/track/3fz0n6umjH83KDybP2qaSU"},"href":"https://api.spotify.com/v1/tracks/3fz0n6umjH83KDybP2qaSU","id":"3fz0n6umjH83KDybP2qaSU","is_local":false,"is_playable":true,"name":"Ik Kijk Soms Naar Jou","track_number":3,"type":"track","uri":"spotify:track:3fz0n6umjH83KDybP2qaSU"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1Ecm9tZW4lMjBaaWpuJTIwQmVkcm9nJTIwRnJhbnMlMjBCYXVlciZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvc2VhcmNoP29mZnNldD0xMCZsaW1pdD0xMCZxdWVyeT1Ecm9tZW4lMjBaaWpuJTIwQmVkcm9nJTIwRnJhbnMlMjBCYXVlciZ0eXBlPXRyYWNrIiwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjExLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJpZCI6IjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQiLCJuYW1lIjoiTWFyY28gQm9yc2F0byIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRDJHVVhidGxMM3IyZDVISkVuc0ZEIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vME9FTEZXdloxdFI0d0tSRW1uZGNFSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBPRUxGV3ZaMXRSNHdLUkVtbmRjRUoiLCJpZCI6IjBPRUxGV3ZaMXRSNHdLUkVtbmRjRUoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmM4MWM1OWQ1NjA1MDJjZDg5ZDViZjFhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZjODFjNTlkNTYwNTAyY2Q4OWQ1YmYxYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmM4MWM1OWQ1NjA1MDJjZDg5ZDViZjFhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1hcmNvIiwicmVsZWFzZV9kYXRlIjoiMTk5NC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBPRUxGV3ZaMXRSNHdLUkVtbmRjRUoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIn0sImhyZQ==", + "ZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsImlkIjoiM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCIsIm5hbWUiOiJNYXJjbyBCb3JzYXRvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNEMkdVWGJ0bEwzcjJkNUhKRW5zRkQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQyNzMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxBMzE5NDAwMTk0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8ybzRpV1pPRkU4a2tsMHRLNjZXQUR3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMm80aVdaT0ZFOGtrbDB0SzY2V0FEdyIsImlkIjoiMm80aVdaT0ZFOGtrbDB0SzY2V0FEdyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEcm9tZW4gWmlqbiBCZWRyb2ciLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mm80aVdaT0ZFOGtrbDB0SzY2V0FEdyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82ekVhQ3ZGMENxRUhzN2tGeUJrTEhpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ6RWFDdkYwQ3FFSHM3a0Z5QmtMSGkiLCJpZCI6IjZ6RWFDdkYwQ3FFSHM3a0Z5QmtMSGkiLCJuYW1lIjoiTXVsYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2ekVhQ3ZGMENxRUhzN2tGeUJrTEhpIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMFlNR3NsZk9kNklIMERpQlZ2NnJmSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBZTUdzbGZPZDZJSDBEaUJWdjZyZkkiLCJpZCI6IjBZTUdzbGZPZDZJSDBEaUJWdjZyZkkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDE4MTc4MjFiNGViYmMzMTBmZTAzZDRjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQxODE3ODIxYjRlYmJjMzEwZmUwM2Q0YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDE4MTc4MjFiNGViYmMzMTBmZQ==", + "MDNkNGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmFyY29wb3AiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTEyLTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MFlNR3NsZk9kNklIMERpQlZ2NnJmSSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ6RWFDdkYwQ3FFSHM3a0Z5QmtMSGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnpFYUN2RjBDcUVIczdrRnlCa0xIaSIsImlkIjoiNnpFYUN2RjBDcUVIczdrRnlCa0xIaSIsIm5hbWUiOiJNdWxhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ6RWFDdkYwQ3FFSHM3a0Z5QmtMSGkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTgyNjIxLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJER0EwSDIzMDEwNTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRxZU93NzRTT2wzRGo5aUN0QUc1UUsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80cWVPdzc0U09sM0RqOWlDdEFHNVFLIiwiaWQiOiI0cWVPdzc0U09sM0RqOWlDdEFHNVFLIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IklrIEtpamsgU29tcyBOYWFyIEpvdSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0cWVPdzc0U09sM0RqOWlDdEFHNVFLIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zckJNVzIzenRkSVB4M3BvaDlaMEcwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNyQk1XMjN6dGRJUHgzcG9oOVowRzAiLCJpZCI6IjNyQk1XMjN6dGRJUHgzcG9oOVowRzAiLCJuYW1lIjoiRm9ucyBWZXVyaW5rIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNyQk1XMjN6dGRJUHgzcG9oOVowRzAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83c1JtOXZQSXlFYVQ3cXhtV1RkY2NHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3NSbTl2UEl5RWFUN3F4bVdUZGNjRyIsImlkIjoiN3NSbTl2UEl5RWFUN3F4bVdUZGNjRyIsImltYWdlcyI6W3siaA==", + "ZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I2NmVmMjQ5MWQ2NTRkMDY4Y2VhZWYyOSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiNjZlZjI0OTFkNjU0ZDA2OGNlYWVmMjkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI2NmVmMjQ5MWQ2NTRkMDY4Y2VhZWYyOSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdG91dHN0ZSBEcm9vbSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDgtMDQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdzUm05dlBJeUVhVDdxeG1XVGRjY0cifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zckJNVzIzenRkSVB4M3BvaDlaMEcwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNyQk1XMjN6dGRJUHgzcG9oOVowRzAiLCJpZCI6IjNyQk1XMjN6dGRJUHgzcG9oOVowRzAiLCJuYW1lIjoiRm9ucyBWZXVyaW5rIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNyQk1XMjN6dGRJUHgzcG9oOVowRzAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc3MDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUVpUQVcyNDc3MDcxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xVkUwelhTZHdHb1JFZlhiaG5Rd1hvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVZFMHpYU2R3R29SRWZYYmhuUXdYbyIsImlkIjoiMVZFMHpYU2R3R29SRWZYYmhuUXdYbyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdG91dHN0ZSBEcm9vbSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxVkUwelhTZHdHb1JFZlhiaG5Rd1hvIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82ekVhQ3ZGMENxRUhzN2tGeUJrTEhpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ6RWFDdkYwQ3FFSHM3a0Z5QmtMSGkiLCJpZCI6IjZ6RWFDdkYwQw==", + "cUVIczdrRnlCa0xIaSIsIm5hbWUiOiJNdWxhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ6RWFDdkYwQ3FFSHM3a0Z5QmtMSGkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zR2p5WW1kcjROeVFTdENYTTNpeVd4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0dqeVltZHI0TnlRU3RDWE0zaXlXeCIsImlkIjoiM0dqeVltZHI0TnlRU3RDWE0zaXlXeCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwOTcwMGE0NDhhMDYyNjdhZjNlNDMwNzIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDk3MDBhNDQ4YTA2MjY3YWYzZTQzMDcyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwOTcwMGE0NDhhMDYyNjdhZjNlNDMwNzIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSWsgS2lqayBTb21zIE5hYXIgSm91IiwicmVsZWFzZV9kYXRlIjoiMjAyMy0xMC0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0dqeVltZHI0TnlRU3RDWE0zaXlXeCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ6RWFDdkYwQ3FFSHM3a0Z5QmtMSGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnpFYUN2RjBDcUVIczdrRnlCa0xIaSIsImlkIjoiNnpFYUN2RjBDcUVIczdrRnlCa0xIaSIsIm5hbWUiOiJNdWxhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ6RWFDdkYwQ3FFSHM3a0Z5QmtMSGkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTgyNjIxLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJER0EwSDIzMDEwNTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdqQnFxSk5UNWFPQ2t1eXZyZDdzY0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83akJxcUpOVDVhT0NrdXl2cmQ3c2NIIiwiaWQiOiI3akJxcUpOVDVhT0NrdXl2cmQ3c2NIIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IklrIEtpamsgU29tcyBOYWFyIEpvdQ==", + "IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdqQnFxSk5UNWFPQ2t1eXZyZDdzY0gifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwiaWQiOiIzRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwibmFtZSI6Ik1hcmNvIEJvcnNhdG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZQOE1Hck81V0tmSG5yWE93NDVqZlIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82UDhNR3JPNVdLZkhuclhPdzQ1amZSIiwiaWQiOiI2UDhNR3JPNVdLZkhuclhPdzQ1amZSIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2MxODlmZGQzY2YzYWQ1NGU2YjgzNDRkNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjMTg5ZmRkM2NmM2FkNTRlNmI4MzQ0ZDcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWMxODlmZGQzY2YzYWQ1NGU2YjgzNDRkNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiIjMSIsInJlbGVhc2VfZGF0ZSI6IjIwMTEtMTEtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2UDhNR3JPNVdLZkhuclhPdzQ1amZSIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwiaWQiOiIzRDJHVVhidGxMM3IyZDVISkVuc0ZEIiwibmFtZSI6Ik1hcmNvIEJvcnNhdG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0QyR1VYYnRsTDNyMmQ1SEpFbnNGRCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDI4NTMsImV4cA==", + "bGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTMxOTQwMDE5NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0UwYXZiNmVnYzRBN005c1ZCVEp3aSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNFMGF2YjZlZ2M0QTdNOXNWQlRKd2kiLCJpZCI6IjNFMGF2YjZlZ2M0QTdNOXNWQlRKd2kiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRHJvbWVuIFppam4gQmVkcm9nIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNFMGF2YjZlZ2M0QTdNOXNWQlRKd2kifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNyQk1XMjN6dGRJUHgzcG9oOVowRzAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3JCTVcyM3p0ZElQeDNwb2g5WjBHMCIsImlkIjoiM3JCTVcyM3p0ZElQeDNwb2g5WjBHMCIsIm5hbWUiOiJGb25zIFZldXJpbmsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3JCTVcyM3p0ZElQeDNwb2g5WjBHMCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJEOFdTZlpVT1J6T2VRenNBUWJJMmcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yRDhXU2ZaVU9Sek9lUXpzQVFiSTJnIiwiaWQiOiIyRDhXU2ZaVU9Sek9lUXpzQVFiSTJnIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2MyNWJjYWYyOWQ5MThmOTI0YmEwOThhOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjMjViY2FmMjlkOTE4ZjkyNGJhMDk4YTgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWMyNWJjYWYyOWQ5MThmOTI0YmEwOThhOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdG91dHN0ZSBEcm9vbSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDgtMDIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJEOFdTZlpVT1J6T2VRenNBUWJJMmcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdQ==", + "cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNyQk1XMjN6dGRJUHgzcG9oOVowRzAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3JCTVcyM3p0ZElQeDNwb2g5WjBHMCIsImlkIjoiM3JCTVcyM3p0ZElQeDNwb2g5WjBHMCIsIm5hbWUiOiJGb25zIFZldXJpbmsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3JCTVcyM3p0ZElQeDNwb2g5WjBHMCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzc2NjcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWlRBVzI0NzcwNzEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRRb3Q2NExWYmxMVHp2RUlTZk82TjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80UW90NjRMVmJsTFR6dkVJU2ZPNk40IiwiaWQiOiI0UW90NjRMVmJsTFR6dkVJU2ZPNk40IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0b3V0c3RlIERyb29tIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRRb3Q2NExWYmxMVHp2RUlTZk82TjQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNThoRlZwd1lScDhzUWR0QU5jTXBpRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81OGhGVnB3WVJwOHNRZHRBTmNNcGlFIiwiaWQiOiI1OGhGVnB3WVJwOHNRZHRBTmNNcGlFIiwibmFtZSI6IkRvZSBNYWFyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU4aEZWcHdZUnA4c1FkdEFOY01waUUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81ZEV1YzNQRndIbHczT1IySXdDWDRTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWRFdWMzUEZ3SGx3M09SMkl3Q1g0UyIsImlkIjoiNWRFdWMzUEZ3SGx3M09SMkl3Q1g0UyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyYjJhNTI2MWQ5NDU0ZTRkMmIyMzJiMTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmIyYTUyNjFkOTQ1NGU0ZDJiMjMyYjEzIn0seyJoZWlnaHQiOjY0LA==", + "IndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJiMmE1MjYxZDk0NTRlNGQyYjIzMmIxMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb2UgTWFhciAtIERlIFNpbmdsZXMgKEhldCBDb21wbGV0ZSBTaW5nbGVzIE92ZXJ6aWNodCkiLCJyZWxlYXNlX2RhdGUiOiIyMDA4LTA3LTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWRFdWMzUEZ3SGx3M09SMkl3Q1g0UyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU4aEZWcHdZUnA4c1FkdEFOY01waUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNThoRlZwd1lScDhzUWR0QU5jTXBpRSIsImlkIjoiNThoRlZwd1lScDhzUWR0QU5jTXBpRSIsIm5hbWUiOiJEb2UgTWFhciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OGhGVnB3WVJwOHNRZHRBTmNNcGlFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI4ODA1NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTM0MDAwMDA2MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0pZbkxmRE15ZnNTeHlpTUVOMzE4VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNKWW5MZkRNeWZzU3h5aU1FTjMxOFQiLCJpZCI6IjNKWW5MZkRNeWZzU3h5aU1FTjMxOFQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWxsZXMgR2FhdCBWb29yYmlqIiwidHJhY2tfbnVtYmVyIjoxNCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozSlluTGZETXlmc1N4eWlNRU4zMThUIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU4aEZWcHdZUnA4c1FkdEFOY01waUUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNThoRlZwd1lScDhzUWR0QU5jTXBpRSIsImlkIjoiNThoRlZwd1lScDhzUWR0QU5jTXBpRSIsIm5hbWUiOiJEb2UgTWFhciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OGhGVnB3WVJwOHNRZHRBTmNNcGlFIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMWQyN1QzVTdLN1dpeA==", + "RnAwSmE2cEx6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWQyN1QzVTdLN1dpeEZwMEphNnBMeiIsImlkIjoiMWQyN1QzVTdLN1dpeEZwMEphNnBMeiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1MmFkY2E4Nzc0ZWU0ZDc4MmE1M2ZhY2YifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTJhZGNhODc3NGVlNGQ3ODJhNTNmYWNmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1MmFkY2E4Nzc0ZWU0ZDc4MmE1M2ZhY2YifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiNHVzIiwicmVsZWFzZV9kYXRlIjoiMTk4My0wMy0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFkMjdUM1U3SzdXaXhGcDBKYTZwTHoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81OGhGVnB3WVJwOHNRZHRBTmNNcGlFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU4aEZWcHdZUnA4c1FkdEFOY01waUUiLCJpZCI6IjU4aEZWcHdZUnA4c1FkdEFOY01waUUiLCJuYW1lIjoiRG9lIE1hYXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NThoRlZwd1lScDhzUWR0QU5jTXBpRSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTI3NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEFYNzA5MjIzNzUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFUck96WkVkbzRuQ3NGM0hPcURQN3YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xVHJPelpFZG80bkNzRjNIT3FEUDd2IiwiaWQiOiIxVHJPelpFZG80bkNzRjNIT3FEUDd2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFsbGVzIEdhYXQgVm9vcmJpaiIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MVRyT3paRWRvNG5Dc0YzSE9xRFA3diJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcg==", + "dGlzdC8wdjRDdmtNeldCUTF3WklNbDJCcVFXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB2NEN2a016V0JRMXdaSU1sMkJxUVciLCJpZCI6IjB2NEN2a016V0JRMXdaSU1sMkJxUVciLCJuYW1lIjoiRnJhbnMgQmF1ZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHY0Q3ZrTXpXQlExd1pJTWwyQnFRVyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yb25tQ3NscWJvSkRkRG9DbzdaUGQyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJvbm1Dc2xxYm9KRGREb0NvN1pQZDIiLCJpZCI6IjJvbm1Dc2xxYm9KRGREb0NvN1pQZDIiLCJuYW1lIjoiRGphbmdvIFdhZ25lciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyb25tQ3NscWJvSkRkRG9DbzdaUGQyIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMTE3a0FGQVJRaTdpc0hHd0ZoOWdZQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzExN2tBRkFSUWk3aXNIR3dGaDlnWUEiLCJpZCI6IjExN2tBRkFSUWk3aXNIR3dGaDlnWUEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzZiOTE2ZmRkOGUwMGQwYTc3ODQ5NzM5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjc2YjkxNmZkZDhlMDBkMGE3Nzg0OTczOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzZiOTE2ZmRkOGUwMGQwYTc3ODQ5NzM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhlYiBKZSBBbCBHZW5vZWcgR2Vub3RlbiIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDgtMDgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjExN2tBRkFSUWk3aXNIR3dGaDlnWUEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdjRDdmtNeldCUTF3WklNbDJCcVFXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB2NEN2a016V0JRMXdaSU1sMkJxUVciLCJpZCI6IjB2NEN2a016V0JRMXdaSU1sMkJxUVciLCJuYW1lIjoiRnJhbnMgQmF1ZXIiLCJ0eQ==", + "cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowdjRDdmtNeldCUTF3WklNbDJCcVFXIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJvbm1Dc2xxYm9KRGREb0NvN1pQZDIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMm9ubUNzbHFib0pEZERvQ283WlBkMiIsImlkIjoiMm9ubUNzbHFib0pEZERvQ283WlBkMiIsIm5hbWUiOiJEamFuZ28gV2FnbmVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJvbm1Dc2xxYm9KRGREb0NvN1pQZDIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTM5NjI4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxFODcyNTE4MzAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81MktpN1B6RllpeVBiUm54dHBaTWM3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNTJLaTdQekZZaXlQYlJueHRwWk1jNyIsImlkIjoiNTJLaTdQekZZaXlQYlJueHRwWk1jNyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZWIgSmUgQWwgR2Vub2VnIEdlbm90ZW4iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NTJLaTdQekZZaXlQYlJueHRwWk1jNyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnpFYUN2RjBDcUVIczdrRnlCa0xIaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82ekVhQ3ZGMENxRUhzN2tGeUJrTEhpIiwiaWQiOiI2ekVhQ3ZGMENxRUhzN2tGeUJrTEhpIiwibmFtZSI6Ik11bGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnpFYUN2RjBDcUVIczdrRnlCa0xIaSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJtckYxcm5GUDBsNHZtN1pJdlhaRTcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8ybXJGMXJuRlAwbDR2bTdaSXZYWkU3IiwiaWQiOiIybXJGMXJuRlAwbDR2bTdaSXZYWkU3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzVmOGQzOWFjMjEyODI0NDNiZmQ1NGIzMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Ig==", + "aHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjVmOGQzOWFjMjEyODI0NDNiZmQ1NGIzMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNWY4ZDM5YWMyMTI4MjQ0M2JmZDU0YjMyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJsb2trZSBHZXBpa3QiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTExLTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToybXJGMXJuRlAwbDR2bTdaSXZYWkU3In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnpFYUN2RjBDcUVIczdrRnlCa0xIaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82ekVhQ3ZGMENxRUhzN2tGeUJrTEhpIiwiaWQiOiI2ekVhQ3ZGMENxRUhzN2tGeUJrTEhpIiwibmFtZSI6Ik11bGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnpFYUN2RjBDcUVIczdrRnlCa0xIaSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODI2MjEsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkRHQTBIMjMwMTA1NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2Z6MG42dW1qSDgzS0R5YlAycWFTVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNmejBuNnVtakg4M0tEeWJQMnFhU1UiLCJpZCI6IjNmejBuNnVtakg4M0tEeWJQMnFhU1UiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSWsgS2lqayBTb21zIE5hYXIgSm91IiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNmejBuNnVtakg4M0tEeWJQMnFhU1UifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Dromen+Zijn+Bedrog+Frans+Bauer&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkFuZGFsdWNpYSUyMiUyMGFydGlzdCUzQSUyMkNoZWYlMjdTcGVjaWFsJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkFuZGFsdWNpYSUyMiUyMGFydGlzdCUzQSUyMkNoZWYlMjdTcGVjaWFsJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Andalucia%22+artist%3A%22Chef%27Special%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMktydWltZWx0amUlMjIlMjBhcnRpc3QlM0ElMjJBbm91ayUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMktydWltZWx0amUlMjIlMjBhcnRpc3QlM0ElMjJBbm91ayUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Kruimeltje%22+artist%3A%22Anouk%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Wonderland%20Chef%27Special&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2jHp7gQArCQrlMvdrIVFCg"},"href":"https://api.spotify.com/v1/artists/2jHp7gQArCQrlMvdrIVFCg","id":"2jHp7gQArCQrlMvdrIVFCg","name":"Anson Seabra","type":"artist","uri":"spotify:artist:2jHp7gQArCQrlMvdrIVFCg"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ZOznMmpjk17NIBj2S4LrP"},"href":"https://api.spotify.com/v1/albums/3ZOznMmpjk17NIBj2S4LrP","id":"3ZOznMmpjk17NIBj2S4LrP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27300c874a64c388c7759b198a5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0200c874a64c388c7759b198a5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485100c874a64c388c7759b198a5"}],"is_playable":true,"name":"Welcome to Wonderland","release_date":"2018-04-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3ZOznMmpjk17NIBj2S4LrP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2jHp7gQArCQrlMvdrIVFCg"},"href":"https://api.spotify.com/v1/artists/2jHp7gQArCQrlMvdrIVFCg","id":"2jHp7gQArCQrlMvdrIVFCg","name":"Anson Seabra","type":"artist","uri":"spotify:artist:2jHp7gQArCQrlMvdrIVFCg"}],"disc_number":1,"duration_ms":199131,"explicit":false,"external_ids":{"isrc":"FR2X41824079"},"external_urls":{"spotify":"https://open.spotify.com/track/1WxuCays6Ads6QwanSvpjF"},"href":"https://api.spotify.com/v1/tracks/1WxuCays6Ads6QwanSvpjF","id":"1WxuCays6Ads6QwanSvpjF","is_local":false,"is_playable":true,"name":"Welcome to Wonderland","track_number":1,"type":"track","uri":"spotify:track:1WxuCays6Ads6QwanSvpjF"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2d58BZUfGvr3SyaCnFArKX"},"href":"https://api.spotify.com/v1/artists/2d58BZUfGvr3SyaCnFArKX","id":"2d58BZUfGvr3SyaCnFArKX","name":"Reem","type":"artist","uri":"spotify:artist:2d58BZUfGvr3SyaCnFArKX"}],"external_urls":{"spotify":"https://open.spotify.com/album/1t1pu4zJ4bK2ydroXY7HIP"},"href":"https://api.spotify.com/v1/albums/1t1pu4zJ4bK2ydroXY7HIP","id":"1t1pu4zJ4bK2ydroXY7HIP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335ab99bbab7e921ad6a3aa66"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235ab99bbab7e921ad6a3aa66"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135ab99bbab7e921ad6a3aa66"}],"is_playable":true,"name":"Wonderland","release_date":"2024-10-04","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1t1pu4zJ4bK2ydroXY7HIP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2d58BZUfGvr3SyaCnFArKX"},"href":"https://api.spotify.com/v1/artists/2d58BZUfGvr3SyaCnFArKX","id":"2d58BZUfGvr3SyaCnFArKX","name":"Reem","type":"artist","uri":"spotify:artist:2d58BZUfGvr3SyaCnFArKX"}],"disc_number":1,"duration_ms":208000,"explicit":false,"external_ids":{"isrc":"SE6QE2474553"},"external_urls":{"spotify":"https://open.spotify.com/track/1QkvrvZ8WsIjILs2EycSVe"},"href":"https://api.spotify.com/v1/tracks/1QkvrvZ8WsIjILs2EycSVe","id":"1QkvrvZ8WsIjILs2EycSVe","is_local":false,"is_playable":true,"name":"Wonderland","track_number":1,"type":"track","uri":"spotify:track:1QkvrvZ8WsIjILs2EycSVe"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6KlY7jizsLWQcXR1F2Sn9j"},"href":"https://api.spotify.com/v1/artists/6KlY7jizsLWQcXR1F2Sn9j","id":"6KlY7jizsLWQcXR1F2Sn9j","name":"Aftershock","type":"artist","uri":"spotify:artist:6KlY7jizsLWQcXR1F2Sn9j"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Uk4IDpF1OIuTzANugS5JC"},"href":"https://api.spotify.com/v1/artists/1Uk4IDpF1OIuTzANugS5JC","id":"1Uk4IDpF1OIuTzANugS5JC","name":"Bass Modulators","type":"artist","uri":"spotify:artist:1Uk4IDpF1OIuTzANugS5JC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/43KI3dStl8f4EJyETnKfiX"},"href":"https://api.spotify.com/v1/artists/43KI3dStl8f4EJyETnKfiX","id":"43KI3dStl8f4EJyETnKfiX","name":"Shadow Legacy","type":"artist","uri":"spotify:artist:43KI3dStl8f4EJyETnKfiX"}],"external_urls":{"spotify":"https://open.spotify.com/album/4wezbz8qkEGf1KWMOfrgE7"},"href":"https://api.spotify.com/v1/albums/4wezbz8qkEGf1KWMOfrgE7","id":"4wezbz8qkEGf1KWMOfrgE7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736645eb33f31a485e02eca970"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026645eb33f31a485e02eca970"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516645eb33f31a485e02eca970"}],"is_playable":true,"name":"Wonderland","release_date":"2026-04-03","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:4wezbz8qkEGf1KWMOfrgE7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6KlY7jizsLWQcXR1F2Sn9j"},"href":"https://api.spotify.com/v1/artists/6KlY7jizsLWQcXR1F2Sn9j","id":"6KlY7jizsLWQcXR1F2Sn9j","name":"Aftershock","type":"artist","uri":"spotify:artist:6KlY7jizsLWQcXR1F2Sn9j"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Uk4IDpF1OIuTzANugS5JC"},"href":"https://api.spotify.com/v1/artists/1Uk4IDpF1OIuTzANugS5JC","id":"1Uk4IDpF1OIuTzANugS5JC","name":"Bass Modulators","type":"artist","uri":"spotify:artist:1Uk4IDpF1OIuTzANugS5JC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/43KI3dStl8f4EJyETnKfiX"},"href":"https://api.spotify.com/v1/artists/43KI3dStl8f4EJyETnKfiX","id":"43KI3dStl8f4EJyETnKfiX","name":"Shadow Legacy","type":"artist","uri":"spotify:artist:43KI3dStl8f4EJyETnKfiX"}],"disc_number":1,"duration_ms":156809,"explicit":false,"external_ids":{"isrc":"GX8LE2676836"},"external_urls":{"spotify":"https://open.spotify.com/track/5pQMGF5MPJQwdAVuWKKESr"},"href":"https://api.spotify.com/v1/tracks/5pQMGF5MPJQwdAVuWKKESr","id":"5pQMGF5MPJQwdAVuWKKESr","is_local":false,"is_playable":true,"name":"Wonderland","track_number":1,"type":"track","uri":"spotify:track:5pQMGF5MPJQwdAVuWKKESr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/38wxcfNEqMwuPniHvplin5"},"href":"https://api.spotify.com/v1/artists/38wxcfNEqMwuPniHvplin5","id":"38wxcfNEqMwuPniHvplin5","name":"Neoni","type":"artist","uri":"spotify:artist:38wxcfNEqMwuPniHvplin5"}],"external_urls":{"spotify":"https://open.spotify.com/album/2npzGBEPDOfVLN8ajYm3pZ"},"href":"https://api.spotify.com/v1/albums/2npzGBEPDOfVLN8ajYm3pZ","id":"2npzGBEPDOfVLN8ajYm3pZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735949fe5472d5ad4d30494569"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025949fe5472d5ad4d30494569"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515949fe5472d5ad4d30494569"}],"is_playable":true,"name":"Wars In A Wonderland","release_date":"2021-08-20","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:2npzGBEPDOfVLN8ajYm3pZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/38wxcfNEqMwuPniHvplin5"},"href":"https://api.spotify.com/v1/artists/38wxcfNEqMwuPniHvplin5","id":"38wxcfNEqMwuPniHvplin5","name":"Neoni","type":"artist","uri":"spotify:artist:38wxcfNEqMwuPniHvplin5"}],"disc_number":1,"duration_ms":197333,"explicit":false,"external_ids":{"isrc":"DEWO71700229"},"external_urls":{"spotify":"https://open.spotify.com/track/1fh4rarBaLB8l5ALt1UvPv"},"href":"https://api.spotify.com/v1/tracks/1fh4rarBaLB8l5ALt1UvPv","id":"1fh4rarBaLB8l5ALt1UvPv","is_local":false,"is_playable":true,"name":"WONDERLAND","track_number":1,"type":"track","uri":"spotify:track:1fh4rarBaLB8l5ALt1UvPv"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1Xb25kZXJsYW5kJTIwQ2hlZiUyN1NwZWNpYWwmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjQsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yakhwN2dRQXJDUXJsTXZkcklWRkNnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJqSHA3Z1FBckNRcmxNdmRySVZGQ2ciLCJpZCI6IjJqSHA3Z1FBckNRcmxNdmRySVZGQ2ciLCJuYW1lIjoiQW5zb24gU2VhYnJhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJqSHA3Z1FBckNRcmxNdmRySVZGQ2cifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zWk96bk1tcGprMTdOSUJqMlM0THJQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM1pPem5NbXBqazE3TklCajJTNExyUCIsImlkIjoiM1pPem5NbXBqazE3TklCajJTNExyUCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwMGM4Nw==", + "NGE2NGMzODhjNzc1OWIxOThhNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwMGM4NzRhNjRjMzg4Yzc3NTliMTk4YTUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAwYzg3NGE2NGMzODhjNzc1OWIxOThhNSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXZWxjb21lIHRvIFdvbmRlcmxhbmQiLCJyZWxlYXNlX2RhdGUiOiIyMDE4LTA0LTIwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozWk96bk1tcGprMTdOSUJqMlM0THJQIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmpIcDdnUUFyQ1FybE12ZHJJVkZDZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yakhwN2dRQXJDUXJsTXZkcklWRkNnIiwiaWQiOiIyakhwN2dRQXJDUXJsTXZkcklWRkNnIiwibmFtZSI6IkFuc29uIFNlYWJyYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyakhwN2dRQXJDUXJsTXZkcklWRkNnIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5OTEzMSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkZSMlg0MTgyNDA3OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVd4dUNheXM2QWRzNlF3YW5TdnBqRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFXeHVDYXlzNkFkczZRd2FuU3ZwakYiLCJpZCI6IjFXeHVDYXlzNkFkczZRd2FuU3ZwakYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2VsY29tZSB0byBXb25kZXJsYW5kIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFXeHVDYXlzNkFkczZRd2FuU3ZwakYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJkNThCWlVmR3ZyM1N5YUNuRkFyS1gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmQ1OEJaVWZHdnIzU3lhQ25GQXJLWCIsImlkIjoiMmQ1OEJaVWZHdnIzU3lhQ25GQXJLWCIsIm5hbWUiOiJSZWVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YQ==", + "cnRpc3Q6MmQ1OEJaVWZHdnIzU3lhQ25GQXJLWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzF0MXB1NHpKNGJLMnlkcm9YWTdISVAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xdDFwdTR6SjRiSzJ5ZHJvWFk3SElQIiwiaWQiOiIxdDFwdTR6SjRiSzJ5ZHJvWFk3SElQIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzM1YWI5OWJiYWI3ZTkyMWFkNmEzYWE2NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzNWFiOTliYmFiN2U5MjFhZDZhM2FhNjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTM1YWI5OWJiYWI3ZTkyMWFkNmEzYWE2NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXb25kZXJsYW5kIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0xMC0wNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXQxcHU0eko0YksyeWRyb1hZN0hJUCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJkNThCWlVmR3ZyM1N5YUNuRkFyS1gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmQ1OEJaVWZHdnIzU3lhQ25GQXJLWCIsImlkIjoiMmQ1OEJaVWZHdnIzU3lhQ25GQXJLWCIsIm5hbWUiOiJSZWVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJkNThCWlVmR3ZyM1N5YUNuRkFyS1gifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA4MDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiU0U2UUUyNDc0NTUzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xUWt2cnZaOFdzSWpJTHMyRXljU1ZlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVFrdnJ2WjhXc0lqSUxzMkV5Y1NWZSIsImlkIjoiMVFrdnJ2WjhXc0lqSUxzMkV5Y1NWZSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXb25kZXJsYW5kIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFRa3Zydlo4V3NJaklMczJFeWNTVmUifSx7Ig==", + "YWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNktsWTdqaXpzTFdRY1hSMUYyU245aiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82S2xZN2ppenNMV1FjWFIxRjJTbjlqIiwiaWQiOiI2S2xZN2ppenNMV1FjWFIxRjJTbjlqIiwibmFtZSI6IkFmdGVyc2hvY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NktsWTdqaXpzTFdRY1hSMUYyU245aiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xVWs0SURwRjFPSXVUekFOdWdTNUpDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFVazRJRHBGMU9JdVR6QU51Z1M1SkMiLCJpZCI6IjFVazRJRHBGMU9JdVR6QU51Z1M1SkMiLCJuYW1lIjoiQmFzcyBNb2R1bGF0b3JzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFVazRJRHBGMU9JdVR6QU51Z1M1SkMifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDNLSTNkU3RsOGY0RUp5RVRuS2ZpWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80M0tJM2RTdGw4ZjRFSnlFVG5LZmlYIiwiaWQiOiI0M0tJM2RTdGw4ZjRFSnlFVG5LZmlYIiwibmFtZSI6IlNoYWRvdyBMZWdhY3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDNLSTNkU3RsOGY0RUp5RVRuS2ZpWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzR3ZXpiejhxa0VHZjFLV01PZnJnRTcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80d2V6Yno4cWtFR2YxS1dNT2ZyZ0U3IiwiaWQiOiI0d2V6Yno4cWtFR2YxS1dNT2ZyZ0U3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzY2NDVlYjMzZjMxYTQ4NWUwMmVjYTk3MCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2NjQ1ZWIzM2YzMWE0ODVlMDJlY2E5NzAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTY2NDVlYjMzZjMxYTQ4NWUwMmVjYTk3MCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXb25kZXJsYW5kIiwicg==", + "ZWxlYXNlX2RhdGUiOiIyMDI2LTA0LTAzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0d2V6Yno4cWtFR2YxS1dNT2ZyZ0U3In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNktsWTdqaXpzTFdRY1hSMUYyU245aiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82S2xZN2ppenNMV1FjWFIxRjJTbjlqIiwiaWQiOiI2S2xZN2ppenNMV1FjWFIxRjJTbjlqIiwibmFtZSI6IkFmdGVyc2hvY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NktsWTdqaXpzTFdRY1hSMUYyU245aiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xVWs0SURwRjFPSXVUekFOdWdTNUpDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFVazRJRHBGMU9JdVR6QU51Z1M1SkMiLCJpZCI6IjFVazRJRHBGMU9JdVR6QU51Z1M1SkMiLCJuYW1lIjoiQmFzcyBNb2R1bGF0b3JzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFVazRJRHBGMU9JdVR6QU51Z1M1SkMifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDNLSTNkU3RsOGY0RUp5RVRuS2ZpWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80M0tJM2RTdGw4ZjRFSnlFVG5LZmlYIiwiaWQiOiI0M0tJM2RTdGw4ZjRFSnlFVG5LZmlYIiwibmFtZSI6IlNoYWRvdyBMZWdhY3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDNLSTNkU3RsOGY0RUp5RVRuS2ZpWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTY4MDksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHWDhMRTI2NzY4MzYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVwUU1HRjVNUEpRd2RBVnVXS0tFU3IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81cFFNR0Y1TVBKUXdkQVZ1V0tLRVNyIiwiaWQiOiI1cFFNR0Y1TVBKUXdkQVZ1V0tLRVNyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldvbmRlcmxhbmQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXBRTUdGNU1QSlF3ZEFWdVdLS0VTciJ9LHsiYWxidW0iOnsiYWxidW1fdA==", + "eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzM4d3hjZk5FcU13dVBuaUh2cGxpbjUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzh3eGNmTkVxTXd1UG5pSHZwbGluNSIsImlkIjoiMzh3eGNmTkVxTXd1UG5pSHZwbGluNSIsIm5hbWUiOiJOZW9uaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozOHd4Y2ZORXFNd3VQbmlIdnBsaW41In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMm5wekdCRVBET2ZWTE44YWpZbTNwWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJucHpHQkVQRE9mVkxOOGFqWW0zcFoiLCJpZCI6IjJucHpHQkVQRE9mVkxOOGFqWW0zcFoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTk0OWZlNTQ3MmQ1YWQ0ZDMwNDk0NTY5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjU5NDlmZTU0NzJkNWFkNGQzMDQ5NDU2OSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTk0OWZlNTQ3MmQ1YWQ0ZDMwNDk0NTY5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhcnMgSW4gQSBXb25kZXJsYW5kIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wOC0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Mm5wekdCRVBET2ZWTE44YWpZbTNwWiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzM4d3hjZk5FcU13dVBuaUh2cGxpbjUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzh3eGNmTkVxTXd1UG5pSHZwbGluNSIsImlkIjoiMzh3eGNmTkVxTXd1UG5pSHZwbGluNSIsIm5hbWUiOiJOZW9uaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozOHd4Y2ZORXFNd3VQbmlIdnBsaW41In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NzMzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkRFV083MTcwMDIyOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jbw==", + "bS90cmFjay8xZmg0cmFyQmFMQjhsNUFMdDFVdlB2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMWZoNHJhckJhTEI4bDVBTHQxVXZQdiIsImlkIjoiMWZoNHJhckJhTEI4bDVBTHQxVXZQdiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXT05ERVJMQU5EIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFmaDRyYXJCYUxCOGw1QUx0MVV2UHYifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Wonderland+Chef%27Special&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJpc2UlMjIlMjBhcnRpc3QlM0ElMjJBbm91ayUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJpc2UlMjIlMjBhcnRpc3QlM0ElMjJBbm91ayUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Rise%22+artist%3A%22Anouk%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Het%20Land%20Van...%20Lange%20Frans%2C%20Baas%20B&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Het%20Land%20Van...%20Lange%20Frans%2C%20Baas%20B&type=track","offset":0,"previous":null,"total":20,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/6um3VlGOcC7PWzcKeYidCV"},"href":"https://api.spotify.com/v1/albums/6um3VlGOcC7PWzcKeYidCV","id":"6um3VlGOcC7PWzcKeYidCV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e2e4b4cf54573a895f7defa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e2e4b4cf54573a895f7defa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e2e4b4cf54573a895f7defa"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-08-10","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:6um3VlGOcC7PWzcKeYidCV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":230440,"explicit":false,"external_ids":{"isrc":"NLG270500124"},"external_urls":{"spotify":"https://open.spotify.com/track/0wMAsL98TGuI6eWUEocd1O"},"href":"https://api.spotify.com/v1/tracks/0wMAsL98TGuI6eWUEocd1O","id":"0wMAsL98TGuI6eWUEocd1O","is_local":false,"is_playable":true,"name":"Het Land Van","track_number":2,"type":"track","uri":"spotify:track:0wMAsL98TGuI6eWUEocd1O"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/7KNScUfntGmEglib8BOvIw"},"href":"https://api.spotify.com/v1/albums/7KNScUfntGmEglib8BOvIw","id":"7KNScUfntGmEglib8BOvIw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27315e20f9f09d1134c65cf5057"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0215e20f9f09d1134c65cf5057"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485115e20f9f09d1134c65cf5057"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-01-01","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:7KNScUfntGmEglib8BOvIw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":262706,"explicit":false,"external_ids":{"isrc":"NLG270500123"},"external_urls":{"spotify":"https://open.spotify.com/track/7bOLDp1XTFUVWvARR2IhwB"},"href":"https://api.spotify.com/v1/tracks/7bOLDp1XTFUVWvARR2IhwB","id":"7bOLDp1XTFUVWvARR2IhwB","is_local":false,"is_playable":true,"name":"Het Land Van - Live","track_number":1,"type":"track","uri":"spotify:track:7bOLDp1XTFUVWvARR2IhwB"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GxCjxM4YUabJgybJq06XT"},"href":"https://api.spotify.com/v1/artists/3GxCjxM4YUabJgybJq06XT","id":"3GxCjxM4YUabJgybJq06XT","name":"Lange Frans & Baas B","type":"artist","uri":"spotify:artist:3GxCjxM4YUabJgybJq06XT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/7G7sz71wV7PLd4mi3vb44s"},"href":"https://api.spotify.com/v1/albums/7G7sz71wV7PLd4mi3vb44s","id":"7G7sz71wV7PLd4mi3vb44s","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27329210b1922d3a7887c5deb39"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0229210b1922d3a7887c5deb39"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485129210b1922d3a7887c5deb39"}],"is_playable":true,"name":"Het Land van Vriendschap","release_date":"2019-09-27","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:7G7sz71wV7PLd4mi3vb44s"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GxCjxM4YUabJgybJq06XT"},"href":"https://api.spotify.com/v1/artists/3GxCjxM4YUabJgybJq06XT","id":"3GxCjxM4YUabJgybJq06XT","name":"Lange Frans & Baas B","type":"artist","uri":"spotify:artist:3GxCjxM4YUabJgybJq06XT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":252077,"explicit":false,"external_ids":{"isrc":"QM7281988518"},"external_urls":{"spotify":"https://open.spotify.com/track/681hSZvGVUWR9K5CUxLqMD"},"href":"https://api.spotify.com/v1/tracks/681hSZvGVUWR9K5CUxLqMD","id":"681hSZvGVUWR9K5CUxLqMD","is_local":false,"is_playable":true,"name":"Het Land van Vriendschap","track_number":1,"type":"track","uri":"spotify:track:681hSZvGVUWR9K5CUxLqMD"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/6um3VlGOcC7PWzcKeYidCV"},"href":"https://api.spotify.com/v1/albums/6um3VlGOcC7PWzcKeYidCV","id":"6um3VlGOcC7PWzcKeYidCV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e2e4b4cf54573a895f7defa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e2e4b4cf54573a895f7defa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e2e4b4cf54573a895f7defa"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-08-10","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:6um3VlGOcC7PWzcKeYidCV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":262706,"explicit":false,"external_ids":{"isrc":"NLG270500123"},"external_urls":{"spotify":"https://open.spotify.com/track/5dpiBQNmK5XzdELUZoOmA7"},"href":"https://api.spotify.com/v1/tracks/5dpiBQNmK5XzdELUZoOmA7","id":"5dpiBQNmK5XzdELUZoOmA7","is_local":false,"is_playable":true,"name":"Het Land Van - Live","track_number":1,"type":"track","uri":"spotify:track:5dpiBQNmK5XzdELUZoOmA7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/7KNScUfntGmEglib8BOvIw"},"href":"https://api.spotify.com/v1/albums/7KNScUfntGmEglib8BOvIw","id":"7KNScUfntGmEglib8BOvIw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27315e20f9f09d1134c65cf5057"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0215e20f9f09d1134c65cf5057"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485115e20f9f09d1134c65cf5057"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-01-01","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:7KNScUfntGmEglib8BOvIw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":187986,"explicit":false,"external_ids":{"isrc":"NLG270500173"},"external_urls":{"spotify":"https://open.spotify.com/track/453xQsT2HNx19OVj4SEc1U"},"href":"https://api.spotify.com/v1/tracks/453xQsT2HNx19OVj4SEc1U","id":"453xQsT2HNx19OVj4SEc1U","is_local":false,"is_playable":true,"name":"Dit Moet Een Zondag Zijn","track_number":16,"type":"track","uri":"spotify:track:453xQsT2HNx19OVj4SEc1U"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/7KNScUfntGmEglib8BOvIw"},"href":"https://api.spotify.com/v1/albums/7KNScUfntGmEglib8BOvIw","id":"7KNScUfntGmEglib8BOvIw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27315e20f9f09d1134c65cf5057"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0215e20f9f09d1134c65cf5057"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485115e20f9f09d1134c65cf5057"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-01-01","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:7KNScUfntGmEglib8BOvIw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":207146,"explicit":false,"external_ids":{"isrc":"NLG270500170"},"external_urls":{"spotify":"https://open.spotify.com/track/5Ax8TA48MXiDo4b1UJCzV3"},"href":"https://api.spotify.com/v1/tracks/5Ax8TA48MXiDo4b1UJCzV3","id":"5Ax8TA48MXiDo4b1UJCzV3","is_local":false,"is_playable":true,"name":"Testament","track_number":12,"type":"track","uri":"spotify:track:5Ax8TA48MXiDo4b1UJCzV3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/7KNScUfntGmEglib8BOvIw"},"href":"https://api.spotify.com/v1/albums/7KNScUfntGmEglib8BOvIw","id":"7KNScUfntGmEglib8BOvIw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27315e20f9f09d1134c65cf5057"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0215e20f9f09d1134c65cf5057"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485115e20f9f09d1134c65cf5057"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-01-01","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:7KNScUfntGmEglib8BOvIw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":188826,"explicit":false,"external_ids":{"isrc":"NLG270500174"},"external_urls":{"spotify":"https://open.spotify.com/track/2snLLpemGkrHJ5U9WiHwyP"},"href":"https://api.spotify.com/v1/tracks/2snLLpemGkrHJ5U9WiHwyP","id":"2snLLpemGkrHJ5U9WiHwyP","is_local":false,"is_playable":true,"name":"Jonge Moeders","track_number":11,"type":"track","uri":"spotify:track:2snLLpemGkrHJ5U9WiHwyP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/7KNScUfntGmEglib8BOvIw"},"href":"https://api.spotify.com/v1/albums/7KNScUfntGmEglib8BOvIw","id":"7KNScUfntGmEglib8BOvIw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27315e20f9f09d1134c65cf5057"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0215e20f9f09d1134c65cf5057"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485115e20f9f09d1134c65cf5057"}],"is_playable":true,"name":"Het Land Van","release_date":"2005-01-01","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:7KNScUfntGmEglib8BOvIw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2nQWjd0HWySFaoH7EcW4PO"},"href":"https://api.spotify.com/v1/artists/2nQWjd0HWySFaoH7EcW4PO","id":"2nQWjd0HWySFaoH7EcW4PO","name":"Rollarocka","type":"artist","uri":"spotify:artist:2nQWjd0HWySFaoH7EcW4PO"}],"disc_number":1,"duration_ms":256066,"explicit":false,"external_ids":{"isrc":"NLG270500165"},"external_urls":{"spotify":"https://open.spotify.com/track/4vsmORwY7gdvZXiN4gc5V3"},"href":"https://api.spotify.com/v1/tracks/4vsmORwY7gdvZXiN4gc5V3","id":"4vsmORwY7gdvZXiN4gc5V3","is_local":false,"is_playable":true,"name":"Gedoogbeleid","track_number":6,"type":"track","uri":"spotify:track:4vsmORwY7gdvZXiN4gc5V3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l5sWxJhBcsUTN00u33vgf"},"href":"https://api.spotify.com/v1/albums/4l5sWxJhBcsUTN00u33vgf","id":"4l5sWxJhBcsUTN00u33vgf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6376faaee805193164ae229"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6376faaee805193164ae229"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6376faaee805193164ae229"}],"is_playable":true,"name":"Supervisie","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4l5sWxJhBcsUTN00u33vgf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":199746,"explicit":false,"external_ids":{"isrc":"NLG270400037"},"external_urls":{"spotify":"https://open.spotify.com/track/3xJFoFhytOgP1qnJrPT9Qk"},"href":"https://api.spotify.com/v1/tracks/3xJFoFhytOgP1qnJrPT9Qk","id":"3xJFoFhytOgP1qnJrPT9Qk","is_local":false,"is_playable":true,"name":"Supervisie","track_number":11,"type":"track","uri":"spotify:track:3xJFoFhytOgP1qnJrPT9Qk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"external_urls":{"spotify":"https://open.spotify.com/album/6V6OQnnbZ0BDmpi9BX2KXp"},"href":"https://api.spotify.com/v1/albums/6V6OQnnbZ0BDmpi9BX2KXp","id":"6V6OQnnbZ0BDmpi9BX2KXp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730338c073e66725096b2d954d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020338c073e66725096b2d954d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510338c073e66725096b2d954d"}],"is_playable":true,"name":"Supervisie","release_date":"2004-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:6V6OQnnbZ0BDmpi9BX2KXp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5I2d294l90n7EMWVNUZczE"},"href":"https://api.spotify.com/v1/artists/5I2d294l90n7EMWVNUZczE","id":"5I2d294l90n7EMWVNUZczE","name":"Lange Frans","type":"artist","uri":"spotify:artist:5I2d294l90n7EMWVNUZczE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UYP8NXUoN2bFx7sylWQ14"},"href":"https://api.spotify.com/v1/artists/2UYP8NXUoN2bFx7sylWQ14","id":"2UYP8NXUoN2bFx7sylWQ14","name":"Baas B","type":"artist","uri":"spotify:artist:2UYP8NXUoN2bFx7sylWQ14"}],"disc_number":1,"duration_ms":199746,"explicit":false,"external_ids":{"isrc":"NLG270400037"},"external_urls":{"spotify":"https://open.spotify.com/track/4qU7pEMwYYvEYmXqsUtHCg"},"href":"https://api.spotify.com/v1/tracks/4qU7pEMwYYvEYmXqsUtHCg","id":"4qU7pEMwYYvEYmXqsUtHCg","is_local":false,"is_playable":true,"name":"Supervisie","track_number":2,"type":"track","uri":"spotify:track:4qU7pEMwYYvEYmXqsUtHCg"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1IZXQlMjBMYW5kJTIwVmFuLi4uJTIwTGFuZ2UlMjBGcmFucyUyQyUyMEJhYXMlMjBCJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9zZWFyY2g/b2Zmc2V0PTEwJmxpbWl0PTEwJnF1ZXJ5PUhldCUyMExhbmQlMjBWYW4uLi4lMjBMYW5nZSUyMEZyYW5zJTJDJTIwQmFhcyUyMEImdHlwZT10cmFjayIsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyMCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMv", + "MlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ1bTNWbEdPY0M3UFd6Y0tlWWlkQ1YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82dW0zVmxHT2NDN1BXemNLZVlpZENWIiwiaWQiOiI2dW0zVmxHT2NDN1BXemNLZVlpZENWIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzdlMmU0YjRjZjU0NTczYTg5NWY3ZGVmYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3ZTJlNGI0Y2Y1NDU3M2E4OTVmN2RlZmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTdlMmU0YjRjZjU0NTczYTg5NWY3ZGVmYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXQgTGFuZCBWYW4iLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTA4LTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2dW0zVmxHT2NDN1BXemNLZVlpZENWIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwiaWQiOiI1STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwibmFtZSI6IkxhbmdlIEZyYW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwiaWQiOiIyVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwibmFtZSI6IkJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVVlQOE5YVW9OMmJGeDdzeWxXUTE0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzMDQ0MA==", + "LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHMjcwNTAwMTI0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wd01Bc0w5OFRHdUk2ZVdVRW9jZDFPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMHdNQXNMOThUR3VJNmVXVUVvY2QxTyIsImlkIjoiMHdNQXNMOThUR3VJNmVXVUVvY2QxTyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXQgTGFuZCBWYW4iLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHdNQXNMOThUR3VJNmVXVUVvY2QxTyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJpZCI6IjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJuYW1lIjoiQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83S05TY1VmbnRHbUVnbGliOEJPdkl3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0tOU2NVZm50R21FZ2xpYjhCT3ZJdyIsImlkIjoiN0tOU2NVZm50R21FZ2xpYjhCT3ZJdyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNWUyMGY5ZjA5ZDExMzRjNjVjZjUwNTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTVlMjBmOWYwOWQxMTM0YzY1Y2Y1MDU3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zYw==", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXQgTGFuZCBWYW4iLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0tOU2NVZm50R21FZ2xpYjhCT3ZJdyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjI3MDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEcyNzA1MDAxMjMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdiT0xEcDFYVEZVVld2QVJSMklod0IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83Yk9MRHAxWFRGVVZXdkFSUjJJaHdCIiwiaWQiOiI3Yk9MRHAxWFRGVVZXdkFSUjJJaHdCIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBMYW5kIFZhbiAtIExpdmUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2JPTERwMVhURlVWV3ZBUlIySWh3QiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0d4Q2p4TTRZVWFiSmd5YkpxMDZYVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zR3hDanhNNFlVYWJKZw==", + "eWJKcTA2WFQiLCJpZCI6IjNHeENqeE00WVVhYkpneWJKcTA2WFQiLCJuYW1lIjoiTGFuZ2UgRnJhbnMgJiBCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0d4Q2p4TTRZVWFiSmd5YkpxMDZYVCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJpZCI6IjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJuYW1lIjoiQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83Rzdzejcxd1Y3UExkNG1pM3ZiNDRzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0c3c3o3MXdWN1BMZDRtaTN2YjQ0cyIsImlkIjoiN0c3c3o3MXdWN1BMZDRtaTN2YjQ0cyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyOTIxMGIxOTIyZDNhNzg4N2M1ZGViMzkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMjkyMTBiMTkyMmQzYTc4ODdjNWRlYjM5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyOTIxMGIxOTIyZDNhNzg4N2M1ZGViMzkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGV0IExhbmQgdmFuIFZyaWVuZHNjaGFwIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wOS0yNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0c3c3o3MXdWN1BMZDRtaTN2YjQ0cyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZg==", + "eSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0d4Q2p4TTRZVWFiSmd5YkpxMDZYVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zR3hDanhNNFlVYWJKZ3liSnEwNlhUIiwiaWQiOiIzR3hDanhNNFlVYWJKZ3liSnEwNlhUIiwibmFtZSI6IkxhbmdlIEZyYW5zICYgQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNHeENqeE00WVVhYkpneWJKcTA2WFQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwiaWQiOiI1STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwibmFtZSI6IkxhbmdlIEZyYW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwiaWQiOiIyVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwibmFtZSI6IkJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVVlQOE5YVW9OMmJGeDdzeWxXUTE0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1MjA3NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFNNzI4MTk4ODUxOCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNjgxaFNadkdWVVdSOUs1Q1V4THFNRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzY4MWhTWnZHVlVXUjlLNUNVeExxTUQiLCJpZCI6IjY4MWhTWnZHVlVXUjlLNUNVeExxTUQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGV0IExhbmQgdmFuIFZyaWVuZHNjaGFwIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjY4MWhTWnZHVlVXUjlLNUNVeExxTUQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZA==", + "Mjk0bDkwbjdFTVdWTlVaY3pFIiwiaWQiOiI1STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwibmFtZSI6IkxhbmdlIEZyYW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwiaWQiOiIyVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwibmFtZSI6IkJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVVlQOE5YVW9OMmJGeDdzeWxXUTE0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNnVtM1ZsR09jQzdQV3pjS2VZaWRDViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZ1bTNWbEdPY0M3UFd6Y0tlWWlkQ1YiLCJpZCI6IjZ1bTNWbEdPY0M3UFd6Y0tlWWlkQ1YiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2UyZTRiNGNmNTQ1NzNhODk1ZjdkZWZhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdlMmU0YjRjZjU0NTczYTg5NWY3ZGVmYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2UyZTRiNGNmNTQ1NzNhODk1ZjdkZWZhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBMYW5kIFZhbiIsInJlbGVhc2VfZGF0ZSI6IjIwMDUtMDgtMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZ1bTNWbEdPY0M3UFd6Y0tlWWlkQ1YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Lw==", + "L29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjI3MDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEcyNzA1MDAxMjMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVkcGlCUU5tSzVYemRFTFVab09tQTcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81ZHBpQlFObUs1WHpkRUxVWm9PbUE3IiwiaWQiOiI1ZHBpQlFObUs1WHpkRUxVWm9PbUE3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBMYW5kIFZhbiAtIExpdmUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NWRwaUJRTm1LNVh6ZEVMVVpvT21BNyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJpZCI6IjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJuYW1lIjoiQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83S05TY1VmbnRHbUVnbGliOEJPdkl3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0tOU2NVZm50R21FZ2xpYjhCT3ZJdyIsImlkIjoiN0tOU2NVZg==", + "bnRHbUVnbGliOEJPdkl3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNWUyMGY5ZjA5ZDExMzRjNjVjZjUwNTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXQgTGFuZCBWYW4iLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0tOU2NVZm50R21FZ2xpYjhCT3ZJdyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODc5ODYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEcyNzA1MDAxNzMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzQ1M3hRc1QySE54MTlPVmo0U0VjMVUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80NTN4UXNUMkhOeDE5T1ZqNFNFYzFVIiwiaWQiOiI0NTN4UXNUMkhOeDE5T1ZqNFNFYzFVIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpdCBNb2V0IEVlbiBabw==", + "bmRhZyBaaWpuIiwidHJhY2tfbnVtYmVyIjoxNiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0NTN4UXNUMkhOeDE5T1ZqNFNFYzFVIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdLTlNjVWZudEdtRWdsaWI4Qk92SXcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83S05TY1VmbnRHbUVnbGliOEJPdkl3IiwiaWQiOiI3S05TY1VmbnRHbUVnbGliOEJPdkl3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNWUyMGY5ZjA5ZDExMzRjNjVjZjUwNTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXQgTGFuZCBWYW4iLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0tOU2NVZm50R21FZ2xpYjhCT3ZJdyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovLw==", + "b3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwiaWQiOiI1STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwibmFtZSI6IkxhbmdlIEZyYW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwiaWQiOiIyVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwibmFtZSI6IkJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVVlQOE5YVW9OMmJGeDdzeWxXUTE0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNzE0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzI3MDUwMDE3MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNUF4OFRBNDhNWGlEbzRiMVVKQ3pWMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVBeDhUQTQ4TVhpRG80YjFVSkN6VjMiLCJpZCI6IjVBeDhUQTQ4TVhpRG80YjFVSkN6VjMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGVzdGFtZW50IiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1QXg4VEE0OE1YaURvNGIxVUpDelYzIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTg==", + "MmJGeDdzeWxXUTE0IiwibmFtZSI6IkJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVVlQOE5YVW9OMmJGeDdzeWxXUTE0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN0tOU2NVZm50R21FZ2xpYjhCT3ZJdyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdLTlNjVWZudEdtRWdsaWI4Qk92SXciLCJpZCI6IjdLTlNjVWZudEdtRWdsaWI4Qk92SXciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMTVlMjBmOWYwOWQxMTM0YzY1Y2Y1MDU3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTVlMjBmOWYwOWQxMTM0YzY1Y2Y1MDU3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBMYW5kIFZhbiIsInJlbGVhc2VfZGF0ZSI6IjIwMDUtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3S05TY1VmbnRHbUVnbGliOEJPdkl3In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwiaWQiOiI1STJkMjk0bDkwbjdFTVdWTlVaY3pFIiwibmFtZSI6IkxhbmdlIEZyYW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSx7ImV4", + "dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwiaWQiOiIyVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwibmFtZSI6IkJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVVlQOE5YVW9OMmJGeDdzeWxXUTE0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4ODgyNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzI3MDUwMDE3NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMnNuTExwZW1Ha3JISjVVOVdpSHd5UCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJzbkxMcGVtR2tySEo1VTlXaUh3eVAiLCJpZCI6IjJzbkxMcGVtR2tySEo1VTlXaUh3eVAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSm9uZ2UgTW9lZGVycyIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MnNuTExwZW1Ha3JISjVVOVdpSHd5UCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJpZCI6IjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJuYW1lIjoiQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83S05TY1VmbnRHbUVnbGliOEJPdkl3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0tOU2NVZm50Rw==", + "bUVnbGliOEJPdkl3IiwiaWQiOiI3S05TY1VmbnRHbUVnbGliOEJPdkl3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNWUyMGY5ZjA5ZDExMzRjNjVjZjUwNTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE1ZTIwZjlmMDlkMTEzNGM2NWNmNTA1NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXQgTGFuZCBWYW4iLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0tOU2NVZm50R21FZ2xpYjhCT3ZJdyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yblFXamQwSFd5U0Zhb0g3RWNXNFBPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJuUVdqZDBIV3lTRmFvSDdFY1c0UE8iLCJpZCI6IjJuUVdqZDBIV3lTRmFvSDdFY1c0UE8iLCJuYW1lIjoiUm9sbGFyb2NrYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyblFXamQwSFd5U0Zhb0g3RWNXNFBPIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1NjA2NiwiZQ==", + "eHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHMjcwNTAwMTY1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80dnNtT1J3WTdnZHZaWGlONGdjNVYzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNHZzbU9Sd1k3Z2R2WlhpTjRnYzVWMyIsImlkIjoiNHZzbU9Sd1k3Z2R2WlhpTjRnYzVWMyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHZWRvb2diZWxlaWQiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NHZzbU9Sd1k3Z2R2WlhpTjRnYzVWMyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJpZCI6IjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJuYW1lIjoiQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80bDVzV3hKaEJjc1VUTjAwdTMzdmdmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNGw1c1d4SmhCY3NVVE4wMHUzM3ZnZiIsImlkIjoiNGw1c1d4SmhCY3NVVE4wMHUzM3ZnZiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiNjM3NmZhYWVlODA1MTkzMTY0YWUyMjkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjYzNzZmYWFlZTgwNTE5MzE2NGFlMjI5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLg==", + "Y28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI2Mzc2ZmFhZWU4MDUxOTMxNjRhZTIyOSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdXBlcnZpc2llIiwicmVsZWFzZV9kYXRlIjoiMjAwNC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRsNXNXeEpoQmNzVVROMDB1MzN2Z2YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZCI6IjVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJuYW1lIjoiTGFuZ2UgRnJhbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUkyZDI5NGw5MG43RU1XVk5VWmN6RSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJpZCI6IjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQiLCJuYW1lIjoiQmFhcyBCIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk5NzQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxHMjcwNDAwMDM3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zeEpGb0ZoeXRPZ1AxcW5KclBUOVFrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM3hKRm9GaHl0T2dQMXFuSnJQVDlRayIsImlkIjoiM3hKRm9GaHl0T2dQMXFuSnJQVDlRayIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdXBlcnZpc2llIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozeEpGb0ZoeXRPZ1AxcW5KclBUOVFrIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUiLCJpZA==", + "IjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVWVA4TlhVb04yYkZ4N3N5bFdRMTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsImlkIjoiMlVZUDhOWFVvTjJiRng3c3lsV1ExNCIsIm5hbWUiOiJCYWFzIEIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZWNk9Rbm5iWjBCRG1waTlCWDJLWHAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82VjZPUW5uYlowQkRtcGk5QlgyS1hwIiwiaWQiOiI2VjZPUW5uYlowQkRtcGk5QlgyS1hwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzAzMzhjMDczZTY2NzI1MDk2YjJkOTU0ZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwMzM4YzA3M2U2NjcyNTA5NmIyZDk1NGQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAzMzhjMDczZTY2NzI1MDk2YjJkOTU0ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdXBlcnZpc2llIiwicmVsZWFzZV9kYXRlIjoiMjAwNC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlY2T1FubmJaMEJEbXBpOUJYMktYcCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJMmQyOTRsOTBuN0VNV1ZOVVpjekUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsImlkIjoiNUkyZDI5NGw5MG43RU1XVk5VWmN6RSIsIm5hbWUiOiJMYW5nZSBGcmFucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1STJkMjk0bDkwbjdFTVdWTlVaY3pFIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lw==", + "MlVZUDhOWFVvTjJiRng3c3lsV1ExNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwiaWQiOiIyVVlQOE5YVW9OMmJGeDdzeWxXUTE0IiwibmFtZSI6IkJhYXMgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVVlQOE5YVW9OMmJGeDdzeWxXUTE0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5OTc0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MRzI3MDQwMDAzNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNHFVN3BFTXdZWXZFWW1YcXNVdEhDZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRxVTdwRU13WVl2RVltWHFzVXRIQ2ciLCJpZCI6IjRxVTdwRU13WVl2RVltWHFzVXRIQ2ciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VwZXJ2aXNpZSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0cVU3cEVNd1lZdkVZbVhxc1V0SENnIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Het+Land+Van...+Lange+Frans%2C+Baas+B&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Nobody%27s%20Wife%22%20artist%3A%22Anouk%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"external_urls":{"spotify":"https://open.spotify.com/album/3zMAFbz27Bd7gtmPFAq46b"},"href":"https://api.spotify.com/v1/albums/3zMAFbz27Bd7gtmPFAq46b","id":"3zMAFbz27Bd7gtmPFAq46b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27300a5b98285f6b0e7f4a2eb6a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0200a5b98285f6b0e7f4a2eb6a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485100a5b98285f6b0e7f4a2eb6a"}],"is_playable":true,"name":"Together Alone","release_date":"1997-01-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:3zMAFbz27Bd7gtmPFAq46b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"disc_number":1,"duration_ms":205733,"explicit":false,"external_ids":{"isrc":"NLA959700182"},"external_urls":{"spotify":"https://open.spotify.com/track/1Q0p30HuN1ADMX2CmPzIvO"},"href":"https://api.spotify.com/v1/tracks/1Q0p30HuN1ADMX2CmPzIvO","id":"1Q0p30HuN1ADMX2CmPzIvO","is_local":false,"is_playable":true,"name":"Nobody's Wife","track_number":1,"type":"track","uri":"spotify:track:1Q0p30HuN1ADMX2CmPzIvO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"external_urls":{"spotify":"https://open.spotify.com/album/2noa35OTmFnShroXPBACoW"},"href":"https://api.spotify.com/v1/albums/2noa35OTmFnShroXPBACoW","id":"2noa35OTmFnShroXPBACoW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739b911dc44132e2d64a1b6c78"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029b911dc44132e2d64a1b6c78"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519b911dc44132e2d64a1b6c78"}],"is_playable":true,"name":"Live At Gelredome","release_date":"2008-01-01","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:2noa35OTmFnShroXPBACoW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"disc_number":2,"duration_ms":329266,"explicit":false,"external_ids":{"isrc":"NLA270800161"},"external_urls":{"spotify":"https://open.spotify.com/track/5CiWnFgk96XjGlBmhLZ2pm"},"href":"https://api.spotify.com/v1/tracks/5CiWnFgk96XjGlBmhLZ2pm","id":"5CiWnFgk96XjGlBmhLZ2pm","is_local":false,"is_playable":true,"name":"Nobody's Wife - Live At Gelredome","track_number":10,"type":"track","uri":"spotify:track:5CiWnFgk96XjGlBmhLZ2pm"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"external_urls":{"spotify":"https://open.spotify.com/album/5I7NfuLdkppTGHhYIapq7V"},"href":"https://api.spotify.com/v1/albums/5I7NfuLdkppTGHhYIapq7V","id":"5I7NfuLdkppTGHhYIapq7V","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739d75572a0ebe4ceeec0e5623"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029d75572a0ebe4ceeec0e5623"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519d75572a0ebe4ceeec0e5623"}],"is_playable":true,"name":"Lost Tracks","release_date":"2003-06-16","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:5I7NfuLdkppTGHhYIapq7V"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"disc_number":1,"duration_ms":338000,"explicit":false,"external_ids":{"isrc":"NLA950100035"},"external_urls":{"spotify":"https://open.spotify.com/track/3j94v2l46MEg4FZm60fKtI"},"href":"https://api.spotify.com/v1/tracks/3j94v2l46MEg4FZm60fKtI","id":"3j94v2l46MEg4FZm60fKtI","is_local":false,"is_playable":true,"name":"Nobody's Wife - 2 Meter Sessie Reggae Version","track_number":8,"type":"track","uri":"spotify:track:3j94v2l46MEg4FZm60fKtI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"external_urls":{"spotify":"https://open.spotify.com/album/3sBNTbY1BCtkLUxv4jvsQ1"},"href":"https://api.spotify.com/v1/albums/3sBNTbY1BCtkLUxv4jvsQ1","id":"3sBNTbY1BCtkLUxv4jvsQ1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27328e0dcdceda615d64232c991"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0228e0dcdceda615d64232c991"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485128e0dcdceda615d64232c991"}],"is_playable":true,"name":"Anouk Is Alive","release_date":"2006-01-01","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:3sBNTbY1BCtkLUxv4jvsQ1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"disc_number":2,"duration_ms":345280,"explicit":false,"external_ids":{"isrc":"NLA950600197"},"external_urls":{"spotify":"https://open.spotify.com/track/4cY01pIv2RqtyLG2TJ8zVD"},"href":"https://api.spotify.com/v1/tracks/4cY01pIv2RqtyLG2TJ8zVD","id":"4cY01pIv2RqtyLG2TJ8zVD","is_local":false,"is_playable":true,"name":"Nobody's Wife - Live","track_number":9,"type":"track","uri":"spotify:track:4cY01pIv2RqtyLG2TJ8zVD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"external_urls":{"spotify":"https://open.spotify.com/album/0fPmkfXEIRh4GxHL4w0jKK"},"href":"https://api.spotify.com/v1/albums/0fPmkfXEIRh4GxHL4w0jKK","id":"0fPmkfXEIRh4GxHL4w0jKK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cbb2aa2cef8a3fc2eaa6423a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cbb2aa2cef8a3fc2eaa6423a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cbb2aa2cef8a3fc2eaa6423a"}],"is_playable":true,"name":"Live At Symphonica In Rosso","release_date":"2014-01-01","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:0fPmkfXEIRh4GxHL4w0jKK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"disc_number":2,"duration_ms":420560,"explicit":false,"external_ids":{"isrc":"NLXA91400023"},"external_urls":{"spotify":"https://open.spotify.com/track/1kCRGYPnPLfZpw7QIlUlyL"},"href":"https://api.spotify.com/v1/tracks/1kCRGYPnPLfZpw7QIlUlyL","id":"1kCRGYPnPLfZpw7QIlUlyL","is_local":false,"is_playable":true,"name":"Nobody's Wife - Live At Symphonica In Rosso","track_number":11,"type":"track","uri":"spotify:track:1kCRGYPnPLfZpw7QIlUlyL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2H6DPjcMaPbCZzxINySIQD"},"href":"https://api.spotify.com/v1/albums/2H6DPjcMaPbCZzxINySIQD","id":"2H6DPjcMaPbCZzxINySIQD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bb01568108f9156dbfe59684"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bb01568108f9156dbfe59684"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bb01568108f9156dbfe59684"}],"is_playable":true,"name":"Het Beste Uit De Top 2000 (Editie 2017)","release_date":"2017-11-17","release_date_precision":"day","total_tracks":36,"type":"album","uri":"spotify:album:2H6DPjcMaPbCZzxINySIQD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"disc_number":1,"duration_ms":206866,"explicit":false,"external_ids":{"isrc":"NLA959700182"},"external_urls":{"spotify":"https://open.spotify.com/track/0ya5hXVqUVcHq6DBoIzxSF"},"href":"https://api.spotify.com/v1/tracks/0ya5hXVqUVcHq6DBoIzxSF","id":"0ya5hXVqUVcHq6DBoIzxSF","is_local":false,"is_playable":true,"name":"Nobody's Wife","track_number":16,"type":"track","uri":"spotify:track:0ya5hXVqUVcHq6DBoIzxSF"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/594ZrosvqgjcTQKW7vbJDp"},"href":"https://api.spotify.com/v1/albums/594ZrosvqgjcTQKW7vbJDp","id":"594ZrosvqgjcTQKW7vbJDp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ba03216c4d12279382386300"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ba03216c4d12279382386300"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ba03216c4d12279382386300"}],"is_playable":true,"name":"Essential: Car Classics","release_date":"2011-06-24","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:594ZrosvqgjcTQKW7vbJDp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ltVunYjAAD70YtVO6rxvX"},"href":"https://api.spotify.com/v1/artists/6ltVunYjAAD70YtVO6rxvX","id":"6ltVunYjAAD70YtVO6rxvX","name":"Anouk","type":"artist","uri":"spotify:artist:6ltVunYjAAD70YtVO6rxvX"}],"disc_number":1,"duration_ms":204960,"explicit":false,"external_ids":{"isrc":"NLA959700182"},"external_urls":{"spotify":"https://open.spotify.com/track/3UJNTGg61zPmXTeVma7sSA"},"href":"https://api.spotify.com/v1/tracks/3UJNTGg61zPmXTeVma7sSA","id":"3UJNTGg61zPmXTeVma7sSA","is_local":false,"is_playable":true,"name":"Nobody's Wife","track_number":19,"type":"track","uri":"spotify:track:3UJNTGg61zPmXTeVma7sSA"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk5vYm9keSUyN3MlMjBXaWZlJTIyJTIwYXJ0aXN0JTNBJTIyQW5vdWslMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjcsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM3pNQUZiejI3QmQ3Z3RtUEZBcTQ2YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzN6TUFGYnoyN0JkN2d0bVBGQXE0NmIiLCJpZCI6IjN6TUFGYnoyN0JkN2d0bVBGQXE0NmIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9h", + "YjY3NjE2ZDAwMDBiMjczMDBhNWI5ODI4NWY2YjBlN2Y0YTJlYjZhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjAwYTViOTgyODVmNmIwZTdmNGEyZWI2YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDBhNWI5ODI4NWY2YjBlN2Y0YTJlYjZhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvZ2V0aGVyIEFsb25lIiwicmVsZWFzZV9kYXRlIjoiMTk5Ny0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjN6TUFGYnoyN0JkN2d0bVBGQXE0NmIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJpZCI6IjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJuYW1lIjoiQW5vdWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDU3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEE5NTk3MDAxODIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFRMHAzMEh1TjFBRE1YMkNtUHpJdk8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xUTBwMzBIdU4xQURNWDJDbVB6SXZPIiwiaWQiOiIxUTBwMzBIdU4xQURNWDJDbVB6SXZPIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vYm9keSdzIFdpZmUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MVEwcDMwSHVOMUFETVgyQ21Qekl2TyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJpZCI6IjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJuYW1lIjoiQW5vdWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcg==", + "dGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMm5vYTM1T1RtRm5TaHJvWFBCQUNvVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJub2EzNU9UbUZuU2hyb1hQQkFDb1ciLCJpZCI6IjJub2EzNU9UbUZuU2hyb1hQQkFDb1ciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWI5MTFkYzQ0MTMyZTJkNjRhMWI2Yzc4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjliOTExZGM0NDEzMmUyZDY0YTFiNmM3OCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWI5MTFkYzQ0MTMyZTJkNjRhMWI2Yzc4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxpdmUgQXQgR2VscmVkb21lIiwicmVsZWFzZV9kYXRlIjoiMjAwOC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJub2EzNU9UbUZuU2hyb1hQQkFDb1cifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJpZCI6IjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJuYW1lIjoiQW5vdWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjozMjkyNjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEEyNzA4MDAxNjEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVDaVduRmdrOTZYakdsQm1oTFoycG0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81Q2lXbkZnazk2WGpHbEJtaExaMnBtIiwiaWQiOiI1Q2lXbkZnazk2WGpHbEJtaExaMnBtIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vYm9keSdzIFdpZmUgLSBMaXZlIEF0IEdlbHJlZG9tZSIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dA==", + "cmFjazo1Q2lXbkZnazk2WGpHbEJtaExaMnBtIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUk3TmZ1TGRrcHBUR0hoWUlhcHE3ViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVJN05mdUxka3BwVEdIaFlJYXBxN1YiLCJpZCI6IjVJN05mdUxka3BwVEdIaFlJYXBxN1YiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWQ3NTU3MmEwZWJlNGNlZWVjMGU1NjIzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjlkNzU1NzJhMGViZTRjZWVlYzBlNTYyMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWQ3NTU3MmEwZWJlNGNlZWVjMGU1NjIzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikxvc3QgVHJhY2tzIiwicmVsZWFzZV9kYXRlIjoiMjAwMy0wNi0xNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVJN05mdUxka3BwVEdIaFlJYXBxN1YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJpZCI6IjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJuYW1lIjoiQW5vdWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMzgwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEE5NTAxMDAwMzUifSwiZXh0ZXJuYWxfdQ==", + "cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2o5NHYybDQ2TUVnNEZabTYwZkt0SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNqOTR2Mmw0Nk1FZzRGWm02MGZLdEkiLCJpZCI6IjNqOTR2Mmw0Nk1FZzRGWm02MGZLdEkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTm9ib2R5J3MgV2lmZSAtIDIgTWV0ZXIgU2Vzc2llIFJlZ2dhZSBWZXJzaW9uIiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNqOTR2Mmw0Nk1FZzRGWm02MGZLdEkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIiwiaWQiOiI2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIiwibmFtZSI6IkFub3VrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zc0JOVGJZMUJDdGtMVXh2NGp2c1ExIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM3NCTlRiWTFCQ3RrTFV4djRqdnNRMSIsImlkIjoiM3NCTlRiWTFCQ3RrTFV4djRqdnNRMSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyOGUwZGNkY2VkYTYxNWQ2NDIzMmM5OTEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMjhlMGRjZGNlZGE2MTVkNjQyMzJjOTkxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyOGUwZGNkY2VkYTYxNWQ2NDIzMmM5OTEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQW5vdWsgSXMgQWxpdmUiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M3NCTlRiWTFCQ3RrTFV4djRqdnNRMSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYQ==", + "cnRpc3QvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIiwiaWQiOiI2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIiwibmFtZSI6IkFub3VrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MzQ1MjgwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxBOTUwNjAwMTk3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80Y1kwMXBJdjJScXR5TEcyVEo4elZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGNZMDFwSXYyUnF0eUxHMlRKOHpWRCIsImlkIjoiNGNZMDFwSXYyUnF0eUxHMlRKOHpWRCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOb2JvZHkncyBXaWZlIC0gTGl2ZSIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0Y1kwMXBJdjJScXR5TEcyVEo4elZEIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMGZQbWtmWEVJUmg0R3hITDR3MGpLSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBmUG1rZlhFSVJoNEd4SEw0dzBqS0siLCJpZCI6IjBmUG1rZlhFSVJoNEd4SEw0dzBqS0siLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczY2JiMmFhMmNlZjhhM2ZjMmVhYTY0MjNhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmNiYjJhYTJjZWY4YTNmYzJlYWE2NDIzYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3Ng==", + "MTZkMDAwMDQ4NTFjYmIyYWEyY2VmOGEzZmMyZWFhNjQyM2EifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGl2ZSBBdCBTeW1waG9uaWNhIEluIFJvc3NvIiwicmVsZWFzZV9kYXRlIjoiMjAxNC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBmUG1rZlhFSVJoNEd4SEw0dzBqS0sifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJpZCI6IjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJuYW1lIjoiQW5vdWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjo0MjA1NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFhBOTE0MDAwMjMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFrQ1JHWVBuUExmWnB3N1FJbFVseUwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xa0NSR1lQblBMZlpwdzdRSWxVbHlMIiwiaWQiOiIxa0NSR1lQblBMZlpwdzdRSWxVbHlMIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vYm9keSdzIFdpZmUgLSBMaXZlIEF0IFN5bXBob25pY2EgSW4gUm9zc28iLCJ0cmFja19udW1iZXIiOjExLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFrQ1JHWVBuUExmWnB3N1FJbFVseUwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkg2RFBqY01hUGJDWnp4SU55U0lRRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeQ==", + "LmNvbS92MS9hbGJ1bXMvMkg2RFBqY01hUGJDWnp4SU55U0lRRCIsImlkIjoiMkg2RFBqY01hUGJDWnp4SU55U0lRRCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiYjAxNTY4MTA4ZjkxNTZkYmZlNTk2ODQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmIwMTU2ODEwOGY5MTU2ZGJmZTU5Njg0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiYjAxNTY4MTA4ZjkxNTZkYmZlNTk2ODQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGV0IEJlc3RlIFVpdCBEZSBUb3AgMjAwMCAoRWRpdGllIDIwMTcpIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0xMS0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJINkRQamNNYVBiQ1p6eElOeVNJUUQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJpZCI6IjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJuYW1lIjoiQW5vdWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDY4NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEE5NTk3MDAxODIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzB5YTVoWFZxVVZjSHE2REJvSXp4U0YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8weWE1aFhWcVVWY0hxNkRCb0l6eFNGIiwiaWQiOiIweWE1aFhWcVVWY0hxNkRCb0l6eFNGIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vYm9keSdzIFdpZmUiLCJ0cmFja19udW1iZXIiOjE2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjB5YTVoWFZxVVZjSHE2REJvSXp4U0YifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMA==", + "THlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81OTRacm9zdnFnamNUUUtXN3ZiSkRwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNTk0WnJvc3ZxZ2pjVFFLVzd2YkpEcCIsImlkIjoiNTk0WnJvc3ZxZ2pjVFFLVzd2YkpEcCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiYTAzMjE2YzRkMTIyNzkzODIzODYzMDAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmEwMzIxNmM0ZDEyMjc5MzgyMzg2MzAwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiYTAzMjE2YzRkMTIyNzkzODIzODYzMDAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRXNzZW50aWFsOiBDYXIgQ2xhc3NpY3MiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTA2LTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NTk0WnJvc3ZxZ2pjVFFLVzd2YkpEcCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNDk2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTk1OTcwMDE4MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM1VKTlRHZzYxelBtWFRlVm1hN3NTQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhYw==", + "a3MvM1VKTlRHZzYxelBtWFRlVm1hN3NTQSIsImlkIjoiM1VKTlRHZzYxelBtWFRlVm1hN3NTQSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOb2JvZHkncyBXaWZlIiwidHJhY2tfbnVtYmVyIjoxOSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozVUpOVEdnNjF6UG1YVGVWbWE3c1NBIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Nobody%27s+Wife%22+artist%3A%22Anouk%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1LcnVpbWVsdGplJTIwQW5vdWsmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMXIxb2pTbjlUd1hXZVlZNDgxZFRSMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFyMW9qU245VHdYV2VZWTQ4MWRUUjEiLCJpZCI6IjFyMW9qU245VHdYV2VZWTQ4MWRUUjEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjk2ZGEyNjg1ODYyOWE0MDRlOTQ4YTdjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY5NmRhMjY4NTg2MjlhNDA0ZTk0OGE3YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjk2ZGEyNjg1ODYyOWE0MDRlOTQ4YTdjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlVyYmFuIFNvbGl0dWRlIiwicmVsZWFzZV9kYXRlIjoiMTk5OS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFyMW9qU245VHdYV2VZWTQ4MWRUUjEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJpZCI6IjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJuYW1lIjoiQW5vdWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDA0MDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEE5NTk5MDAxNzQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNGRDNnRXc4bzFLYjVPUEJacjhyaHkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zRkQzZ0V3OG8xS2I1T1BCWnI4cmh5IiwiaWQiOiIzRkQzZ0V3OG8xS2I1T1BCWnI4cmh5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlIgVSBLaWRkaW4nIE1lIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNGRDNnRXc4bzFLYjVPUEJacjhyaHkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIiwiaWQiOiI2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIiwibmFtZSI6IkFub3VrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zek1BRmJ6MjdCZDdndG1QRkFxNDZiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM3pNQUZiejI3QmQ3Z3RtUEZBcTQ2YiIsImlkIjoiM3pNQUZiejI3QmQ3Z3RtUEZBcTQ2YiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwMGE1Yjk4Mjg1ZjZiMGU3ZjRhMmViNmEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDBhNWI5ODI4NWY2YjBlN2Y0YTJlYjZhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwMGE1Yjk4Mjg1ZjZiMGU3ZjRhMmViNmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVG9nZXRoZXIgQWxvbmUiLCJyZWxlYXNlX2RhdGUiOiIxOTk3LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M3pNQUZiejI3QmQ3Z3RtUEZBcTQ2YiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNTczMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTk1OTcwMDE4MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVEwcDMwSHVOMUFETVgyQ21Qekl2TyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFRMHAzMEh1TjFBRE1YMkNtUHpJdk8iLCJpZCI6IjFRMHAzMEh1TjFBRE1YMkNtUHpJdk8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTm9ib2R5J3MgV2lmZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxUTBwMzBIdU4xQURNWDJDbVB6SXZPIn1dfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1LcnVpbWVsdGplJTIwQW5vdWsmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMXIxb2pTbjlUd1hXZVlZNDgxZFRSMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFyMW9qU245VHdYV2VZWTQ4MWRUUjEiLCJpZCI6IjFyMW9qU245VHdYV2VZWTQ4MWRUUjEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjk2ZGEyNjg1ODYyOWE0MDRlOTQ4YQ==", + "N2MifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjk2ZGEyNjg1ODYyOWE0MDRlOTQ4YTdjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmOTZkYTI2ODU4NjI5YTQwNGU5NDhhN2MifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVXJiYW4gU29saXR1ZGUiLCJyZWxlYXNlX2RhdGUiOiIxOTk5LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXIxb2pTbjlUd1hXZVlZNDgxZFRSMSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwMDQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTk1OTkwMDE3NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0ZEM2dFdzhvMUtiNU9QQlpyOHJoeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNGRDNnRXc4bzFLYjVPUEJacjhyaHkiLCJpZCI6IjNGRDNnRXc4bzFLYjVPUEJacjhyaHkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUiBVIEtpZGRpbicgTWUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0ZEM2dFdzhvMUtiNU9QQlpyOHJoeSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJpZCI6IjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJuYW1lIjoiQW5vdWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9XSwiZXh0ZQ==", + "cm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM3pNQUZiejI3QmQ3Z3RtUEZBcTQ2YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzN6TUFGYnoyN0JkN2d0bVBGQXE0NmIiLCJpZCI6IjN6TUFGYnoyN0JkN2d0bVBGQXE0NmIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDBhNWI5ODI4NWY2YjBlN2Y0YTJlYjZhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjAwYTViOTgyODVmNmIwZTdmNGEyZWI2YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDBhNWI5ODI4NWY2YjBlN2Y0YTJlYjZhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvZ2V0aGVyIEFsb25lIiwicmVsZWFzZV9kYXRlIjoiMTk5Ny0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjN6TUFGYnoyN0JkN2d0bVBGQXE0NmIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJpZCI6IjZsdFZ1bllqQUFENzBZdFZPNnJ4dlgiLCJuYW1lIjoiQW5vdWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDU3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEE5NTk3MDAxODIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFRMHAzMEh1TjFBRE1YMkNtUHpJdk8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xUTBwMzBIdU4xQURNWDJDbVB6SXZPIiwiaWQiOiIxUTBwMzBIdU4xQURNWDJDbVB6SXZPIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vYm9keSdzIFdpZmUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MVEwcDMwSHVOMUFETVgyQ21Qekl2TyJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Kruimeltje+Anouk&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Andalucia%20Chef%27Special&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5PlfkPxwCpRRWQJBxCa0By"},"href":"https://api.spotify.com/v1/artists/5PlfkPxwCpRRWQJBxCa0By","id":"5PlfkPxwCpRRWQJBxCa0By","name":"HUGEL","type":"artist","uri":"spotify:artist:5PlfkPxwCpRRWQJBxCa0By"},{"external_urls":{"spotify":"https://open.spotify.com/artist/541P8kParJeyWFaxfsEHdt"},"href":"https://api.spotify.com/v1/artists/541P8kParJeyWFaxfsEHdt","id":"541P8kParJeyWFaxfsEHdt","name":"GROSSOMODDO","type":"artist","uri":"spotify:artist:541P8kParJeyWFaxfsEHdt"}],"external_urls":{"spotify":"https://open.spotify.com/album/3vgLVhmZFjiDpX52BxHFOl"},"href":"https://api.spotify.com/v1/albums/3vgLVhmZFjiDpX52BxHFOl","id":"3vgLVhmZFjiDpX52BxHFOl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733b0e36e2927704c6eb48f904"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023b0e36e2927704c6eb48f904"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513b0e36e2927704c6eb48f904"}],"is_playable":true,"name":"Andalucia","release_date":"2024-05-31","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3vgLVhmZFjiDpX52BxHFOl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5PlfkPxwCpRRWQJBxCa0By"},"href":"https://api.spotify.com/v1/artists/5PlfkPxwCpRRWQJBxCa0By","id":"5PlfkPxwCpRRWQJBxCa0By","name":"HUGEL","type":"artist","uri":"spotify:artist:5PlfkPxwCpRRWQJBxCa0By"},{"external_urls":{"spotify":"https://open.spotify.com/artist/541P8kParJeyWFaxfsEHdt"},"href":"https://api.spotify.com/v1/artists/541P8kParJeyWFaxfsEHdt","id":"541P8kParJeyWFaxfsEHdt","name":"GROSSOMODDO","type":"artist","uri":"spotify:artist:541P8kParJeyWFaxfsEHdt"}],"disc_number":1,"duration_ms":229000,"explicit":false,"external_ids":{"isrc":"CH7812405239"},"external_urls":{"spotify":"https://open.spotify.com/track/1FUUe1VbjWakX9nFfd0Qki"},"href":"https://api.spotify.com/v1/tracks/1FUUe1VbjWakX9nFfd0Qki","id":"1FUUe1VbjWakX9nFfd0Qki","is_local":false,"is_playable":true,"name":"Andalucia","track_number":1,"type":"track","uri":"spotify:track:1FUUe1VbjWakX9nFfd0Qki"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7IiSLreTg1of8dDwxwiPw3"},"href":"https://api.spotify.com/v1/artists/7IiSLreTg1of8dDwxwiPw3","id":"7IiSLreTg1of8dDwxwiPw3","name":"Chef'Special","type":"artist","uri":"spotify:artist:7IiSLreTg1of8dDwxwiPw3"}],"external_urls":{"spotify":"https://open.spotify.com/album/1eUNnwgmoRBADp5uXoSFur"},"href":"https://api.spotify.com/v1/albums/1eUNnwgmoRBADp5uXoSFur","id":"1eUNnwgmoRBADp5uXoSFur","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273931c24b07f1a4557add05b61"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02931c24b07f1a4557add05b61"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851931c24b07f1a4557add05b61"}],"is_playable":true,"name":"New Gold","release_date":"2024-04-12","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:1eUNnwgmoRBADp5uXoSFur"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7IiSLreTg1of8dDwxwiPw3"},"href":"https://api.spotify.com/v1/artists/7IiSLreTg1of8dDwxwiPw3","id":"7IiSLreTg1of8dDwxwiPw3","name":"Chef'Special","type":"artist","uri":"spotify:artist:7IiSLreTg1of8dDwxwiPw3"}],"disc_number":1,"duration_ms":202627,"explicit":false,"external_ids":{"isrc":"NLZ292300099"},"external_urls":{"spotify":"https://open.spotify.com/track/4bMBMIEP4NmVsJCV1U6CHR"},"href":"https://api.spotify.com/v1/tracks/4bMBMIEP4NmVsJCV1U6CHR","id":"4bMBMIEP4NmVsJCV1U6CHR","is_local":false,"is_playable":true,"name":"Miracles","track_number":3,"type":"track","uri":"spotify:track:4bMBMIEP4NmVsJCV1U6CHR"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7IiSLreTg1of8dDwxwiPw3"},"href":"https://api.spotify.com/v1/artists/7IiSLreTg1of8dDwxwiPw3","id":"7IiSLreTg1of8dDwxwiPw3","name":"Chef'Special","type":"artist","uri":"spotify:artist:7IiSLreTg1of8dDwxwiPw3"}],"external_urls":{"spotify":"https://open.spotify.com/album/71GU8xA9C11Y6C6ZR0EB6G"},"href":"https://api.spotify.com/v1/albums/71GU8xA9C11Y6C6ZR0EB6G","id":"71GU8xA9C11Y6C6ZR0EB6G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d0350a8a768c3a7ede1d8a94"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d0350a8a768c3a7ede1d8a94"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d0350a8a768c3a7ede1d8a94"}],"is_playable":true,"name":"C'est La Vie","release_date":"2024-12-06","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:71GU8xA9C11Y6C6ZR0EB6G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7IiSLreTg1of8dDwxwiPw3"},"href":"https://api.spotify.com/v1/artists/7IiSLreTg1of8dDwxwiPw3","id":"7IiSLreTg1of8dDwxwiPw3","name":"Chef'Special","type":"artist","uri":"spotify:artist:7IiSLreTg1of8dDwxwiPw3"}],"disc_number":1,"duration_ms":183175,"explicit":false,"external_ids":{"isrc":"NLHH42400001"},"external_urls":{"spotify":"https://open.spotify.com/track/56uHBrq9bnanwTVkqQiLCq"},"href":"https://api.spotify.com/v1/tracks/56uHBrq9bnanwTVkqQiLCq","id":"56uHBrq9bnanwTVkqQiLCq","is_local":false,"is_playable":true,"name":"C'est La Vie","track_number":1,"type":"track","uri":"spotify:track:56uHBrq9bnanwTVkqQiLCq"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7IiSLreTg1of8dDwxwiPw3"},"href":"https://api.spotify.com/v1/artists/7IiSLreTg1of8dDwxwiPw3","id":"7IiSLreTg1of8dDwxwiPw3","name":"Chef'Special","type":"artist","uri":"spotify:artist:7IiSLreTg1of8dDwxwiPw3"}],"external_urls":{"spotify":"https://open.spotify.com/album/78xmj94oXbrHsZdmMO29kv"},"href":"https://api.spotify.com/v1/albums/78xmj94oXbrHsZdmMO29kv","id":"78xmj94oXbrHsZdmMO29kv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dfac43dd257eae8d68bd03fd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dfac43dd257eae8d68bd03fd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dfac43dd257eae8d68bd03fd"}],"is_playable":true,"name":"If Not Now Then When","release_date":"2025-11-13","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:78xmj94oXbrHsZdmMO29kv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7IiSLreTg1of8dDwxwiPw3"},"href":"https://api.spotify.com/v1/artists/7IiSLreTg1of8dDwxwiPw3","id":"7IiSLreTg1of8dDwxwiPw3","name":"Chef'Special","type":"artist","uri":"spotify:artist:7IiSLreTg1of8dDwxwiPw3"}],"disc_number":1,"duration_ms":200319,"explicit":false,"external_ids":{"isrc":"NLHH42500003"},"external_urls":{"spotify":"https://open.spotify.com/track/0Ke6qURuzrJYBmPGzOGm9k"},"href":"https://api.spotify.com/v1/tracks/0Ke6qURuzrJYBmPGzOGm9k","id":"0Ke6qURuzrJYBmPGzOGm9k","is_local":false,"is_playable":true,"name":"If Not Now Then When","track_number":1,"type":"track","uri":"spotify:track:0Ke6qURuzrJYBmPGzOGm9k"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1BbmRhbHVjaWElMjBDaGVmJTI3U3BlY2lhbCZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVQbGZrUHh3Q3BSUldRSkJ4Q2EwQnkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVBsZmtQeHdDcFJSV1FKQnhDYTBCeSIsImlkIjoiNVBsZmtQeHdDcFJSV1FKQnhDYTBCeSIsIm5hbWUiOiJIVUdFTCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1UGxma1B4d0NwUlJXUUpCeENhMEJ5In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU0MVA4a1BhckpleVdGYXhmc0VIZHQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTQxUDhrUGFySmV5V0ZheGZzRUhkdCIsImlkIjoiNTQxUDhrUGFySmV5V0ZheGZzRUhkdCIsIm5hbWUiOiJHUk9TU09NT0RETyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1NDFQOGtQYXJKZXlXRmF4ZnNFSGR0In1dLCJleHRlcm5hbA==", + "X3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zdmdMVmhtWkZqaURwWDUyQnhIRk9sIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM3ZnTFZobVpGamlEcFg1MkJ4SEZPbCIsImlkIjoiM3ZnTFZobVpGamlEcFg1MkJ4SEZPbCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzYjBlMzZlMjkyNzcwNGM2ZWI0OGY5MDQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyM2IwZTM2ZTI5Mjc3MDRjNmViNDhmOTA0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzYjBlMzZlMjkyNzcwNGM2ZWI0OGY5MDQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQW5kYWx1Y2lhIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wNS0zMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M3ZnTFZobVpGamlEcFg1MkJ4SEZPbCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVQbGZrUHh3Q3BSUldRSkJ4Q2EwQnkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVBsZmtQeHdDcFJSV1FKQnhDYTBCeSIsImlkIjoiNVBsZmtQeHdDcFJSV1FKQnhDYTBCeSIsIm5hbWUiOiJIVUdFTCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1UGxma1B4d0NwUlJXUUpCeENhMEJ5In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU0MVA4a1BhckpleVdGYXhmc0VIZHQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTQxUDhrUGFySmV5V0ZheGZzRUhkdCIsImlkIjoiNTQxUDhrUGFySmV5V0ZheGZzRUhkdCIsIm5hbWUiOiJHUk9TU09NT0RETyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1NDFQOGtQYXJKZXlXRmF4ZnNFSGR0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyOTAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkNINzgxMjQwNTIzOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUZVVWUxVmJqV2FrWDluRmZkMFFraSJ9LCJocmVmIg==", + "OiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMUZVVWUxVmJqV2FrWDluRmZkMFFraSIsImlkIjoiMUZVVWUxVmJqV2FrWDluRmZkMFFraSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbmRhbHVjaWEiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUZVVWUxVmJqV2FrWDluRmZkMFFraSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83SWlTTHJlVGcxb2Y4ZER3eHdpUHczIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdJaVNMcmVUZzFvZjhkRHd4d2lQdzMiLCJpZCI6IjdJaVNMcmVUZzFvZjhkRHd4d2lQdzMiLCJuYW1lIjoiQ2hlZidTcGVjaWFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdJaVNMcmVUZzFvZjhkRHd4d2lQdzMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xZVVObndnbW9SQkFEcDV1WG9TRnVyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWVVTm53Z21vUkJBRHA1dVhvU0Z1ciIsImlkIjoiMWVVTm53Z21vUkJBRHA1dVhvU0Z1ciIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5MzFjMjRiMDdmMWE0NTU3YWRkMDViNjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTMxYzI0YjA3ZjFhNDU1N2FkZDA1YjYxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5MzFjMjRiMDdmMWE0NTU3YWRkMDViNjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmV3IEdvbGQiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTA0LTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MWVVTm53Z21vUkJBRHA1dVhvU0Z1ciJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdJaVNMcmVUZzFvZjhkRHd4d2lQdzMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0lpU0xyZVRnMW9mOGREd3h3aVB3MyIsImlkIjoiN0lpU0xyZVRnMQ==", + "b2Y4ZER3eHdpUHczIiwibmFtZSI6IkNoZWYnU3BlY2lhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3SWlTTHJlVGcxb2Y4ZER3eHdpUHczIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwMjYyNywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MWjI5MjMwMDA5OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGJNQk1JRVA0Tm1Wc0pDVjFVNkNIUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRiTUJNSUVQNE5tVnNKQ1YxVTZDSFIiLCJpZCI6IjRiTUJNSUVQNE5tVnNKQ1YxVTZDSFIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWlyYWNsZXMiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGJNQk1JRVA0Tm1Wc0pDVjFVNkNIUiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0lpU0xyZVRnMW9mOGREd3h3aVB3MyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83SWlTTHJlVGcxb2Y4ZER3eHdpUHczIiwiaWQiOiI3SWlTTHJlVGcxb2Y4ZER3eHdpUHczIiwibmFtZSI6IkNoZWYnU3BlY2lhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3SWlTTHJlVGcxb2Y4ZER3eHdpUHczIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzFHVTh4QTlDMTFZNkM2WlIwRUI2RyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzcxR1U4eEE5QzExWTZDNlpSMEVCNkciLCJpZCI6IjcxR1U4eEE5QzExWTZDNlpSMEVCNkciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDAzNTBhOGE3NjhjM2E3ZWRlMWQ4YTk0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQwMzUwYThhNzY4YzNhN2VkZTFkOGE5NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDAzNTBhOGE3NjhjM2E3ZWRlMWQ4YTk0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkMnZXN0IExhIFZpZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMTItMDYiLCJyZQ==", + "bGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzFHVTh4QTlDMTFZNkM2WlIwRUI2RyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdJaVNMcmVUZzFvZjhkRHd4d2lQdzMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0lpU0xyZVRnMW9mOGREd3h3aVB3MyIsImlkIjoiN0lpU0xyZVRnMW9mOGREd3h3aVB3MyIsIm5hbWUiOiJDaGVmJ1NwZWNpYWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0lpU0xyZVRnMW9mOGREd3h3aVB3MyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODMxNzUsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTEhINDI0MDAwMDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzU2dUhCcnE5Ym5hbndUVmtxUWlMQ3EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81NnVIQnJxOWJuYW53VFZrcVFpTENxIiwiaWQiOiI1NnVIQnJxOWJuYW53VFZrcVFpTENxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkMnZXN0IExhIFZpZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1NnVIQnJxOWJuYW53VFZrcVFpTENxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83SWlTTHJlVGcxb2Y4ZER3eHdpUHczIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdJaVNMcmVUZzFvZjhkRHd4d2lQdzMiLCJpZCI6IjdJaVNMcmVUZzFvZjhkRHd4d2lQdzMiLCJuYW1lIjoiQ2hlZidTcGVjaWFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdJaVNMcmVUZzFvZjhkRHd4d2lQdzMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83OHhtajk0b1hickhzWmRtTU8yOWt2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzh4bWo5NG9YYnJIc1pkbU1PMjlrdiIsImlkIjoiNzh4bWo5NG9YYnJIc1pkbU1PMjlrdiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkZmFjNDNkZA==", + "MjU3ZWFlOGQ2OGJkMDNmZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkZmFjNDNkZDI1N2VhZThkNjhiZDAzZmQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWRmYWM0M2RkMjU3ZWFlOGQ2OGJkMDNmZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJZiBOb3QgTm93IFRoZW4gV2hlbiIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMTEtMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc4eG1qOTRvWGJySHNaZG1NTzI5a3YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83SWlTTHJlVGcxb2Y4ZER3eHdpUHczIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdJaVNMcmVUZzFvZjhkRHd4d2lQdzMiLCJpZCI6IjdJaVNMcmVUZzFvZjhkRHd4d2lQdzMiLCJuYW1lIjoiQ2hlZidTcGVjaWFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdJaVNMcmVUZzFvZjhkRHd4d2lQdzMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjAwMzE5LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxISDQyNTAwMDAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wS2U2cVVSdXpySllCbVBHek9HbTlrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMEtlNnFVUnV6ckpZQm1QR3pPR205ayIsImlkIjoiMEtlNnFVUnV6ckpZQm1QR3pPR205ayIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJZiBOb3QgTm93IFRoZW4gV2hlbiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowS2U2cVVSdXpySllCbVBHek9HbTlrIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Andalucia+Chef%27Special&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1SaXNlJTIwQW5vdWsmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjMsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM3N4dmE0TjZtdERpT2E2enZCYThUMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNzeHZhNE42bXREaU9hNnp2QmE4VDMiLCJpZCI6IjNzeHZhNE42bXREaU9hNnp2QmE4VDMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjNlZGY1ZWViMDZhZjcxZTdjMjU4NjMwIn0sew==", + "ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjNlZGY1ZWViMDZhZjcxZTdjMjU4NjMwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiM2VkZjVlZWIwNmFmNzFlN2MyNTg2MzAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG90ZWwgTmV3IFlvcmsiLCJyZWxlYXNlX2RhdGUiOiIyMDA0LTEwLTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M3N4dmE0TjZtdERpT2E2enZCYThUMyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZsdFZ1bllqQUFENzBZdFZPNnJ4dlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsImlkIjoiNmx0VnVuWWpBQUQ3MFl0Vk82cnh2WCIsIm5hbWUiOiJBbm91ayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHRWdW5ZakFBRDcwWXRWTzZyeHZYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMjQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTk1MDQwMDA0OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0REZVE4VGVkTDAwVGlJVjVObUZybiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNERGVROFRlZEwwMFRpSVY1Tm1Gcm4iLCJpZCI6IjNERGVROFRlZEwwMFRpSVY1Tm1Gcm4iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTG9zdCIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozRERlUThUZWRMMDBUaUlWNU5tRnJuIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJKeVdYUGJrcUk1WkphM2d3cVZhMGMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkp5V1hQYmtxSTVaSmEzZ3dxVmEwYyIsImlkIjoiMkp5V1hQYmtxSTVaSmEzZ3dxVmEwYyIsIm5hbWUiOiJDcmFpZyBEYXZpZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoySnlXWFBia3FJNVpKYTNnd3FWYTBjIn1dLCJleHRlcm5hbF91cmxzIg==", + "Onsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82VVNSWFVaWGU0a2VHczJ5VWozRmlzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNlVTUlhVWlhlNGtlR3MyeVVqM0ZpcyIsImlkIjoiNlVTUlhVWlhlNGtlR3MyeVVqM0ZpcyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNTJmYThmODkxYzEyMTRlOGI1NDg5ZTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTUyZmE4Zjg5MWMxMjE0ZThiNTQ4OWUzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExNTJmYThmODkxYzEyMTRlOGI1NDg5ZTMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2xpY2tlciB0aGFuIFlvdXIgQXZlcmFnZSIsInJlbGVhc2VfZGF0ZSI6IjIwMDItMTEtMTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2VVNSWFVaWGU0a2VHczJ5VWozRmlzIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkp5V1hQYmtxSTVaSmEzZ3dxVmEwYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8ySnlXWFBia3FJNVpKYTNnd3FWYTBjIiwiaWQiOiIySnlXWFBia3FJNVpKYTNnd3FWYTBjIiwibmFtZSI6IkNyYWlnIERhdmlkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJKeVdYUGJrcUk1WkphM2d3cVZhMGMifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFR5NjNjZW9Sbm5KS1ZFWVAwVlFwayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wVHk2M2Nlb1JubkpLVkVZUDBWUXBrIiwiaWQiOiIwVHk2M2Nlb1JubkpLVkVZUDBWUXBrIiwibmFtZSI6IlN0aW5nIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBUeTYzY2VvUm5uSktWRVlQMFZRcGsifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjg3MjI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBV1YwMjAzMDI5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yM2VoUjRqcEZRRk1mREFEZ0ZkWA==", + "UjcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yM2VoUjRqcEZRRk1mREFEZ0ZkWFI3IiwiaWQiOiIyM2VoUjRqcEZRRk1mREFEZ0ZkWFI3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJpc2UgJiBGYWxsIChmZWF0LiBTdGluZykiLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MjNlaFI0anBGUUZNZkRBRGdGZFhSNyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82T0c5ZloxTEtYeUwwaFNoUm1tbnExIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZPRzlmWjFMS1h5TDBoU2hSbW1ucTEiLCJpZCI6IjZPRzlmWjFMS1h5TDBoU2hSbW1ucTEiLCJuYW1lIjoiRGF2aW5hIE1pY2hlbGxlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZPRzlmWjFMS1h5TDBoU2hSbW1ucTEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xaG4ycGFFTFBZZEZhWFVEN2xBaVNPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWhuMnBhRUxQWWRGYVhVRDdsQWlTTyIsImlkIjoiMWhuMnBhRUxQWWRGYVhVRDdsQWlTTyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzM2IzMzNlMjYyYjI4NDM5YTVmYzVjYTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzNiMzMzZTI2MmIyODQzOWE1ZmM1Y2E2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzM2IzMzNlMjYyYjI4NDM5YTVmYzVjYTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ292ZXJzICcyNCIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDgtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxaG4ycGFFTFBZZEZhWFVEN2xBaVNPIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNk9HOWZaMUxLWHlMMGhTaFJtbW5xMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82T0c5ZloxTA==", + "S1h5TDBoU2hSbW1ucTEiLCJpZCI6IjZPRzlmWjFMS1h5TDBoU2hSbW1ucTEiLCJuYW1lIjoiRGF2aW5hIE1pY2hlbGxlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZPRzlmWjFMS1h5TDBoU2hSbW1ucTEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTYzMDc4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxSM0EyNDAwMDA5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xc3F5cTRTYnNBeGJ0dWxwQmdwYzd0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMXNxeXE0U2JzQXhidHVscEJncGM3dCIsImlkIjoiMXNxeXE0U2JzQXhidHVscEJncGM3dCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaXNlIFVwIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxc3F5cTRTYnNBeGJ0dWxwQmdwYzd0In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Rise+Anouk&type=track&limit=10" + } +] diff --git a/eval/fixtures/focus-coding-refine/anthropic.json b/eval/fixtures/focus-coding-refine/anthropic.json new file mode 100644 index 0000000..37497a4 --- /dev/null +++ b/eval/fixtures/focus-coding-refine/anthropic.json @@ -0,0 +1,127 @@ +[ + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"query\":\"something calm for while I am programming, but not boring\",\"history\":[],\"prior_recommendations\":[],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"required_candidate_count\":35}"}],"model":"claude-sonnet-5","output_config":{"effort":"low","format":{"schema":{"$defs":{"CandidateOutput":{"type":"object","description":"One bounded candidate in the intent response.","title":"CandidateOutput","properties":{"title":{"type":"string","title":"Title","description":"{maxLength: 200, minLength: 1}"},"artist":{"type":"string","title":"Artist","description":"{maxLength: 200, minLength: 1}"}},"additionalProperties":false,"required":["title","artist"]},"Familiarity":{"type":"string","enum":["familiar","mix","new"],"description":"How strongly a request should favor known or unknown music.","title":"Familiarity"}},"type":"object","description":"Bounded structured output for the intent call.","title":"IntentOutput","properties":{"mood":{"type":"array","title":"Mood","items":{"type":"string"},"description":"{maxItems: 6}"},"activity":{"anyOf":[{"type":"string","description":"{maxLength: 100}"},{"type":"null"}],"title":"Activity","description":"{default: None}"},"era":{"type":"array","title":"Era","items":{"type":"string"},"description":"{maxItems: 5}"},"languages":{"type":"array","title":"Languages","items":{"type":"string"},"description":"{maxItems: 8}"},"genres":{"type":"array","title":"Genres","items":{"type":"string"},"description":"{maxItems: 8}"},"familiarity":{"$ref":"#/$defs/Familiarity"},"is_refinement":{"type":"boolean","title":"Is Refinement"},"intent_summary":{"type":"string","title":"Intent Summary","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"},"candidates":{"type":"array","title":"Candidates","items":{"$ref":"#/$defs/CandidateOutput"},"description":"{maxItems: 50, minItems: 10}"}},"additionalProperties":false,"required":["familiarity","is_refinement","intent_summary","candidates"]},"type":"json_schema"}},"system":[{"type":"text","text":"You are the intent interpreter and candidate generator for a music discovery system. Your job is to understand one listener request, use the supplied taste evidence carefully, and propose real recordings that another service can resolve against Spotify. Return only data that conforms to the provided output schema. Do not add prose before or after the structured response.\n\nInterpret the request in context. The variable input can contain a current query, a bounded conversation history, recommendations from an earlier response, and a compact taste profile. Treat the current query as authoritative. Use history only to resolve references, continuity, or explicit changes such as \"more like the third one\" or \"less energetic.\" Prior recommendations are evidence about what the listener has just seen, not proof that the listener likes every item. The Spotify taste profile is evidence of listening behavior, not a complete identity and not permission to stereotype the listener.\n\nPopulate every schema field honestly. Mood is a short bounded list of useful musical or emotional qualities. Activity is a concise listening context when one is stated or strongly implied, otherwise null. Era contains only time periods that matter to the request. Languages contains requested or strongly implied vocal languages; use an empty list when language is irrelevant or the music can be instrumental. Genres should be specific enough to guide selection without inventing a false precision. Familiarity must be familiar, mix, or new. Use familiar when the listener asks for comfort, favorites, known songs, or reliable crowd recognition. Use new when the listener asks for discovery, obscurity, unfamiliar music, or a departure from their habits. Use mix for a balanced bridge or when the request does not justify either extreme.\n\nSet is_refinement to true only when the listener is revising, narrowing, extending, or referring to an earlier recommendation result in the supplied conversation. A standalone request is not a refinement merely because history exists. The intent summary must be one plain-English sentence that tells the listener how the request was understood. It must not mention internal models, candidate generation, schemas, retrieval, or Spotify search behavior.\n\nGenerate the exact candidate count requested in the variable input. Each candidate contains only a track title and the credited artist name most likely to identify the recording. Choose recordings that plausibly exist in Spotify's catalog. Use canonical spellings. Do not fabricate tracks, mash up titles and artists, translate titles, or use descriptive placeholders. Avoid remixes, live versions, remasters, edits, sped-up versions, slowed versions, karaoke versions, covers, and tribute recordings unless the user explicitly asks for them. When several recordings share a title, choose the artist credit that makes the intended recording unambiguous.\n\nCandidate quality matters more than superficial variety. Every candidate should fit the interpreted mood, activity, era, language, genre, and familiarity. Still, spread the set across artists. Do not let one artist dominate the candidate list, even when that artist appears prominently in the taste profile. Avoid duplicate titles by the same artist and avoid multiple editions of the same recording. Use a range of strong fits so a later ranking step has meaningful choices rather than thirty near-identical songs.\n\nWhen familiarity leans new, propose music the listener plausibly does not know. Move beyond the named top artists and tracks while retaining understandable bridges through genre, scene, production style, instrumentation, energy, era, or songwriting. Do not simply select deep cuts from every familiar artist. Prefer adjacent artists, overlooked catalogs, regional scenes, and credible cross-genre connections. The profile is not exhaustive, so never claim that a candidate is definitely unknown. When familiarity is familiar, candidates may include supplied top or saved tracks, but remain responsive to the current request. When familiarity is mix, combine recognizable anchors with adjacent discoveries rather than splitting into unrelated halves.\n\nUse musical knowledge conservatively. Base selection on durable, commonly knowable attributes of recordings. Do not invent listening statistics, personal memories, release stories, chart facts, cultural identities, lyrical meanings, or audio features. Do not infer sensitive traits from taste. Explicit safety or content constraints in the request are binding. If a request is broad, create a coherent interpretation instead of asking a question. If constraints conflict, prioritize explicit exclusions, then the current query, then history, then taste evidence.\n\nThe downstream resolver first tries an exact field-filtered search and then a fuzzy bare-text search. Help it succeed with correct title and artist spelling. It will reject weak title or artist matches, so substituting a vaguely related track wastes a candidate. Prefer a confidently identifiable recording over an obscure item whose title or credit you cannot state accurately. Do not include Spotify identifiers, album names, explanations, scores, or justifications in candidate objects.\n\nBefore returning, silently check that the response matches the schema, the candidate list has exactly the requested size, familiarity uses the allowed value, is_refinement reflects conversation continuity, the intent summary is one line, spellings are credible, artist distribution is broad, and no candidate violates an explicit exclusion. Return strictly the structured response and nothing else.\n","cache_control":{"type":"ephemeral"}}]}", + "response_body_base64": "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", + "response_chunks_base64": [ + "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" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"intent\":{\"mood\":[\"calm\",\"focused\",\"smooth\",\"warm\",\"understated\"],\"activity\":\"programming\",\"era\":[],\"languages\":[],\"genres\":[\"chillhop\",\"lo-fi\",\"downtempo\",\"ambient soul\",\"instrumental\"],\"familiarity\":\"mix\",\"intent_summary\":\"Looking for calm but engaging background music suited to focused programming, blending mellow electronic and soulful textures.\"},\"grounded_pool\":[{\"track_id\":\"44ZKnfWEkp7wPs035j4Tua\",\"title\":\"Casio\",\"artists\":[\"Jungle\"]},{\"track_id\":\"7sMRDjjwsB7wQEBOkdfg0i\",\"title\":\"Kaiju\",\"artists\":[\"sakanaction\"]},{\"track_id\":\"46RNrAkGsqWTDrv2ZPOAbx\",\"title\":\"Moon Song\",\"artists\":[\"Phoebe Bridgers\"]},{\"track_id\":\"1zAIRb8mTj8CcAUXW2FoMd\",\"title\":\"Dermot (see yourself in my eyes)\",\"artists\":[\"Fred again..\",\"Dermot Kennedy\"]},{\"track_id\":\"7nYClzzNY6f3EcfeDFNqhS\",\"title\":\"When I Get There\",\"artists\":[\"Big Wild\"]},{\"track_id\":\"6WKu0pl1jHSuVo4PbSn2yk\",\"title\":\"Downtown\",\"artists\":[\"Godford\"]},{\"track_id\":\"7HWyA12GJhcn866OJ0QHkt\",\"title\":\"Missing - Todd Terry Remix Radio Edit\",\"artists\":[\"Everything But The Girl\",\"Todd Terry\"]},{\"track_id\":\"0U0ldCRmgCqhVvD6ksG63j\",\"title\":\"Nightcall\",\"artists\":[\"Kavinsky\"]},{\"track_id\":\"0uKrhHBDUQ4w5fv4qwOubP\",\"title\":\"Breathe\",\"artists\":[\"T\\u00e9l\\u00e9popmusik\",\"Angela McCluskey\"]},{\"track_id\":\"6EXi6ZqTITKGtVBKqbphjL\",\"title\":\"Porcelain\",\"artists\":[\"Moby\"]},{\"track_id\":\"6kkwzB6hXLIONkEk9JciA6\",\"title\":\"Weightless\",\"artists\":[\"Marconi Union\"]},{\"track_id\":\"2usrT8QIbIk9y0NEtQwS4j\",\"title\":\"Intro\",\"artists\":[\"The xx\"]},{\"track_id\":\"35KiiILklye1JRRctaLUb4\",\"title\":\"Holocene\",\"artists\":[\"Bon Iver\"]},{\"track_id\":\"6KpO4neDXxGdiEgsivZieY\",\"title\":\"Divenire\",\"artists\":[\"Ludovico Einaudi\",\"Robert Ziegler\",\"Royal Philharmonic Orchestra\"]},{\"track_id\":\"2agBDIr9MYDUducQPC1sFU\",\"title\":\"River Flows In You\",\"artists\":[\"Yiruma\"]},{\"track_id\":\"67Hna13dNDkZvBpTXRIaOJ\",\"title\":\"Teardrop\",\"artists\":[\"Massive Attack\",\"Elizabeth Fraser\"]},{\"track_id\":\"6GyFP1nfCDB8lbD2bG0Hq9\",\"title\":\"Midnight City\",\"artists\":[\"M83\"]},{\"track_id\":\"4kJWtxDDNb9oAk3h7sX3N4\",\"title\":\"Strobe\",\"artists\":[\"deadmau5\"]},{\"track_id\":\"54KFQB6N4pn926IUUYZGzK\",\"title\":\"To Build A Home\",\"artists\":[\"The Cinematic Orchestra\",\"Patrick Watson\"]},{\"track_id\":\"07eGxuz8bL6QMsRqEe1Adu\",\"title\":\"Svefn-g-englar\",\"artists\":[\"Sigur R\\u00f3s\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"history\":[],\"requested_selection_count\":15,\"correction\":null}"}],"model":"claude-sonnet-5","output_config":{"effort":"medium","format":{"type":"json_schema","schema":{"$defs":{"RerankSelectionOutput":{"type":"object","description":"One validated object extracted from the rerank stream.","title":"RerankSelectionOutput","properties":{"track_id":{"type":"string","title":"Track Id","description":"{maxLength: 200, minLength: 1}"},"justification":{"type":"string","title":"Justification","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"}},"additionalProperties":false,"required":["track_id","justification"]}},"type":"object","description":"Complete bounded rerank output used for final validation.","title":"RerankOutput","properties":{"recommendations":{"type":"array","title":"Recommendations","items":{"$ref":"#/$defs/RerankSelectionOutput"},"minItems":1,"description":"{maxItems: 50}"}},"additionalProperties":false,"required":["recommendations"]}}},"system":[{"type":"text","text":"You are the final ranking component of a music discovery system. Select and order tracks only from the grounded Spotify pool supplied in the variable input. Return only data that conforms to the provided JSON schema. Output strictly the JSON object required by that schema, with no markdown, no code fence, no introductory sentence, and no trailing commentary.\n\nThe variable input contains the interpreted intent, a compact listener taste summary, bounded conversation history, and a grounded pool. Every pool entry includes a Spotify track id, title, and artist names. The pool is the complete set of allowed choices. Copy track_id values exactly. Never create, alter, guess, shorten, or normalize an id. Never select a title that is absent from the pool, even if it would be a better recommendation. Never return the same track id twice.\n\nChoose up to the requested selection count, ordered from strongest to weakest recommendation. Prefer a shorter set of honest strong fits over padding with clearly unsuitable material, but normally fill the requested count when the pool contains enough relevant choices. Ranking should respond to the current intent first. Use the taste summary to personalize among plausible fits, not to override an explicit request. Use history to understand refinements and references. Treat prior assistant statements as conversation context rather than verified facts about a recording.\n\nRespect the interpreted mood, activity, era, languages, genres, and familiarity together. A track need not satisfy every soft descriptor equally, but the ordering should form a coherent listening path. Put the clearest overall matches early. Consider transitions in energy, texture, and familiarity when that creates a more useful sequence, while avoiding a mechanical pattern. Spread selections across artists where the grounded pool permits it. Do not rank several editions of the same recording merely to fill space.\n\nFamiliarity affects ordering, but it does not grant access to information outside the input. For familiar requests, favor grounded tracks that visibly connect to the supplied taste evidence or prior recommendations. For new requests, favor credible adjacent discoveries and avoid leaning entirely on artists named in the taste summary. For mix requests, use recognizable anchors and exploratory choices in a coherent balance. The application may already have filtered known tracks, so do not claim that any selection is definitely new or previously unheard.\n\nWrite one concise, plain-English justification for each selection. It should connect the track to the stated intent and, only when supported, to an explicit item or pattern in the supplied taste summary. Keep it to one line. Make the reason useful to the listener rather than describing internal ranking operations. Good reasons identify a grounded connection such as pacing for the activity, a genre bridge, a requested era, a compatible vocal language, a mood transition, or continuity with a named preference.\n\nBe exact and modest. Do not invent audio measurements, tempo values, key signatures, instrumentation, lyrical subjects, release dates, artist biographies, chart history, cultural significance, collaborations, popularity, or claims about what the listener has heard. A title and artist name alone do not prove detailed sonic or lyrical facts. You may use stable general musical knowledge when confident, but phrase the justification around the supplied intent and visible evidence. If the inputs do not support a specific fact, use a restrained reason such as \"A focused fit for the requested late-night electronic mood\" rather than manufacturing detail.\n\nDo not mention Spotify search, grounding, the candidate generator, language models, schemas, hidden scores, safety filters, cache state, or missing data in a justification. Do not tell the listener that a track was selected because it was available in the pool. Do not compare a selection with tracks that are not in the pool. Do not repeat the same generic sentence for every item. Avoid promotional language and absolute claims such as \"perfect,\" \"guaranteed,\" or \"the best.\"\n\nWhen the variable input says this is a correction attempt, treat the stated validation failure as a strict constraint. Return a fresh complete JSON object, not a patch or explanation. Correct invalid ids, duplicates, malformed fields, count problems, and formatting errors using only the supplied pool. The correction instruction never allows an out-of-pool id.\n\nThe response must be one JSON object with the exact top-level field required by the schema. Each array item must contain exactly a track_id and justification in the required types. Preserve the requested ranking order in the array. Use valid JSON quoting and escaping. Do not emit comments, dangling commas, alternate keys, null justifications, numeric ids, or additional properties.\n\nBefore returning, silently verify every track_id against the supplied pool, ensure all ids are unique, ensure the number of items does not exceed the requested count, confirm each justification is honest and one line, confirm the ranking follows the current intent, and confirm the entire response is valid against the provided JSON schema. Return only the JSON object.\n","cache_control":{"type":"ephemeral"}}],"stream":true}", + "response_body_base64": "event: message_start
data: {"type":"message_start","message":{"model":"claude-sonnet-5","id":"msg_011CdtucVoGV7iAKoF9jPnLN","type":"message","role":"assistant","content":[],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":6221,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"global"}}  }

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}      }

event: ping
data: {"type": "ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"{"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"rec"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ommendations\":[{\"track_id\":\"6kkwzB6hXLION"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"kEk9JciA6\",\"justification\":\"An unob"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"trusive ambient piece that stays in the background without pulling focus while coding.\"},{\"track_id\":\"2usrT8Q"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"IbIk9y0NEtQwS"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"4j\",\"justification\":\"Sparse and understated, this instrumental opener sets a calm tone for deep work.\"},{\"track_id\":\"44"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ZKnfWEkp7wPs035"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"j4Tua\",\"justification\":\"A warm, groove-forward track from an artist already in your saved library, fit"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ting the smooth mood requested.\"},{\"track_id\":\"6EXi6ZqT"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ITKGtVBKqbphjL"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"Mellow downtempo textures make this a steady companion for sustained concentration.\"},{\"track_id\":\"0uKrhHB"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"DUQ4w5fv4qwO"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ubP\",\"justification\":\"Soulful vocals over a laid-back electronic bed bridge the"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" ambient-soul and lo-fi feel you're after.\"},{\"track_id\":\"6KpO4neDXxGdiE"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"gsivZieY\",\"justification\":\"Instrumental piano-led piece offering"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" calm focus without lyrics to distract.\"},{\"track_id\":\"2agBDIr9M"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"YDUducQPC1sFU\",\"justification\":\"A"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" gentle instrumental piano piece that keeps energy low and steady for programming sessions.\"},{\"track_id\":\"07eGxuz"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"8bL6QMsRqEe1"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Adu\",\"justification\":\"Slow-building ambient textures work well as understated background music.\"},{\"track_id\":\"67Hna"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"13dNDkZvBpTXR"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"IaOJ\",\"justification\":\"Downtempo trip-hop atmosphere with soulful vocals suits a war"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"m, focused mood.\"},{\"track_id\":\"54KFQB6N4pn"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"926IUUYZGzK\",\"justification\":\"Cinematic instrumental swells give a"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" calm but engaging backdrop for concentrated work.\"},{\"track_id\":\"6WKu0pl1jH"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"SuVo4PbSn2yk"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"A smooth, saved-track lo-fi groove that matches the requested chillhop feel.\"},{\"track_id\":\"7"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"HWyA12GJhcn866O"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"J0QHkt\",\"justification\":\"A mellow remix pace that ke"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"eps momentum without becoming distracting, drawn from your saved list.\"},{\"track_id\":\"1zAIRb8"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"mTj8CcAUXW2Fo"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Md\",\"justification\":\"A warm, soulful production from an artist you've saved before, fitting the ambient-soul thread.\"},{\"track_id"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\":\"7nYClzzNY6f3Ec"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"feDFNqhS\",\"justification\":\"Smooth electronic textures from your"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" saved tracks provide continuity with a relaxed focus vibe.\"},{\"track_id\":\"6GyFP1"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"nfCDB8lbD2bG"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"0Hq9\",\"justification\":\"A polished downtempo-adjacent synth track that adds g"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"entle energy without breaking concentration.\"}]}"}}

event: content_block_stop
data: {"type":"content_block_stop","index":0   }

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null,"stop_details":null},"usage":{"input_tokens":6221,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"output_tokens":963,"output_tokens_details":{"thinking_tokens":0}} }

event: message_stop
data: {"type":"message_stop"              }

", + "response_chunks_base64": [ + "ZXZlbnQ6IG1lc3NhZ2Vfc3Q=", + "YXJ0CmRhdGE6IHsidHlwZSI6Im1lc3NhZ2Vfc3RhcnQiLCJtZXNzYWdlIjp7Im1vZGVsIjoiY2xhdWRlLXNvbm5ldC01IiwiaWQiOiJtc2dfMDExQ2R0dWNWb0dWN2lBS29GOWpQbkxOIiwidHlwZSI6Im1lc3NhZ2UiLCJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6W10sInN0b3BfcmVhc29uIjpudWxsLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NjIyMSwiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MjExMywiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MCwiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjEsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Imdsb2JhbCJ9fSAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RhcnQKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19zdGFydCIsImluZGV4IjowLCJjb250ZW50X2Jsb2NrIjp7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IiJ9ICAgICAgfQoK", + "ZXZlbnQ6IHBpbmcKZGF0YTogeyJ0eXBlIjogInBpbmcifQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ7In0gICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInJlYyJ9ICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvbW1lbmRhdGlvbnNcIjpbe1widHJhY2tfaWRcIjpcIjZra3d6QjZoWExJT04ifSAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJrRWs5SmNpQTZcIixcImp1c3RpZmljYXRpb25cIjpcIkFuIHVub2IifSAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ0cnVzaXZlIGFtYmllbnQgcGllY2UgdGhhdCBzdGF5cyBpbiB0aGUgYmFja2dyb3VuZCB3aXRob3V0IHB1bGxpbmcgZm9jdXMgd2hpbGUgY29kaW5nLlwifSx7XCJ0cmFja19pZFwiOlwiMnVzclQ4USJ9ICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJJYklrOXkwTkV0UXdTIn0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI0alwiLFwianVzdGlmaWNhdGlvblwiOlwiU3BhcnNlIGFuZCB1bmRlcnN0YXRlZCwgdGhpcyBpbnN0cnVtZW50YWwgb3BlbmVyIHNldHMgYSBjYWxtIHRvbmUgZm9yIGRlZXAgd29yay5cIn0se1widHJhY2tfaWRcIjpcIjQ0In0gICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJaS25mV0VrcDd3UHMwMzUifSAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJqNFR1YVwiLFwianVzdGlmaWNhdGlvblwiOlwiQSB3YXJtLCBncm9vdmUtZm9yd2FyZCB0cmFjayBmcm9tIGFuIGFydGlzdCBhbHJlYWR5IGluIHlvdXIgc2F2ZWQgbGlicmFyeSwgZml0In0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ0aW5nIHRoZSBzbW9vdGggbW9vZCByZXF1ZXN0ZWQuXCJ9LHtcInRyYWNrX2lkXCI6XCI2RVhpNlpxVCJ9ICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJJVEtHdFZCS3FicGhqTCJ9ICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIk1lbGxvdyBkb3dudGVtcG8gdGV4dHVyZXMgbWFrZSB0aGlzIGEgc3RlYWR5IGNvbXBhbmlvbiBmb3Igc3VzdGFpbmVkIGNvbmNlbnRyYXRpb24uXCJ9LHtcInRyYWNrX2lkXCI6XCIwdUtyaEhCIn0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJEVVE0dzVmdjRxd08ifSAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ1YlBcIixcImp1c3RpZmljYXRpb25cIjpcIlNvdWxmdWwgdm9jYWxzIG92ZXIgYSBsYWlkLWJhY2sgZWxlY3Ryb25pYyBiZWQgYnJpZGdlIHRoZSJ9ICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgYW1iaWVudC1zb3VsIGFuZCBsby1maSBmZWVsIHlvdSdyZSBhZnRlci5cIn0se1widHJhY2tfaWRcIjpcIjZLcE80bmVEWHhHZGlFIn0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJnc2l2WmllWVwiLFwianVzdGlmaWNhdGlvblwiOlwiSW5zdHJ1bWVudGFsIHBpYW5vLWxlZCBwaWVjZSBvZmZlcmluZyJ9ICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgY2FsbSBmb2N1cyB3aXRob3V0IGx5cmljcyB0byBkaXN0cmFjdC5cIn0se1widHJhY2tfaWRcIjpcIjJhZ0JESXI5TSJ9ICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJZRFVkdWNRUEMxc0ZVXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIn0gICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgZ2VudGxlIGluc3RydW1lbnRhbCBwaWFubyBwaWVjZSB0aGF0IGtlZXBzIGVuZXJneSBsb3cgYW5kIHN0ZWFkeSBmb3IgcHJvZ3JhbW1pbmcgc2Vzc2lvbnMuXCJ9LHtcInRyYWNrX2lkXCI6XCIwN2VHeHV6In0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI4Ykw2UU1zUnFFZTEifSAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJBZHVcIixcImp1c3RpZmljYXRpb25cIjpcIlNsb3ctYnVpbGRpbmcgYW1iaWVudCB0ZXh0dXJlcyB3b3JrIHdlbGwgYXMgdW5kZXJzdGF0ZWQgYmFja2dyb3VuZCBtdXNpYy5cIn0se1widHJhY2tfaWRcIjpcIjY3SG5hIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIxM2RORGtadkJwVFhSIn0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJJYU9KXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJEb3dudGVtcG8gdHJpcC1ob3AgYXRtb3NwaGVyZSB3aXRoIHNvdWxmdWwgdm9jYWxzIHN1aXRzIGEgd2FyIn0gICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJtLCBmb2N1c2VkIG1vb2QuXCJ9LHtcInRyYWNrX2lkXCI6XCI1NEtGUUI2TjRwbiJ9ICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI5MjZJVVVZWkd6S1wiLFwianVzdGlmaWNhdGlvblwiOlwiQ2luZW1hdGljIGluc3RydW1lbnRhbCBzd2VsbHMgZ2l2ZSBhIn0gICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgY2FsbSBidXQgZW5nYWdpbmcgYmFja2Ryb3AgZm9yIGNvbmNlbnRyYXRlZCB3b3JrLlwifSx7XCJ0cmFja19pZFwiOlwiNldLdTBwbDFqSCJ9ICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJTdVZvNFBiU24yeWsifSAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIkEgc21vb3RoLCBzYXZlZC10cmFjayBsby1maSBncm9vdmUgdGhhdCBtYXRjaGVzIHRoZSByZXF1ZXN0ZWQgY2hpbGxob3AgZmVlbC5cIn0se1widHJhY2tfaWRcIjpcIjcifSAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJIV3lBMTJHSmhjbjg2Nk8ifSAgICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJKMFFIa3RcIixcImp1c3RpZmljYXRpb25cIjpcIkEgbWVsbG93IHJlbWl4IHBhY2UgdGhhdCBrZSJ9ICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlcHMgbW9tZW50dW0gd2l0aG91dCBiZWNvbWluZyBkaXN0cmFjdGluZywgZHJhd24gZnJvbSB5b3VyIHNhdmVkIGxpc3QuXCJ9LHtcInRyYWNrX2lkXCI6XCIxekFJUmI4In0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJtVGo4Q2NBVVhXMkZvIn0gICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJNZFwiLFwianVzdGlmaWNhdGlvblwiOlwiQSB3YXJtLCBzb3VsZnVsIHByb2R1Y3Rpb24gZnJvbSBhbiBhcnRpc3QgeW91J3ZlIHNhdmVkIGJlZm9yZSwgZml0dGluZyB0aGUgYW1iaWVudC1zb3VsIHRocmVhZC5cIn0se1widHJhY2tfaWQifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIjpcIjduWUNsenpOWTZmM0VjIn0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJmZURGTnFoU1wiLFwianVzdGlmaWNhdGlvblwiOlwiU21vb3RoIGVsZWN0cm9uaWMgdGV4dHVyZXMgZnJvbSB5b3VyIn0gIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgc2F2ZWQgdHJhY2tzIHByb3ZpZGUgY29udGludWl0eSB3aXRoIGEgcmVsYXhlZCBmb2N1cyB2aWJlLlwifSx7XCJ0cmFja19pZFwiOlwiNkd5RlAxIn0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJuZkNEQjhsYkQyYkcifX0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIwSHE5XCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIHBvbGlzaGVkIGRvd250ZW1wby1hZGphY2VudCBzeW50aCB0cmFjayB0aGF0IGFkZHMgZyJ9ICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlbnRsZSBlbmVyZ3kgd2l0aG91dCBicmVha2luZyBjb25jZW50cmF0aW9uLlwifV19In19Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RvcApkYXRhOiB7InR5cGUiOiJjb250ZW50X2Jsb2NrX3N0b3AiLCJpbmRleCI6MCAgIH0KCg==", + "ZXZlbnQ6IG1lc3NhZ2VfZGVsdGEKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9kZWx0YSIsImRlbHRhIjp7InN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGx9LCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjYyMjEsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjIxMTMsIm91dHB1dF90b2tlbnMiOjk2Mywib3V0cHV0X3Rva2Vuc19kZXRhaWxzIjp7InRoaW5raW5nX3Rva2VucyI6MH19IH0KCmV2ZW50OiBtZXNzYWdlX3N0b3AKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9zdG9wIiAgICAgICAgICAgICAgfQoK" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"query\":\"a bit more electronic, and drop number 3\",\"history\":[{\"role\":\"user\",\"content\":\"something calm for while I am programming, but not boring\"},{\"role\":\"assistant\",\"content\":\"1. Weightless by Marconi Union\\n2. Intro by The xx\\n3. Casio by Jungle\\n4. Porcelain by Moby\\n5. Breathe by T\\u00e9l\\u00e9popmusik, Angela McCluskey\\n6. Divenire by Ludovico Einaudi, Robert Ziegler, Royal Philharmonic Orchestra\\n7. River Flows In You by Yiruma\\n8. Svefn-g-englar by Sigur R\\u00f3s\\n9. Teardrop by Massive Attack, Elizabeth Fraser\\n10. To Build A Home by The Cinematic Orchestra, Patrick Watson\\n11. Downtown by Godford\\n12. Missing - Todd Terry Remix Radio Edit by Everything But The Girl, Todd Terry\\n13. Dermot (see yourself in my eyes) by Fred again.., Dermot Kennedy\\n14. When I Get There by Big Wild\\n15. Midnight City by M83\"}],\"prior_recommendations\":[{\"rank\":1,\"track_id\":\"6kkwzB6hXLIONkEk9JciA6\",\"title\":\"Weightless\",\"artists\":[\"Marconi Union\"]},{\"rank\":2,\"track_id\":\"2usrT8QIbIk9y0NEtQwS4j\",\"title\":\"Intro\",\"artists\":[\"The xx\"]},{\"rank\":3,\"track_id\":\"44ZKnfWEkp7wPs035j4Tua\",\"title\":\"Casio\",\"artists\":[\"Jungle\"]},{\"rank\":4,\"track_id\":\"6EXi6ZqTITKGtVBKqbphjL\",\"title\":\"Porcelain\",\"artists\":[\"Moby\"]},{\"rank\":5,\"track_id\":\"0uKrhHBDUQ4w5fv4qwOubP\",\"title\":\"Breathe\",\"artists\":[\"T\\u00e9l\\u00e9popmusik\",\"Angela McCluskey\"]},{\"rank\":6,\"track_id\":\"6KpO4neDXxGdiEgsivZieY\",\"title\":\"Divenire\",\"artists\":[\"Ludovico Einaudi\",\"Robert Ziegler\",\"Royal Philharmonic Orchestra\"]},{\"rank\":7,\"track_id\":\"2agBDIr9MYDUducQPC1sFU\",\"title\":\"River Flows In You\",\"artists\":[\"Yiruma\"]},{\"rank\":8,\"track_id\":\"07eGxuz8bL6QMsRqEe1Adu\",\"title\":\"Svefn-g-englar\",\"artists\":[\"Sigur R\\u00f3s\"]},{\"rank\":9,\"track_id\":\"67Hna13dNDkZvBpTXRIaOJ\",\"title\":\"Teardrop\",\"artists\":[\"Massive Attack\",\"Elizabeth Fraser\"]},{\"rank\":10,\"track_id\":\"54KFQB6N4pn926IUUYZGzK\",\"title\":\"To Build A Home\",\"artists\":[\"The Cinematic Orchestra\",\"Patrick Watson\"]},{\"rank\":11,\"track_id\":\"6WKu0pl1jHSuVo4PbSn2yk\",\"title\":\"Downtown\",\"artists\":[\"Godford\"]},{\"rank\":12,\"track_id\":\"7HWyA12GJhcn866OJ0QHkt\",\"title\":\"Missing - Todd Terry Remix Radio Edit\",\"artists\":[\"Everything But The Girl\",\"Todd Terry\"]},{\"rank\":13,\"track_id\":\"1zAIRb8mTj8CcAUXW2FoMd\",\"title\":\"Dermot (see yourself in my eyes)\",\"artists\":[\"Fred again..\",\"Dermot Kennedy\"]},{\"rank\":14,\"track_id\":\"7nYClzzNY6f3EcfeDFNqhS\",\"title\":\"When I Get There\",\"artists\":[\"Big Wild\"]},{\"rank\":15,\"track_id\":\"6GyFP1nfCDB8lbD2bG0Hq9\",\"title\":\"Midnight City\",\"artists\":[\"M83\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"required_candidate_count\":35}"}],"model":"claude-sonnet-5","output_config":{"effort":"low","format":{"schema":{"$defs":{"CandidateOutput":{"type":"object","description":"One bounded candidate in the intent response.","title":"CandidateOutput","properties":{"title":{"type":"string","title":"Title","description":"{maxLength: 200, minLength: 1}"},"artist":{"type":"string","title":"Artist","description":"{maxLength: 200, minLength: 1}"}},"additionalProperties":false,"required":["title","artist"]},"Familiarity":{"type":"string","enum":["familiar","mix","new"],"description":"How strongly a request should favor known or unknown music.","title":"Familiarity"}},"type":"object","description":"Bounded structured output for the intent call.","title":"IntentOutput","properties":{"mood":{"type":"array","title":"Mood","items":{"type":"string"},"description":"{maxItems: 6}"},"activity":{"anyOf":[{"type":"string","description":"{maxLength: 100}"},{"type":"null"}],"title":"Activity","description":"{default: None}"},"era":{"type":"array","title":"Era","items":{"type":"string"},"description":"{maxItems: 5}"},"languages":{"type":"array","title":"Languages","items":{"type":"string"},"description":"{maxItems: 8}"},"genres":{"type":"array","title":"Genres","items":{"type":"string"},"description":"{maxItems: 8}"},"familiarity":{"$ref":"#/$defs/Familiarity"},"is_refinement":{"type":"boolean","title":"Is Refinement"},"intent_summary":{"type":"string","title":"Intent Summary","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"},"candidates":{"type":"array","title":"Candidates","items":{"$ref":"#/$defs/CandidateOutput"},"description":"{maxItems: 50, minItems: 10}"}},"additionalProperties":false,"required":["familiarity","is_refinement","intent_summary","candidates"]},"type":"json_schema"}},"system":[{"type":"text","text":"You are the intent interpreter and candidate generator for a music discovery system. Your job is to understand one listener request, use the supplied taste evidence carefully, and propose real recordings that another service can resolve against Spotify. Return only data that conforms to the provided output schema. Do not add prose before or after the structured response.\n\nInterpret the request in context. The variable input can contain a current query, a bounded conversation history, recommendations from an earlier response, and a compact taste profile. Treat the current query as authoritative. Use history only to resolve references, continuity, or explicit changes such as \"more like the third one\" or \"less energetic.\" Prior recommendations are evidence about what the listener has just seen, not proof that the listener likes every item. The Spotify taste profile is evidence of listening behavior, not a complete identity and not permission to stereotype the listener.\n\nPopulate every schema field honestly. Mood is a short bounded list of useful musical or emotional qualities. Activity is a concise listening context when one is stated or strongly implied, otherwise null. Era contains only time periods that matter to the request. Languages contains requested or strongly implied vocal languages; use an empty list when language is irrelevant or the music can be instrumental. Genres should be specific enough to guide selection without inventing a false precision. Familiarity must be familiar, mix, or new. Use familiar when the listener asks for comfort, favorites, known songs, or reliable crowd recognition. Use new when the listener asks for discovery, obscurity, unfamiliar music, or a departure from their habits. Use mix for a balanced bridge or when the request does not justify either extreme.\n\nSet is_refinement to true only when the listener is revising, narrowing, extending, or referring to an earlier recommendation result in the supplied conversation. A standalone request is not a refinement merely because history exists. The intent summary must be one plain-English sentence that tells the listener how the request was understood. It must not mention internal models, candidate generation, schemas, retrieval, or Spotify search behavior.\n\nGenerate the exact candidate count requested in the variable input. Each candidate contains only a track title and the credited artist name most likely to identify the recording. Choose recordings that plausibly exist in Spotify's catalog. Use canonical spellings. Do not fabricate tracks, mash up titles and artists, translate titles, or use descriptive placeholders. Avoid remixes, live versions, remasters, edits, sped-up versions, slowed versions, karaoke versions, covers, and tribute recordings unless the user explicitly asks for them. When several recordings share a title, choose the artist credit that makes the intended recording unambiguous.\n\nCandidate quality matters more than superficial variety. Every candidate should fit the interpreted mood, activity, era, language, genre, and familiarity. Still, spread the set across artists. Do not let one artist dominate the candidate list, even when that artist appears prominently in the taste profile. Avoid duplicate titles by the same artist and avoid multiple editions of the same recording. Use a range of strong fits so a later ranking step has meaningful choices rather than thirty near-identical songs.\n\nWhen familiarity leans new, propose music the listener plausibly does not know. Move beyond the named top artists and tracks while retaining understandable bridges through genre, scene, production style, instrumentation, energy, era, or songwriting. Do not simply select deep cuts from every familiar artist. Prefer adjacent artists, overlooked catalogs, regional scenes, and credible cross-genre connections. The profile is not exhaustive, so never claim that a candidate is definitely unknown. When familiarity is familiar, candidates may include supplied top or saved tracks, but remain responsive to the current request. When familiarity is mix, combine recognizable anchors with adjacent discoveries rather than splitting into unrelated halves.\n\nUse musical knowledge conservatively. Base selection on durable, commonly knowable attributes of recordings. Do not invent listening statistics, personal memories, release stories, chart facts, cultural identities, lyrical meanings, or audio features. Do not infer sensitive traits from taste. Explicit safety or content constraints in the request are binding. If a request is broad, create a coherent interpretation instead of asking a question. If constraints conflict, prioritize explicit exclusions, then the current query, then history, then taste evidence.\n\nThe downstream resolver first tries an exact field-filtered search and then a fuzzy bare-text search. Help it succeed with correct title and artist spelling. It will reject weak title or artist matches, so substituting a vaguely related track wastes a candidate. Prefer a confidently identifiable recording over an obscure item whose title or credit you cannot state accurately. Do not include Spotify identifiers, album names, explanations, scores, or justifications in candidate objects.\n\nBefore returning, silently check that the response matches the schema, the candidate list has exactly the requested size, familiarity uses the allowed value, is_refinement reflects conversation continuity, the intent summary is one line, spellings are credible, artist distribution is broad, and no candidate violates an explicit exclusion. Return strictly the structured response and nothing else.\n","cache_control":{"type":"ephemeral"}}]}", + "response_body_base64": "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", + "response_chunks_base64": [ + "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" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"intent\":{\"mood\":[\"chill\",\"focused\",\"atmospheric\",\"electronic\",\"subtly energetic\"],\"activity\":\"programming\",\"era\":[],\"languages\":[],\"genres\":[\"electronic\",\"downtempo\",\"future garage\",\"ambient techno\",\"liquid drum and bass\"],\"familiarity\":\"mix\",\"intent_summary\":\"Refining the calm programming playlist by removing Casio and leaning further into electronic textures while keeping the tone unobtrusive.\"},\"grounded_pool\":[{\"track_id\":\"44ZKnfWEkp7wPs035j4Tua\",\"title\":\"Casio\",\"artists\":[\"Jungle\"]},{\"track_id\":\"7sMRDjjwsB7wQEBOkdfg0i\",\"title\":\"Kaiju\",\"artists\":[\"sakanaction\"]},{\"track_id\":\"46RNrAkGsqWTDrv2ZPOAbx\",\"title\":\"Moon Song\",\"artists\":[\"Phoebe Bridgers\"]},{\"track_id\":\"1zAIRb8mTj8CcAUXW2FoMd\",\"title\":\"Dermot (see yourself in my eyes)\",\"artists\":[\"Fred again..\",\"Dermot Kennedy\"]},{\"track_id\":\"7nYClzzNY6f3EcfeDFNqhS\",\"title\":\"When I Get There\",\"artists\":[\"Big Wild\"]},{\"track_id\":\"6WKu0pl1jHSuVo4PbSn2yk\",\"title\":\"Downtown\",\"artists\":[\"Godford\"]},{\"track_id\":\"7HWyA12GJhcn866OJ0QHkt\",\"title\":\"Missing - Todd Terry Remix Radio Edit\",\"artists\":[\"Everything But The Girl\",\"Todd Terry\"]},{\"track_id\":\"0U0ldCRmgCqhVvD6ksG63j\",\"title\":\"Nightcall\",\"artists\":[\"Kavinsky\"]},{\"track_id\":\"0uKrhHBDUQ4w5fv4qwOubP\",\"title\":\"Breathe\",\"artists\":[\"T\\u00e9l\\u00e9popmusik\",\"Angela McCluskey\"]},{\"track_id\":\"6EXi6ZqTITKGtVBKqbphjL\",\"title\":\"Porcelain\",\"artists\":[\"Moby\"]},{\"track_id\":\"6kkwzB6hXLIONkEk9JciA6\",\"title\":\"Weightless\",\"artists\":[\"Marconi Union\"]},{\"track_id\":\"2usrT8QIbIk9y0NEtQwS4j\",\"title\":\"Intro\",\"artists\":[\"The xx\"]},{\"track_id\":\"35KiiILklye1JRRctaLUb4\",\"title\":\"Holocene\",\"artists\":[\"Bon Iver\"]},{\"track_id\":\"6KpO4neDXxGdiEgsivZieY\",\"title\":\"Divenire\",\"artists\":[\"Ludovico Einaudi\",\"Robert Ziegler\",\"Royal Philharmonic Orchestra\"]},{\"track_id\":\"2agBDIr9MYDUducQPC1sFU\",\"title\":\"River Flows In You\",\"artists\":[\"Yiruma\"]},{\"track_id\":\"67Hna13dNDkZvBpTXRIaOJ\",\"title\":\"Teardrop\",\"artists\":[\"Massive Attack\",\"Elizabeth Fraser\"]},{\"track_id\":\"6GyFP1nfCDB8lbD2bG0Hq9\",\"title\":\"Midnight City\",\"artists\":[\"M83\"]},{\"track_id\":\"4kJWtxDDNb9oAk3h7sX3N4\",\"title\":\"Strobe\",\"artists\":[\"deadmau5\"]},{\"track_id\":\"54KFQB6N4pn926IUUYZGzK\",\"title\":\"To Build A Home\",\"artists\":[\"The Cinematic Orchestra\",\"Patrick Watson\"]},{\"track_id\":\"07eGxuz8bL6QMsRqEe1Adu\",\"title\":\"Svefn-g-englar\",\"artists\":[\"Sigur R\\u00f3s\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"history\":[{\"role\":\"user\",\"content\":\"something calm for while I am programming, but not boring\"},{\"role\":\"assistant\",\"content\":\"1. Weightless by Marconi Union\\n2. Intro by The xx\\n3. Casio by Jungle\\n4. Porcelain by Moby\\n5. Breathe by T\\u00e9l\\u00e9popmusik, Angela McCluskey\\n6. Divenire by Ludovico Einaudi, Robert Ziegler, Royal Philharmonic Orchestra\\n7. River Flows In You by Yiruma\\n8. Svefn-g-englar by Sigur R\\u00f3s\\n9. Teardrop by Massive Attack, Elizabeth Fraser\\n10. To Build A Home by The Cinematic Orchestra, Patrick Watson\\n11. Downtown by Godford\\n12. Missing - Todd Terry Remix Radio Edit by Everything But The Girl, Todd Terry\\n13. Dermot (see yourself in my eyes) by Fred again.., Dermot Kennedy\\n14. When I Get There by Big Wild\\n15. Midnight City by M83\"}],\"requested_selection_count\":15,\"correction\":null}"}],"model":"claude-sonnet-5","output_config":{"effort":"medium","format":{"type":"json_schema","schema":{"$defs":{"RerankSelectionOutput":{"type":"object","description":"One validated object extracted from the rerank stream.","title":"RerankSelectionOutput","properties":{"track_id":{"type":"string","title":"Track Id","description":"{maxLength: 200, minLength: 1}"},"justification":{"type":"string","title":"Justification","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"}},"additionalProperties":false,"required":["track_id","justification"]}},"type":"object","description":"Complete bounded rerank output used for final validation.","title":"RerankOutput","properties":{"recommendations":{"type":"array","title":"Recommendations","items":{"$ref":"#/$defs/RerankSelectionOutput"},"minItems":1,"description":"{maxItems: 50}"}},"additionalProperties":false,"required":["recommendations"]}}},"system":[{"type":"text","text":"You are the final ranking component of a music discovery system. Select and order tracks only from the grounded Spotify pool supplied in the variable input. Return only data that conforms to the provided JSON schema. Output strictly the JSON object required by that schema, with no markdown, no code fence, no introductory sentence, and no trailing commentary.\n\nThe variable input contains the interpreted intent, a compact listener taste summary, bounded conversation history, and a grounded pool. Every pool entry includes a Spotify track id, title, and artist names. The pool is the complete set of allowed choices. Copy track_id values exactly. Never create, alter, guess, shorten, or normalize an id. Never select a title that is absent from the pool, even if it would be a better recommendation. Never return the same track id twice.\n\nChoose up to the requested selection count, ordered from strongest to weakest recommendation. Prefer a shorter set of honest strong fits over padding with clearly unsuitable material, but normally fill the requested count when the pool contains enough relevant choices. Ranking should respond to the current intent first. Use the taste summary to personalize among plausible fits, not to override an explicit request. Use history to understand refinements and references. Treat prior assistant statements as conversation context rather than verified facts about a recording.\n\nRespect the interpreted mood, activity, era, languages, genres, and familiarity together. A track need not satisfy every soft descriptor equally, but the ordering should form a coherent listening path. Put the clearest overall matches early. Consider transitions in energy, texture, and familiarity when that creates a more useful sequence, while avoiding a mechanical pattern. Spread selections across artists where the grounded pool permits it. Do not rank several editions of the same recording merely to fill space.\n\nFamiliarity affects ordering, but it does not grant access to information outside the input. For familiar requests, favor grounded tracks that visibly connect to the supplied taste evidence or prior recommendations. For new requests, favor credible adjacent discoveries and avoid leaning entirely on artists named in the taste summary. For mix requests, use recognizable anchors and exploratory choices in a coherent balance. The application may already have filtered known tracks, so do not claim that any selection is definitely new or previously unheard.\n\nWrite one concise, plain-English justification for each selection. It should connect the track to the stated intent and, only when supported, to an explicit item or pattern in the supplied taste summary. Keep it to one line. Make the reason useful to the listener rather than describing internal ranking operations. Good reasons identify a grounded connection such as pacing for the activity, a genre bridge, a requested era, a compatible vocal language, a mood transition, or continuity with a named preference.\n\nBe exact and modest. Do not invent audio measurements, tempo values, key signatures, instrumentation, lyrical subjects, release dates, artist biographies, chart history, cultural significance, collaborations, popularity, or claims about what the listener has heard. A title and artist name alone do not prove detailed sonic or lyrical facts. You may use stable general musical knowledge when confident, but phrase the justification around the supplied intent and visible evidence. If the inputs do not support a specific fact, use a restrained reason such as \"A focused fit for the requested late-night electronic mood\" rather than manufacturing detail.\n\nDo not mention Spotify search, grounding, the candidate generator, language models, schemas, hidden scores, safety filters, cache state, or missing data in a justification. Do not tell the listener that a track was selected because it was available in the pool. Do not compare a selection with tracks that are not in the pool. Do not repeat the same generic sentence for every item. Avoid promotional language and absolute claims such as \"perfect,\" \"guaranteed,\" or \"the best.\"\n\nWhen the variable input says this is a correction attempt, treat the stated validation failure as a strict constraint. Return a fresh complete JSON object, not a patch or explanation. Correct invalid ids, duplicates, malformed fields, count problems, and formatting errors using only the supplied pool. The correction instruction never allows an out-of-pool id.\n\nThe response must be one JSON object with the exact top-level field required by the schema. Each array item must contain exactly a track_id and justification in the required types. Preserve the requested ranking order in the array. Use valid JSON quoting and escaping. Do not emit comments, dangling commas, alternate keys, null justifications, numeric ids, or additional properties.\n\nBefore returning, silently verify every track_id against the supplied pool, ensure all ids are unique, ensure the number of items does not exceed the requested count, confirm each justification is honest and one line, confirm the ranking follows the current intent, and confirm the entire response is valid against the provided JSON schema. Return only the JSON object.\n","cache_control":{"type":"ephemeral"}}],"stream":true}", + "response_body_base64": "event: message_start
data: {"type":"message_start","message":{"model":"claude-sonnet-5","id":"msg_011Cdtuex8734C59NgRMkKvM","type":"message","role":"assistant","content":[],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":6613,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"global"}}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: ping
data: {"type": "ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"{"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"recommendations\":[{\"track_id\":\"6EXi6ZqTITKGt"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"VBKqbphjL\",\"justification\":\"Porcelain offers a sm"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ooth, unobtrusive electronic pulse that stays in the background while coding.\"},{\"track_id\":\"0uKrhHB"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"DUQ4w5fv4qwOub"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"P\",\"justification\":\"Breathe blends downtempo electronic texture with a laid-back vocal, keeping focus without distraction.\"},{\"track_id\":\"67H"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"na13dNDkZvBpTX"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"RIaOJ\",\"justification\":\"Teardrop's atmospheric trip-hop feel fits the calm, electronic-leaning program"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ming mood.\"},{\"track_id\":\"6GyFP1nfCDB8l"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"bD2bG0Hq9\",\"justification\":\"Midnight City adds a"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" subtly energetic synth lift that matches the request to lean further into electronic textures.\"},{\"track_id\":\"4kJ"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"WtxDDNb9oAk3h"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"7sX3N4\",\"justification\":\"Strobe's steady electronic build offers a focused, "}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ambient-techno adjacent backdrop for deep work.\"},{\"track_id\":\"6WKu0pl1j"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"HSuVo4PbSn2y"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"k\",\"justification\":\"Downtown brings a chill electronic groove that keeps energy present but unobtrusive, ech"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"oing tracks already saved.\"},{\"track_id\":\"7nYClzzN"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Y6f3EcfeDFNq"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"hS\",\"justification\":\"When I Get There's mellow electronic production continues the atmospheric focus vibe from your saved tracks.\"},{\"track_"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"id\":\"1zAIRb8mTj8CcA"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"UXW2FoMd\",\"justification\":\"This Fred again."}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":". collaboration offers a gentle electronic pulse that suits sustained concentration.\"},{\"track_id\":\"0U0ldCR"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"mgCqhVvD6ksG63j"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"Nightcall's synth-driven atmosphere adds a subtly energetic electronic layer without becoming distracting.\"},{\"track_id\":\"7HWyA"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"12GJhcn866OJ0QH"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"kt\",\"justification\":\"This remix leans into a smooth electronic groove that fits the calm but active programming mood.\"},{\"track_id\":\"2usr"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"T8QIbIk9y0NE"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"tQwS4j\",\"justification\":\"Intro's minimal electronic build off"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ers a quiet, focused entry point for deep work sessions.\"},{\"track_id\":\"6kkwzB6hX"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"LIONkEk9JciA6\",\"justification\":\"Weight"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"less provides an ambient, textural anchor that keeps the session calm and unobtrusive.\"},{\"track_id\":\"07eGxu"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"z8bL6QMsRqEe1"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Adu\",\"justification\":\"Svefn-g-englar's slow atmospheric swell adds depth while staying gentle in"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" the background.\"},{\"track_id\":\"54KFQB6N4pn926I"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"UUYZGzK\",\"justification\":\"To Build A Home blends orchestral warmth with electronic production for"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" a coherent, focused transition.\"},{\"track_id\":\"6KpO4neDXxGdi"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"EgsivZieY\",\"justification\":\"Divenire's cinematic, understated build offers a cal"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"m closing texture to round out the mix.\"}]}"}   }

event: content_block_stop
data: {"type":"content_block_stop","index":0           }

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null,"stop_details":null},"usage":{"input_tokens":6613,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"output_tokens":1025,"output_tokens_details":{"thinking_tokens":0}}          }

event: message_stop
data: {"type":"message_stop"             }

", + "response_chunks_base64": [ + "ZXZlbnQ6IG1lc3NhZ2Vfc3RhcnQKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9zdGFydCIsIm1lc3NhZ2UiOnsibW9kZWwiOiJjbGF1ZGUtc29ubmV0LTUiLCJpZCI6Im1zZ18wMTFDZHR1ZXg4NzM0QzU5TmdSTWtLdk0iLCJ0eXBlIjoibWVzc2FnZSIsInJvbGUiOiJhc3Npc3RhbnQiLCJjb250ZW50IjpbXSwic3RvcF9yZWFzb24iOm51bGwsInN0b3Bfc2VxdWVuY2UiOm51bGwsInN0b3BfZGV0YWlscyI6bnVsbCwidXNhZ2UiOnsiaW5wdXRfdG9rZW5zIjo2NjEzLCJjYWNoZV9jcmVhdGlvbl9pbnB1dF90b2tlbnMiOjAsImNhY2hlX3JlYWRfaW5wdXRfdG9rZW5zIjoyMTEzLCJjYWNoZV9jcmVhdGlvbiI6eyJlcGhlbWVyYWxfNW1faW5wdXRfdG9rZW5zIjowLCJlcGhlbWVyYWxfMWhfaW5wdXRfdG9rZW5zIjowfSwib3V0cHV0X3Rva2VucyI6MSwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJpbmZlcmVuY2VfZ2VvIjoiZ2xvYmFsIn19fQoKZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RhcnQKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19zdGFydCIsImluZGV4IjowLCJjb250ZW50X2Jsb2NrIjp7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IiJ9fQoK", + "ZXZlbnQ6IHBpbmcKZGF0YTogeyJ0eXBlIjogInBpbmcifQoKZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ7In0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInJlY29tbWVuZGF0aW9uc1wiOlt7XCJ0cmFja19pZFwiOlwiNkVYaTZacVRJVEtHdCJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJWQktxYnBoakxcIixcImp1c3RpZmljYXRpb25cIjpcIlBvcmNlbGFpbiBvZmZlcnMgYSBzbSJ9ICAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvb3RoLCB1bm9idHJ1c2l2ZSBlbGVjdHJvbmljIHB1bHNlIHRoYXQgc3RheXMgaW4gdGhlIGJhY2tncm91bmQgd2hpbGUgY29kaW5nLlwifSx7XCJ0cmFja19pZFwiOlwiMHVLcmhIQiJ9ICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJEVVE0dzVmdjRxd091YiJ9ICAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJQXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJCcmVhdGhlIGJsZW5kcyBkb3dudGVtcG8gZWxlY3Ryb25pYyB0ZXh0dXJlIHdpdGggYSBsYWlkLWJhY2sgdm9jYWwsIGtlZXBpbmcgZm9jdXMgd2l0aG91dCBkaXN0cmFjdGlvbi5cIn0se1widHJhY2tfaWRcIjpcIjY3SCJ9ICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJuYTEzZE5Ea1p2QnBUWCJ9ICAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJSSWFPSlwiLFwianVzdGlmaWNhdGlvblwiOlwiVGVhcmRyb3AncyBhdG1vc3BoZXJpYyB0cmlwLWhvcCBmZWVsIGZpdHMgdGhlIGNhbG0sIGVsZWN0cm9uaWMtbGVhbmluZyBwcm9ncmFtIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJtaW5nIG1vb2QuXCJ9LHtcInRyYWNrX2lkXCI6XCI2R3lGUDFuZkNEQjhsIn0gICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJiRDJiRzBIcTlcIixcImp1c3RpZmljYXRpb25cIjpcIk1pZG5pZ2h0IENpdHkgYWRkcyBhIn0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgc3VidGx5IGVuZXJnZXRpYyBzeW50aCBsaWZ0IHRoYXQgbWF0Y2hlcyB0aGUgcmVxdWVzdCB0byBsZWFuIGZ1cnRoZXIgaW50byBlbGVjdHJvbmljIHRleHR1cmVzLlwifSx7XCJ0cmFja19pZFwiOlwiNGtKIn0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJXdHhERE5iOW9BazNoIn0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI3c1gzTjRcIixcImp1c3RpZmljYXRpb25cIjpcIlN0cm9iZSdzIHN0ZWFkeSBlbGVjdHJvbmljIGJ1aWxkIG9mZmVycyBhIGZvY3VzZWQsICJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJhbWJpZW50LXRlY2hubyBhZGphY2VudCBiYWNrZHJvcCBmb3IgZGVlcCB3b3JrLlwifSx7XCJ0cmFja19pZFwiOlwiNldLdTBwbDFqIn0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJIU3VWbzRQYlNuMnkifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJrXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJEb3dudG93biBicmluZ3MgYSBjaGlsbCBlbGVjdHJvbmljIGdyb292ZSB0aGF0IGtlZXBzIGVuZXJneSBwcmVzZW50IGJ1dCB1bm9idHJ1c2l2ZSwgZWNoIn0gICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvaW5nIHRyYWNrcyBhbHJlYWR5IHNhdmVkLlwifSx7XCJ0cmFja19pZFwiOlwiN25ZQ2x6ek4ifSAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJZNmYzRWNmZURGTnEifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJoU1wiLFwianVzdGlmaWNhdGlvblwiOlwiV2hlbiBJIEdldCBUaGVyZSdzIG1lbGxvdyBlbGVjdHJvbmljIHByb2R1Y3Rpb24gY29udGludWVzIHRoZSBhdG1vc3BoZXJpYyBmb2N1cyB2aWJlIGZyb20geW91ciBzYXZlZCB0cmFja3MuXCJ9LHtcInRyYWNrXyJ9ICAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpZFwiOlwiMXpBSVJiOG1UajhDY0EifSAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJVWFcyRm9NZFwiLFwianVzdGlmaWNhdGlvblwiOlwiVGhpcyBGcmVkIGFnYWluLiJ9ICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIuIGNvbGxhYm9yYXRpb24gb2ZmZXJzIGEgZ2VudGxlIGVsZWN0cm9uaWMgcHVsc2UgdGhhdCBzdWl0cyBzdXN0YWluZWQgY29uY2VudHJhdGlvbi5cIn0se1widHJhY2tfaWRcIjpcIjBVMGxkQ1IifSAgICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJtZ0NxaFZ2RDZrc0c2M2oifSAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIk5pZ2h0Y2FsbCdzIHN5bnRoLWRyaXZlbiBhdG1vc3BoZXJlIGFkZHMgYSBzdWJ0bHkgZW5lcmdldGljIGVsZWN0cm9uaWMgbGF5ZXIgd2l0aG91dCBiZWNvbWluZyBkaXN0cmFjdGluZy5cIn0se1widHJhY2tfaWRcIjpcIjdIV3lBIn0gICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIxMkdKaGNuODY2T0owUUgifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJrdFwiLFwianVzdGlmaWNhdGlvblwiOlwiVGhpcyByZW1peCBsZWFucyBpbnRvIGEgc21vb3RoIGVsZWN0cm9uaWMgZ3Jvb3ZlIHRoYXQgZml0cyB0aGUgY2FsbSBidXQgYWN0aXZlIHByb2dyYW1taW5nIG1vb2QuXCJ9LHtcInRyYWNrX2lkXCI6XCIydXNyIn0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJUOFFJYklrOXkwTkUifSAgICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ0UXdTNGpcIixcImp1c3RpZmljYXRpb25cIjpcIkludHJvJ3MgbWluaW1hbCBlbGVjdHJvbmljIGJ1aWxkIG9mZiJ9ICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlcnMgYSBxdWlldCwgZm9jdXNlZCBlbnRyeSBwb2ludCBmb3IgZGVlcCB3b3JrIHNlc3Npb25zLlwifSx7XCJ0cmFja19pZFwiOlwiNmtrd3pCNmhYIn19Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJMSU9Oa0VrOUpjaUE2XCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJXZWlnaHQifSAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJsZXNzIHByb3ZpZGVzIGFuIGFtYmllbnQsIHRleHR1cmFsIGFuY2hvciB0aGF0IGtlZXBzIHRoZSBzZXNzaW9uIGNhbG0gYW5kIHVub2J0cnVzaXZlLlwifSx7XCJ0cmFja19pZFwiOlwiMDdlR3h1In0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ6OGJMNlFNc1JxRWUxIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJBZHVcIixcImp1c3RpZmljYXRpb25cIjpcIlN2ZWZuLWctZW5nbGFyJ3Mgc2xvdyBhdG1vc3BoZXJpYyBzd2VsbCBhZGRzIGRlcHRoIHdoaWxlIHN0YXlpbmcgZ2VudGxlIGluIn0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgdGhlIGJhY2tncm91bmQuXCJ9LHtcInRyYWNrX2lkXCI6XCI1NEtGUUI2TjRwbjkyNkkifSAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJVVVlaR3pLXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJUbyBCdWlsZCBBIEhvbWUgYmxlbmRzIG9yY2hlc3RyYWwgd2FybXRoIHdpdGggZWxlY3Ryb25pYyBwcm9kdWN0aW9uIGZvciJ9ICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgYSBjb2hlcmVudCwgZm9jdXNlZCB0cmFuc2l0aW9uLlwifSx7XCJ0cmFja19pZFwiOlwiNktwTzRuZURYeEdkaSJ9ICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJFZ3NpdlppZVlcIixcImp1c3RpZmljYXRpb25cIjpcIkRpdmVuaXJlJ3MgY2luZW1hdGljLCB1bmRlcnN0YXRlZCBidWlsZCBvZmZlcnMgYSBjYWwifSB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJtIGNsb3NpbmcgdGV4dHVyZSB0byByb3VuZCBvdXQgdGhlIG1peC5cIn1dfSJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RvcApkYXRhOiB7InR5cGUiOiJjb250ZW50X2Jsb2NrX3N0b3AiLCJpbmRleCI6MCAgICAgICAgICAgfQoK", + "ZXZlbnQ6IG1lc3NhZ2VfZGVsdGEKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9kZWx0YSIsImRlbHRhIjp7InN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGx9LCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjY2MTMsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjIxMTMsIm91dHB1dF90b2tlbnMiOjEwMjUsIm91dHB1dF90b2tlbnNfZGV0YWlscyI6eyJ0aGlua2luZ190b2tlbnMiOjB9fSAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IG1lc3NhZ2Vfc3RvcApkYXRhOiB7InR5cGUiOiJtZXNzYWdlX3N0b3AiICAgICAgICAgICAgIH0KCg==" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + } +] diff --git a/eval/fixtures/focus-coding-refine/spotify.json b/eval/fixtures/focus-coding-refine/spotify.json new file mode 100644 index 0000000..7a02b31 --- /dev/null +++ b/eval/fixtures/focus-coding-refine/spotify.json @@ -0,0 +1,413 @@ +[ + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=", + "response_chunks_base64": [ + "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=0" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkthaWp1JTIyJTIwYXJ0aXN0JTNBJTIyc2FrYW5hY3Rpb24lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8waENXVk1HR1FuUlZmRGdtaHdMSXhxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBoQ1dWTUdHUW5SVmZEZ21od0xJeHEiLCJpZCI6IjBoQ1dWTUdHUW5SVmZEZ21od0xJeHEiLCJuYW1lIjoic2FrYW5hY3Rpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGhDV1ZNR0dRblJWZkRnbWh3TEl4cSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFEaUw3Z3dTdUVoZzJ5MFN2Z1FobFMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xRGlMN2d3U3VFaGcyeTBTdmdRaGxTIiwiaWQiOiIxRGlMN2d3U3VFaGcyeTBTdmdRaGxTIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYQ==", + "YjY3NjE2ZDAwMDBiMjczMjMzN2YwMzYyMDQyMGQ0NTYxYzdlNmM5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjIzMzdmMDM2MjA0MjBkNDU2MWM3ZTZjOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjMzN2YwMzYyMDQyMGQ0NTYxYzdlNmM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkthaWp1IiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMi0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MURpTDdnd1N1RWhnMnkwU3ZnUWhsUyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBoQ1dWTUdHUW5SVmZEZ21od0xJeHEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGhDV1ZNR0dRblJWZkRnbWh3TEl4cSIsImlkIjoiMGhDV1ZNR0dRblJWZkRnbWh3TEl4cSIsIm5hbWUiOiJzYWthbmFjdGlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowaENXVk1HR1FuUlZmRGdtaHdMSXhxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1MjcyMiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkpQVkkwMjQwMzU2MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN3NNUkRqandzQjd3UUVCT2tkZmcwaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdzTVJEamp3c0I3d1FFQk9rZGZnMGkiLCJpZCI6IjdzTVJEamp3c0I3d1FFQk9rZGZnMGkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS2FpanUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N3NNUkRqandzQjd3UUVCT2tkZmcwaSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Kaiju%22+artist%3A%22sakanaction%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNhc2lvJTIyJTIwYXJ0aXN0JTNBJTIySnVuZ2xlJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81OW9BNVdiYlF2b21KejJCdVJHMDcxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU5b0E1V2JiUXZvbUp6MkJ1UkcwNzEiLCJpZCI6IjU5b0E1V2JiUXZvbUp6MkJ1UkcwNzEiLCJuYW1lIjoiSnVuZ2xlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU5b0E1V2JiUXZvbUp6MkJ1UkcwNzEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81Z1lDWmdtWHp6V1h4T0NiOWZNZkJtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWdZQ1pnbVh6eldYeE9DYjlmTWZCbSIsImlkIjoiNWdZQ1pnbVh6eldYeE9DYjlmTWZCbSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMA==", + "YjI3MzAxMGI4MGQ2Njc1YWY3YzljNjBjNGQ5OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwMTBiODBkNjY3NWFmN2M5YzYwYzRkOTgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAxMGI4MGQ2Njc1YWY3YzljNjBjNGQ5OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGb3IgRXZlciIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDktMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1Z1lDWmdtWHp6V1h4T0NiOWZNZkJtIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTlvQTVXYmJRdm9tSnoyQnVSRzA3MSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81OW9BNVdiYlF2b21KejJCdVJHMDcxIiwiaWQiOiI1OW9BNVdiYlF2b21KejJCdVJHMDcxIiwibmFtZSI6Ikp1bmdsZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OW9BNVdiYlF2b21KejJCdVJHMDcxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNDM2OSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQktTMTgwMDEwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDRaS25mV0VrcDd3UHMwMzVqNFR1YSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQ0WktuZldFa3A3d1BzMDM1ajRUdWEiLCJpZCI6IjQ0WktuZldFa3A3d1BzMDM1ajRUdWEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2FzaW8iLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NDRaS25mV0VrcDd3UHMwMzVqNFR1YSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZ1ZDNjh4Rm9nQ1hTNUFlU0JuTFNQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNnVkM2OHhGb2dDWFM1QWVTQm5MU1AiLCJpZCI6IjNnVkM2OHhGb2dDWFM1QWVTQm5MU1AiLCJuYW1lIjoiUmV0cm8gSnVuZ2xlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNnVkM2OHhGb2dDWA==", + "UzVBZVNCbkxTUCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRURlp3djFEOG9aVjA0T0FNQmV3S2MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80VEZad3YxRDhvWlYwNE9BTUJld0tjIiwiaWQiOiI0VEZad3YxRDhvWlYwNE9BTUJld0tjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2M3MGVjNjY5ZTQ0Zjc1M2Y5ZjA2NzY5MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjNzBlYzY2OWU0NGY3NTNmOWYwNjc2OTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM3MGVjNjY5ZTQ0Zjc1M2Y5ZjA2NzY5MSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW1tZXIgVmliZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA3LTE3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFRGWnd2MUQ4b1pWMDRPQU1CZXdLYyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNnVkM2OHhGb2dDWFM1QWVTQm5MU1AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2dWQzY4eEZvZ0NYUzVBZVNCbkxTUCIsImlkIjoiM2dWQzY4eEZvZ0NYUzVBZVNCbkxTUCIsIm5hbWUiOiJSZXRybyBKdW5nbGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2dWQzY4eEZvZ0NYUzVBZVNCbkxTUCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zbDJ4c1E2OWFqbThyN0taRVJqcDZ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNsMnhzUTY5YWptOHI3S1pFUmpwNngiLCJpZCI6IjNsMnhzUTY5YWptOHI3S1pFUmpwNngiLCJuYW1lIjoiRmxhbmRycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozbDJ4c1E2OWFqbThyN0taRVJqcDZ4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEzODAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkNINjU0MTk0MTI5NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNA==", + "RHFla3ZHUVcyekhOTVZoMGdNM3FwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNERxZWt2R1FXMnpITk1WaDBnTTNxcCIsImlkIjoiNERxZWt2R1FXMnpITk1WaDBnTTNxcCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYXNpbyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0RHFla3ZHUVcyekhOTVZoMGdNM3FwIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Casio%22+artist%3A%22Jungle%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1vb24lMjBTb25nJTIyJTIwYXJ0aXN0JTNBJTIyUGhvZWJlJTIwQnJpZGdlcnMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsImlkIjoiMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsIm5hbWUiOiJQaG9lYmUgQnJpZGdlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZQcDZxR0V5d0Rkb2ZnRkMxb0ZiU0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82UHA2cUdFeXdEZG9mZ0ZDMW9GYlNIIiwiaWQiOiI2UHA2cUdFeXdEZG9mZ0ZDMW9GYlNIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLg==", + "c2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTkxYjc1YzllZjY1ZWQ4ZDc2MGZmNjAwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmE5MWI3NWM5ZWY2NWVkOGQ3NjBmZjYwMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTkxYjc1YzllZjY1ZWQ4ZDc2MGZmNjAwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlB1bmlzaGVyIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wNi0xOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZQcDZxR0V5d0Rkb2ZnRkMxb0ZiU0gifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xcjF1eG95MTlmek14dW50M09OQWtHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJpZCI6IjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJuYW1lIjoiUGhvZWJlIEJyaWRnZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjc3Njc2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNKNUcyMDIwMDA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80NlJOckFrR3NxV1REcnYyWlBPQWJ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDZSTnJBa0dzcVdURHJ2MlpQT0FieCIsImlkIjoiNDZSTnJBa0dzcVdURHJ2MlpQT0FieCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb29uIFNvbmciLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NDZSTnJBa0dzcVdURHJ2MlpQT0FieCJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Moon+Song%22+artist%3A%22Phoebe+Bridgers%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldoZW4lMjBJJTIwR2V0JTIwVGhlcmUlMjIlMjBhcnRpc3QlM0ElMjJCaWclMjBXaWxkJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUHh6R25DWUJwU3VhSTQ5T1I5NGNBIiwiaWQiOiIwUHh6R25DWUJwU3VhSTQ5T1I5NGNBIiwibmFtZSI6IkJpZyBXaWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83OFJPY1I1cmtLNTZGblNZeEJvNDBMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzhST2NSNXJrSzU2Rm5TWXhCbzQwTCIsImlkIjoiNzhST2NSNXJrSzU2Rm5TWXhCbzQwTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiNmNmMTJiZTk4YWQ4ODc3MDMzZDUzN2MifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjZjZjEyYmU5OGFkODg3NzAzM2Q1MzdjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiNmNmMTJiZTk4YWQ4ODc3MDMzZDUzN2MifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW52aW5jaWJsZSBFUCIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDItMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc4Uk9jUjVya0s1NkZuU1l4Qm80MEwifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wUHh6R25DWUJwU3VhSTQ5T1I5NGNBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EiLCJpZCI6IjBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EiLCJuYW1lIjoiQmlnIFdpbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFB4ekduQ1lCcFN1YUk0OU9SOTRjQSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjAwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1FZNTE3MDYxMTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzduWUNsenpOWTZmM0VjZmVERk5xaFMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83bllDbHp6Tlk2ZjNFY2ZlREZOcWhTIiwiaWQiOiI3bllDbHp6Tlk2ZjNFY2ZlREZOcWhTIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldoZW4gSSBHZXQgVGhlcmUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N25ZQ2x6ek5ZNmYzRWNmZURGTnFoUyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80MmZFV3pOUlV6SUltRmdDODVBZGdVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzQyZkVXek5SVXpJSW1GZ0M4NUFkZ1UiLCJpZCI6IjQyZkVXek5SVXpJSW1GZ0M4NUFkZ1UiLCJuYW1lIjoiRm9yZWlnbiBGYW1pbHkgQ29sbGVjdGl2ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0MmZFV3pOUlV6SUltRmdDODVBZGdVIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMDJYNjczQ2RxVGNTT21CRHVOWFBxdyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzAyWDY3M0NkcVRjU09tQkR1TlhQcXciLCJpZCI6IjAyWDY3M0NkcVRjU09tQkR1TlhQcXciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmFlYzkwMWZmMmM0YTg0NDVkODg2ZDIzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZhZWM5MDFmZjJjNGE4NDQ1ZDg4NmQyMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmFlYzkwMWZmMmM0YTg0NDVkODg2ZDIzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZvcmVpZ24gRmFtaWx5IENvbGxlY3RpdmUsIFZvbC4gMiIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDMtMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowMlg2NzNDZHFUY1NPbUJEdU5YUHF3In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUHh6R25DWUJwU3VhSTQ5T1I5NGNBIiwiaWQiOiIwUHh6R25DWUJwU3VhSTQ5T1I5NGNBIiwibmFtZSI6IkJpZyBXaWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjIwMDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNRWTUxNzA2MTEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82cDVjWHJpY2V3NWJ3Q0ZSS3Y1Y3I3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNnA1Y1hyaWNldzVid0NGUkt2NWNyNyIsImlkIjoiNnA1Y1hyaWNldzVid0NGUkt2NWNyNyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXaGVuIEkgR2V0IFRoZXJlIiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2cDVjWHJpY2V3NWJ3Q0ZSS3Y1Y3I3In1dfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldoZW4lMjBJJTIwR2V0JTIwVGhlcmUlMjIlMjBhcnRpc3QlM0ElMjJCaWclMjBXaWxkJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUHh6R25DWUJwU3VhSTQ5T1I5NGNBIiwiaWQiOiIwUHh6R25DWUJwU3VhSTQ5T1I5NGNBIiwibmFtZSI6IkJpZyBXaWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83OFJPY1I1cmtLNTZGblNZeEJvNDBMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzhST2NSNXJrSzU2Rm5TWXhCbzQwTCIsImlkIjoiNzhST2NSNXJrSzU2Rm5TWXhCbzQwTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zYw==", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I2Y2YxMmJlOThhZDg4NzcwMzNkNTM3YyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiNmNmMTJiZTk4YWQ4ODc3MDMzZDUzN2MifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI2Y2YxMmJlOThhZDg4NzcwMzNkNTM3YyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbnZpbmNpYmxlIEVQIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wMi0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzhST2NSNXJrSzU2Rm5TWXhCbzQwTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSIsImlkIjoiMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSIsIm5hbWUiOiJCaWcgV2lsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUHh6R25DWUJwU3VhSTQ5T1I5NGNBIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMDAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUVk1MTcwNjExMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN25ZQ2x6ek5ZNmYzRWNmZURGTnFoUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzduWUNsenpOWTZmM0VjZmVERk5xaFMiLCJpZCI6IjduWUNsenpOWTZmM0VjZmVERk5xaFMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2hlbiBJIEdldCBUaGVyZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3bllDbHp6Tlk2ZjNFY2ZlREZOcWhTIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzQyZkVXek5SVXpJSW1GZ0M4NUFkZ1UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNDJmRVd6TlJVeklJbUZnQzg1QWRnVSIsImlkIjoiNDJmRVd6TlJVeklJbUZnQzg1QWRnVSIsIm5hbWUiOiJGb3JlaWduIEZhbWlseSBDb2xsZWN0aQ==", + "dmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDJmRVd6TlJVeklJbUZnQzg1QWRnVSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzAyWDY3M0NkcVRjU09tQkR1TlhQcXcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wMlg2NzNDZHFUY1NPbUJEdU5YUHF3IiwiaWQiOiIwMlg2NzNDZHFUY1NPbUJEdU5YUHF3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ZhZWM5MDFmZjJjNGE4NDQ1ZDg4NmQyMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmYWVjOTAxZmYyYzRhODQ0NWQ4ODZkMjMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWZhZWM5MDFmZjJjNGE4NDQ1ZDg4NmQyMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGb3JlaWduIEZhbWlseSBDb2xsZWN0aXZlLCBWb2wuIDIiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTAzLTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MDJYNjczQ2RxVGNTT21CRHVOWFBxdyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSIsImlkIjoiMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSIsIm5hbWUiOiJCaWcgV2lsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUHh6R25DWUJwU3VhSTQ5T1I5NGNBIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMDAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUVk1MTcwNjExMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnA1Y1hyaWNldzVid0NGUkt2NWNyNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZwNWNYcmljZXc1YndDRlJLdjVjcjciLCJpZCI6IjZwNWNYcmljZXc1YndDRlJLdjVjcjciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2hlbiBJIEdldCBUaGVyZSIsInRyYWNrX251bQ==", + "YmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2cDVjWHJpY2V3NWJ3Q0ZSS3Y1Y3I3In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22When+I+Get+There%22+artist%3A%22Big+Wild%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNpbGslMjBDaGlmZm9uJTIyJTIwYXJ0aXN0JTNBJTIyTVVOQSUyQyUyMFBob2ViZSUyMEJyaWRnZXJzJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82eGRSYjJHeXBKN0RxbldBSTJtSEduIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ4ZFJiMkd5cEo3RHFuV0FJMm1IR24iLCJpZCI6IjZ4ZFJiMkd5cEo3RHFuV0FJMm1IR24iLCJuYW1lIjoiTVVOQSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2eGRSYjJHeXBKN0RxbldBSTJtSEduIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNG5kVHZUck53Z1VmUnc0ZzFSMkI0bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRuZFR2VHJOd2dVZlJ3NGcxUjJCNGwiLCJpZCI6IjRuZFR2VHJOd2dVZlJ3NGcxUjJCNGwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovLw==", + "aS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiYjVhM2RlOTdkNTQ4YTY0OWNmYWZlNjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmI1YTNkZTk3ZDU0OGE2NDljZmFmZTY3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiYjVhM2RlOTdkNTQ4YTY0OWNmYWZlNjcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTVVOQSIsInJlbGVhc2VfZGF0ZSI6IjIwMjItMDYtMjQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0bmRUdlRyTndnVWZSdzRnMVIyQjRsIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnhkUmIyR3lwSjdEcW5XQUkybUhHbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82eGRSYjJHeXBKN0RxbldBSTJtSEduIiwiaWQiOiI2eGRSYjJHeXBKN0RxbldBSTJtSEduIiwibmFtZSI6Ik1VTkEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnhkUmIyR3lwSjdEcW5XQUkybUhHbiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xcjF1eG95MTlmek14dW50M09OQWtHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJpZCI6IjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJuYW1lIjoiUGhvZWJlIEJyaWRnZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA2NTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNKNUcyMTAwNTAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81RUN4aUs0VmlnbzF5UlJtQW9aYzFmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUVDeGlLNFZpZ28xeVJSbUFvWmMxZiIsImlkIjoiNUVDeGlLNFZpZ28xeVJSbUFvWmMxZiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTaWxrIENoaWZmb24iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUVDeGlLNFZpZ28xeVJSbUFvWmMxZg==", + "In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Silk+Chiffon%22+artist%3A%22MUNA%2C+Phoebe+Bridgers%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Dermot%20%28see%20yourself%20in%20my%20eyes%29%22%20artist%3A%22Fred%20again..%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4oLeXFyACqeem2VImYeBFe"},"href":"https://api.spotify.com/v1/artists/4oLeXFyACqeem2VImYeBFe","id":"4oLeXFyACqeem2VImYeBFe","name":"Fred again..","type":"artist","uri":"spotify:artist:4oLeXFyACqeem2VImYeBFe"}],"external_urls":{"spotify":"https://open.spotify.com/album/6o86bV7TAt5x4exc2qLDqC"},"href":"https://api.spotify.com/v1/albums/6o86bV7TAt5x4exc2qLDqC","id":"6o86bV7TAt5x4exc2qLDqC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273723d4df900fd02eff83579d9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02723d4df900fd02eff83579d9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851723d4df900fd02eff83579d9"}],"is_playable":true,"name":"Actual Life (April 14 - December 17 2020)","release_date":"2021-04-15","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:6o86bV7TAt5x4exc2qLDqC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4oLeXFyACqeem2VImYeBFe"},"href":"https://api.spotify.com/v1/artists/4oLeXFyACqeem2VImYeBFe","id":"4oLeXFyACqeem2VImYeBFe","name":"Fred again..","type":"artist","uri":"spotify:artist:4oLeXFyACqeem2VImYeBFe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5KNNVgR6LBIABRIomyCwKJ"},"href":"https://api.spotify.com/v1/artists/5KNNVgR6LBIABRIomyCwKJ","id":"5KNNVgR6LBIABRIomyCwKJ","name":"Dermot Kennedy","type":"artist","uri":"spotify:artist:5KNNVgR6LBIABRIomyCwKJ"}],"disc_number":1,"duration_ms":228857,"explicit":true,"external_ids":{"isrc":"GBAHS2001195"},"external_urls":{"spotify":"https://open.spotify.com/track/1zAIRb8mTj8CcAUXW2FoMd"},"href":"https://api.spotify.com/v1/tracks/1zAIRb8mTj8CcAUXW2FoMd","id":"1zAIRb8mTj8CcAUXW2FoMd","is_local":false,"is_playable":true,"name":"Dermot (see yourself in my eyes)","track_number":3,"type":"track","uri":"spotify:track:1zAIRb8mTj8CcAUXW2FoMd"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4oLeXFyACqeem2VImYeBFe"},"href":"https://api.spotify.com/v1/artists/4oLeXFyACqeem2VImYeBFe","id":"4oLeXFyACqeem2VImYeBFe","name":"Fred again..","type":"artist","uri":"spotify:artist:4oLeXFyACqeem2VImYeBFe"}],"external_urls":{"spotify":"https://open.spotify.com/album/1K8YcEnJG2t7vifbRCOS69"},"href":"https://api.spotify.com/v1/albums/1K8YcEnJG2t7vifbRCOS69","id":"1K8YcEnJG2t7vifbRCOS69","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eff52f9ab4cb88b69c093ce6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eff52f9ab4cb88b69c093ce6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eff52f9ab4cb88b69c093ce6"}],"is_playable":true,"name":"Actual Life (April 14 - December 17 2020)","release_date":"2021-04-15","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:1K8YcEnJG2t7vifbRCOS69"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4oLeXFyACqeem2VImYeBFe"},"href":"https://api.spotify.com/v1/artists/4oLeXFyACqeem2VImYeBFe","id":"4oLeXFyACqeem2VImYeBFe","name":"Fred again..","type":"artist","uri":"spotify:artist:4oLeXFyACqeem2VImYeBFe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5KNNVgR6LBIABRIomyCwKJ"},"href":"https://api.spotify.com/v1/artists/5KNNVgR6LBIABRIomyCwKJ","id":"5KNNVgR6LBIABRIomyCwKJ","name":"Dermot Kennedy","type":"artist","uri":"spotify:artist:5KNNVgR6LBIABRIomyCwKJ"}],"disc_number":1,"duration_ms":228857,"explicit":true,"external_ids":{"isrc":"GBAHS2001195"},"external_urls":{"spotify":"https://open.spotify.com/track/5vQILUpDui3vsLpjUAqBd3"},"href":"https://api.spotify.com/v1/tracks/5vQILUpDui3vsLpjUAqBd3","id":"5vQILUpDui3vsLpjUAqBd3","is_local":false,"is_playable":true,"name":"Dermot (see yourself in my eyes)","track_number":3,"type":"track","uri":"spotify:track:5vQILUpDui3vsLpjUAqBd3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4oLeXFyACqeem2VImYeBFe"},"href":"https://api.spotify.com/v1/artists/4oLeXFyACqeem2VImYeBFe","id":"4oLeXFyACqeem2VImYeBFe","name":"Fred again..","type":"artist","uri":"spotify:artist:4oLeXFyACqeem2VImYeBFe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5KNNVgR6LBIABRIomyCwKJ"},"href":"https://api.spotify.com/v1/artists/5KNNVgR6LBIABRIomyCwKJ","id":"5KNNVgR6LBIABRIomyCwKJ","name":"Dermot Kennedy","type":"artist","uri":"spotify:artist:5KNNVgR6LBIABRIomyCwKJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/0HCeaOCRiWB8kK42nApFyy"},"href":"https://api.spotify.com/v1/albums/0HCeaOCRiWB8kK42nApFyy","id":"0HCeaOCRiWB8kK42nApFyy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27370a4527821761bac60e46c57"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0270a4527821761bac60e46c57"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485170a4527821761bac60e46c57"}],"is_playable":true,"name":"Dermot (see yourself in my eyes)","release_date":"2021-04-14","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0HCeaOCRiWB8kK42nApFyy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4oLeXFyACqeem2VImYeBFe"},"href":"https://api.spotify.com/v1/artists/4oLeXFyACqeem2VImYeBFe","id":"4oLeXFyACqeem2VImYeBFe","name":"Fred again..","type":"artist","uri":"spotify:artist:4oLeXFyACqeem2VImYeBFe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5KNNVgR6LBIABRIomyCwKJ"},"href":"https://api.spotify.com/v1/artists/5KNNVgR6LBIABRIomyCwKJ","id":"5KNNVgR6LBIABRIomyCwKJ","name":"Dermot Kennedy","type":"artist","uri":"spotify:artist:5KNNVgR6LBIABRIomyCwKJ"}],"disc_number":1,"duration_ms":228857,"explicit":true,"external_ids":{"isrc":"GBAHS2001195"},"external_urls":{"spotify":"https://open.spotify.com/track/0WY8rv7BxSzJseNuARBjBL"},"href":"https://api.spotify.com/v1/tracks/0WY8rv7BxSzJseNuARBjBL","id":"0WY8rv7BxSzJseNuARBjBL","is_local":false,"is_playable":true,"name":"Dermot (see yourself in my eyes)","track_number":1,"type":"track","uri":"spotify:track:0WY8rv7BxSzJseNuARBjBL"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRlcm1vdCUyMCUyOHNlZSUyMHlvdXJzZWxmJTIwaW4lMjBteSUyMGV5ZXMlMjklMjIlMjBhcnRpc3QlM0ElMjJGcmVkJTIwYWdhaW4uLiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80b0xlWEZ5QUNxZWVtMlZJbVllQkZlIiwiaWQiOiI0b0xlWEZ5QUNxZWVtMlZJbVllQkZlIiwibmFtZSI6IkZyZWQgYWdhaW4uLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0b0xlWEZ5QUNxZWVtMlZJbVllQkZlIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNm84NmJWN1RBdDV4NGV4YzJxTERxQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZvODZiVjdUQXQ1eDRleGMycUxEcUMiLCJpZCI6IjZvODZiVjdUQXQ1eDRleGMycUxEcUMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLA==", + "IndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3MjNkNGRmOTAwZmQwMmVmZjgzNTc5ZDkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzIzZDRkZjkwMGZkMDJlZmY4MzU3OWQ5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3MjNkNGRmOTAwZmQwMmVmZjgzNTc5ZDkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWN0dWFsIExpZmUgKEFwcmlsIDE0IC0gRGVjZW1iZXIgMTcgMjAyMCkiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTA0LTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nm84NmJWN1RBdDV4NGV4YzJxTERxQyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRvTGVYRnlBQ3FlZW0yVkltWWVCRmUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSIsImlkIjoiNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSIsIm5hbWUiOiJGcmVkIGFnYWluLi4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81S05OVmdSNkxCSUFCUklvbXlDd0tKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVLTk5WZ1I2TEJJQUJSSW9teUN3S0oiLCJpZCI6IjVLTk5WZ1I2TEJJQUJSSW9teUN3S0oiLCJuYW1lIjoiRGVybW90IEtlbm5lZHkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUtOTlZnUjZMQklBQlJJb215Q3dLSiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjg4NTcsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMjAwMTE5NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXpBSVJiOG1UajhDY0FVWFcyRm9NZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzF6QUlSYjhtVGo4Q2NBVVhXMkZvTWQiLCJpZCI6IjF6QUlSYjhtVGo4Q2NBVVhXMkZvTWQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGVybW90IChzZWUgeW91cnNlbA==", + "ZiBpbiBteSBleWVzKSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxekFJUmI4bVRqOENjQVVYVzJGb01kIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRvTGVYRnlBQ3FlZW0yVkltWWVCRmUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSIsImlkIjoiNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSIsIm5hbWUiOiJGcmVkIGFnYWluLi4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFLOFljRW5KRzJ0N3ZpZmJSQ09TNjkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xSzhZY0VuSkcydDd2aWZiUkNPUzY5IiwiaWQiOiIxSzhZY0VuSkcydDd2aWZiUkNPUzY5IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2VmZjUyZjlhYjRjYjg4YjY5YzA5M2NlNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlZmY1MmY5YWI0Y2I4OGI2OWMwOTNjZTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVmZjUyZjlhYjRjYjg4YjY5YzA5M2NlNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBY3R1YWwgTGlmZSAoQXByaWwgMTQgLSBEZWNlbWJlciAxNyAyMDIwKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDQtMTUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxSzhZY0VuSkcydDd2aWZiUkNPUzY5In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80b0xlWEZ5QUNxZWVtMlZJbVllQkZlIiwiaWQiOiI0b0xlWEZ5QUNxZWVtMlZJbVllQkZlIiwibmFtZSI6IkZyZWQgYWdhaW4uLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0b0xlWEZ5QUNxZWVtMlZJbVllQkZlIg==", + "fSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUtOTlZnUjZMQklBQlJJb215Q3dLSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81S05OVmdSNkxCSUFCUklvbXlDd0tKIiwiaWQiOiI1S05OVmdSNkxCSUFCUklvbXlDd0tKIiwibmFtZSI6IkRlcm1vdCBLZW5uZWR5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVLTk5WZ1I2TEJJQUJSSW9teUN3S0oifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI4ODU3LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIUzIwMDExOTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzV2UUlMVXBEdWkzdnNMcGpVQXFCZDMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81dlFJTFVwRHVpM3ZzTHBqVUFxQmQzIiwiaWQiOiI1dlFJTFVwRHVpM3ZzTHBqVUFxQmQzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlcm1vdCAoc2VlIHlvdXJzZWxmIGluIG15IGV5ZXMpIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjV2UUlMVXBEdWkzdnNMcGpVQXFCZDMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRvTGVYRnlBQ3FlZW0yVkltWWVCRmUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSIsImlkIjoiNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSIsIm5hbWUiOiJGcmVkIGFnYWluLi4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81S05OVmdSNkxCSUFCUklvbXlDd0tKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVLTk5WZ1I2TEJJQUJSSW9teUN3S0oiLCJpZCI6IjVLTk5WZ1I2TEJJQUJSSW9teUN3S0oiLCJuYW1lIjoiRGVybW90IEtlbm5lZHkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUtOTlZnUjZMQklBQlJJb215Q3dLSiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBIQ2VhT0NSaVdCOGtLNDJuQXBGeXkifSwiaHJlZiI6Imh0dA==", + "cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBIQ2VhT0NSaVdCOGtLNDJuQXBGeXkiLCJpZCI6IjBIQ2VhT0NSaVdCOGtLNDJuQXBGeXkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzBhNDUyNzgyMTc2MWJhYzYwZTQ2YzU3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjcwYTQ1Mjc4MjE3NjFiYWM2MGU0NmM1NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzBhNDUyNzgyMTc2MWJhYzYwZTQ2YzU3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlcm1vdCAoc2VlIHlvdXJzZWxmIGluIG15IGV5ZXMpIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wNC0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MEhDZWFPQ1JpV0I4a0s0Mm5BcEZ5eSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRvTGVYRnlBQ3FlZW0yVkltWWVCRmUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSIsImlkIjoiNG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSIsIm5hbWUiOiJGcmVkIGFnYWluLi4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NG9MZVhGeUFDcWVlbTJWSW1ZZUJGZSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81S05OVmdSNkxCSUFCUklvbXlDd0tKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVLTk5WZ1I2TEJJQUJSSW9teUN3S0oiLCJpZCI6IjVLTk5WZ1I2TEJJQUJSSW9teUN3S0oiLCJuYW1lIjoiRGVybW90IEtlbm5lZHkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUtOTlZnUjZMQklBQlJJb215Q3dLSiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjg4NTcsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMjAwMTE5NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMFdZOHJ2N0J4U3pKc2VOdUFSQmpCTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBXWThydjdCeFN6SnNlTnVBUg==", + "QmpCTCIsImlkIjoiMFdZOHJ2N0J4U3pKc2VOdUFSQmpCTCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZXJtb3QgKHNlZSB5b3Vyc2VsZiBpbiBteSBleWVzKSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowV1k4cnY3QnhTekpzZU51QVJCakJMIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Dermot+%28see+yourself+in+my+eyes%29%22+artist%3A%22Fred+again..%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1pc3NpbmclMjAtJTIwVG9kZCUyMFRlcnJ5JTIwUmVtaXglMjAlMkYlMjBSYWRpbyUyMEVkaXQlMjIlMjBhcnRpc3QlM0ElMjJFdmVyeXRoaW5nJTIwQnV0JTIwVGhlJTIwR2lybCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzEzY2NYcks3QW1YYjRUZGRNa0U3ankifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTNjY1hySzdBbVhiNFRkZE1rRTdqeSIsImlkIjoiMTNjY1hySzdBbVhiNFRkZE1rRTdqeSIsIm5hbWUiOiJFdmVyeXRoaW5nIEJ1dCBUaGUgR2lybCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxM2NjWHJLN0FtWGI0VGRkTWtFN2p5In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNExEcjhUemh4WTBRcHlmbTFjS05ZbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRMRHI4VHpoeFkwUXB5Zm0xY0tOWW8iLCJpZCI6IjRMRHI4VHpoeFkwUQ==", + "cHlmbTFjS05ZbyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmZDMxNTI5ODJmMzEwODhiOGIyMTdkYjAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZmQzMTUyOTgyZjMxMDg4YjhiMjE3ZGIwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmZDMxNTI5ODJmMzEwODhiOGIyMTdkYjAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWlzc2luZyAoUmVtaXhlcykiLCJyZWxlYXNlX2RhdGUiOiIxOTk0LTA4LTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NExEcjhUemh4WTBRcHlmbTFjS05ZbyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzEzY2NYcks3QW1YYjRUZGRNa0U3ankifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTNjY1hySzdBbVhiNFRkZE1rRTdqeSIsImlkIjoiMTNjY1hySzdBbVhiNFRkZE1rRTdqeSIsIm5hbWUiOiJFdmVyeXRoaW5nIEJ1dCBUaGUgR2lybCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxM2NjWHJLN0FtWGI0VGRkTWtFN2p5In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNkRTkyeUdXY3Jib1Axa0M1U1d5cXUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RFOTJ5R1djcmJvUDFrQzVTV3lxdSIsImlkIjoiM2RFOTJ5R1djcmJvUDFrQzVTV3lxdSIsIm5hbWUiOiJUb2RkIFRlcnJ5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNkRTkyeUdXY3Jib1Axa0M1U1d5cXUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMzMTYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFQ5NjAxMTI1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83SFd5QTEyR0poY244NjZPSjBRSGt0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN0hXeUExMkdKaGNuODY2T0owUUhrdCIsImlkIjoiN0hXeUExMkdKaGNuODY2T0owUUhrdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOg==", + "Ik1pc3NpbmcgLSBUb2RkIFRlcnJ5IFJlbWl4IFJhZGlvIEVkaXQiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N0hXeUExMkdKaGNuODY2T0owUUhrdCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xM2NjWHJLN0FtWGI0VGRkTWtFN2p5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzEzY2NYcks3QW1YYjRUZGRNa0U3ankiLCJpZCI6IjEzY2NYcks3QW1YYjRUZGRNa0U3ankiLCJuYW1lIjoiRXZlcnl0aGluZyBCdXQgVGhlIEdpcmwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTNjY1hySzdBbVhiNFRkZE1rRTdqeSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNmWmJKUktkWDRUQW9DNDN4bzVrV0sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zZlpiSlJLZFg0VEFvQzQzeG81a1dLIiwiaWQiOiIzZlpiSlJLZFg0VEFvQzQzeG81a1dLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZjZjEyMTM2ZDI2NmI2ZDkwNjA2OTY5NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2Y2YxMjEzNmQyNjZiNmQ5MDYwNjk2OTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZjZjEyMTM2ZDI2NmI2ZDkwNjA2OTY5NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMaWtlIFRoZSBEZXNlcnRzIE1pc3MgVGhlIFJhaW4iLCJyZWxlYXNlX2RhdGUiOiIyMDAyLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2ZaYkpSS2RYNFRBb0M0M3hvNWtXSyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzEzY2NYcks3QW1YYjRUZGRNa0U3ankifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTNjY1hySzdBbVhiNFRkZE1rRTdqeSIsImlkIjoiMTNjY1hySzdBbVhiNFRkZE1rRTdqeSIsIm5hbWUiOiJFdmVyeXRoaW5nIEJ1dCBUaGUgR2lybCIsInR5cGUiOiJhcnRpc3QiLCJ1cg==", + "aSI6InNwb3RpZnk6YXJ0aXN0OjEzY2NYcks3QW1YYjRUZGRNa0U3ankifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjM1MDI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFQwMTA5MDEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xSXN2WFpYQVY5RUJDNGhCS1c2eUROIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMUlzdlhaWEFWOUVCQzRoQktXNnlETiIsImlkIjoiMUlzdlhaWEFWOUVCQzRoQktXNnlETiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNaXNzaW5nIC0gVG9kZCBUZXJyeSBSZW1peCAvIFJhZGlvIEVkaXQiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFJc3ZYWlhBVjlFQkM0aEJLVzZ5RE4ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTNjY1hySzdBbVhiNFRkZE1rRTdqeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xM2NjWHJLN0FtWGI0VGRkTWtFN2p5IiwiaWQiOiIxM2NjWHJLN0FtWGI0VGRkTWtFN2p5IiwibmFtZSI6IkV2ZXJ5dGhpbmcgQnV0IFRoZSBHaXJsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjEzY2NYcks3QW1YYjRUZGRNa0U3ankifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xT0NTUUpDS1hPaTRrcXFMSWtxZnh2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMU9DU1FKQ0tYT2k0a3FxTElrcWZ4diIsImlkIjoiMU9DU1FKQ0tYT2k0a3FxTElrcWZ4diIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiNDVmMjg1ZTk3NzgzM2RhNzhmOWIwZWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjQ1ZjI4NWU5Nzc4MzNkYTc4ZjliMGVkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiNDVmMjg1ZTk3NzgzM2RhNzhmOWIwZWQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEJlc3QgT2YgRXZlcnl0aGluZyBCdXQgVGhlIEdpcmwiLCJyZWxlYXNlX2RhdGUiOg==", + "IjIwMjUtMTEtMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxT0NTUUpDS1hPaTRrcXFMSWtxZnh2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTNjY1hySzdBbVhiNFRkZE1rRTdqeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xM2NjWHJLN0FtWGI0VGRkTWtFN2p5IiwiaWQiOiIxM2NjWHJLN0FtWGI0VGRkTWtFN2p5IiwibmFtZSI6IkV2ZXJ5dGhpbmcgQnV0IFRoZSBHaXJsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjEzY2NYcks3QW1YYjRUZGRNa0U3ankifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMzMTYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFQ5NjAxMTI1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wT1M2ZmN2a2RJVFVlNmpSR2tya0o4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvME9TNmZjdmtkSVRVZTZqUkdrcmtKOCIsImlkIjoiME9TNmZjdmtkSVRVZTZqUkdrcmtKOCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNaXNzaW5nIC0gVG9kZCBUZXJyeSBSZW1peCBSYWRpbyBFZGl0IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBPUzZmY3ZrZElUVWU2alJHa3JrSjgifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Missing+-+Todd+Terry+Remix+%2F+Radio+Edit%22+artist%3A%22Everything+But+The+Girl%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Downtown%22%20artist%3A%22Godford%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"external_urls":{"spotify":"https://open.spotify.com/album/5gFwQJ5wcMQNPm69TYNFTP"},"href":"https://api.spotify.com/v1/albums/5gFwQJ5wcMQNPm69TYNFTP","id":"5gFwQJ5wcMQNPm69TYNFTP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aa9c8411d9f30cd99e93629c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aa9c8411d9f30cd99e93629c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aa9c8411d9f30cd99e93629c"}],"is_playable":true,"name":"Non Binary Place","release_date":"2020-09-25","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5gFwQJ5wcMQNPm69TYNFTP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"disc_number":1,"duration_ms":267911,"explicit":false,"external_ids":{"isrc":"FRD9M1900280"},"external_urls":{"spotify":"https://open.spotify.com/track/6WKu0pl1jHSuVo4PbSn2yk"},"href":"https://api.spotify.com/v1/tracks/6WKu0pl1jHSuVo4PbSn2yk","id":"6WKu0pl1jHSuVo4PbSn2yk","is_local":false,"is_playable":true,"name":"Downtown","track_number":2,"type":"track","uri":"spotify:track:6WKu0pl1jHSuVo4PbSn2yk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"external_urls":{"spotify":"https://open.spotify.com/album/1SxsP8sgDsbN2tefZTN9Ao"},"href":"https://api.spotify.com/v1/albums/1SxsP8sgDsbN2tefZTN9Ao","id":"1SxsP8sgDsbN2tefZTN9Ao","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273403f245a95ad96ca40599393"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02403f245a95ad96ca40599393"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851403f245a95ad96ca40599393"}],"is_playable":true,"name":"Downtown (Couros Remix)","release_date":"2021-01-13","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:1SxsP8sgDsbN2tefZTN9Ao"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"disc_number":1,"duration_ms":267911,"explicit":false,"external_ids":{"isrc":"FRD9M1900280"},"external_urls":{"spotify":"https://open.spotify.com/track/3q4DwnFcrYdpV1BlXifyAv"},"href":"https://api.spotify.com/v1/tracks/3q4DwnFcrYdpV1BlXifyAv","id":"3q4DwnFcrYdpV1BlXifyAv","is_local":false,"is_playable":true,"name":"Downtown","track_number":2,"type":"track","uri":"spotify:track:3q4DwnFcrYdpV1BlXifyAv"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Lz2iB6xfFvAWMUqcujGVk"},"href":"https://api.spotify.com/v1/albums/6Lz2iB6xfFvAWMUqcujGVk","id":"6Lz2iB6xfFvAWMUqcujGVk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734e2636c2696111408dd804fe"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024e2636c2696111408dd804fe"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514e2636c2696111408dd804fe"}],"is_playable":true,"name":"Downtown","release_date":"2020-01-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6Lz2iB6xfFvAWMUqcujGVk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"disc_number":1,"duration_ms":267911,"explicit":false,"external_ids":{"isrc":"FRD9M1900280"},"external_urls":{"spotify":"https://open.spotify.com/track/1mL66NYaEjriWFhTQiLyeI"},"href":"https://api.spotify.com/v1/tracks/1mL66NYaEjriWFhTQiLyeI","id":"1mL66NYaEjriWFhTQiLyeI","is_local":false,"is_playable":true,"name":"Downtown","track_number":1,"type":"track","uri":"spotify:track:1mL66NYaEjriWFhTQiLyeI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"external_urls":{"spotify":"https://open.spotify.com/album/1SxsP8sgDsbN2tefZTN9Ao"},"href":"https://api.spotify.com/v1/albums/1SxsP8sgDsbN2tefZTN9Ao","id":"1SxsP8sgDsbN2tefZTN9Ao","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273403f245a95ad96ca40599393"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02403f245a95ad96ca40599393"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851403f245a95ad96ca40599393"}],"is_playable":true,"name":"Downtown (Couros Remix)","release_date":"2021-01-13","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:1SxsP8sgDsbN2tefZTN9Ao"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7g0azP1aJBtmhhOk00SpIM"},"href":"https://api.spotify.com/v1/artists/7g0azP1aJBtmhhOk00SpIM","id":"7g0azP1aJBtmhhOk00SpIM","name":"Couros","type":"artist","uri":"spotify:artist:7g0azP1aJBtmhhOk00SpIM"}],"disc_number":1,"duration_ms":188701,"explicit":false,"external_ids":{"isrc":"QMFME2055810"},"external_urls":{"spotify":"https://open.spotify.com/track/1tFyeVd0R8yqxpK8H4sURf"},"href":"https://api.spotify.com/v1/tracks/1tFyeVd0R8yqxpK8H4sURf","id":"1tFyeVd0R8yqxpK8H4sURf","is_local":false,"is_playable":true,"name":"Downtown - Couros Remix","track_number":1,"type":"track","uri":"spotify:track:1tFyeVd0R8yqxpK8H4sURf"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRvd250b3duJTIyJTIwYXJ0aXN0JTNBJTIyR29kZm9yZCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwiaWQiOiI0cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwibmFtZSI6IkdvZGZvcmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVnRndRSjV3Y01RTlBtNjlUWU5GVFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81Z0Z3UUo1d2NNUU5QbTY5VFlORlRQIiwiaWQiOiI1Z0Z3UUo1d2NNUU5QbTY5VFlORlRQIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNg==", + "ZDAwMDBiMjczYWE5Yzg0MTFkOWYzMGNkOTllOTM2MjljIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmFhOWM4NDExZDlmMzBjZDk5ZTkzNjI5YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYWE5Yzg0MTFkOWYzMGNkOTllOTM2MjljIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vbiBCaW5hcnkgUGxhY2UiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTA5LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWdGd1FKNXdjTVFOUG02OVRZTkZUUCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSIsImlkIjoiNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSIsIm5hbWUiOiJHb2Rmb3JkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY3OTExLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiRlJEOU0xOTAwMjgwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82V0t1MHBsMWpIU3VWbzRQYlNuMnlrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNldLdTBwbDFqSFN1Vm80UGJTbjJ5ayIsImlkIjoiNldLdTBwbDFqSFN1Vm80UGJTbjJ5ayIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb3dudG93biIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2V0t1MHBsMWpIU3VWbzRQYlNuMnlrIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80cFV3dG5iUzZGZEJuaUxwNDEwQU91In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJpZCI6IjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJuYW1lIjoiR29kZm9yZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdA==", + "OjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xU3hzUDhzZ0RzYk4ydGVmWlROOUFvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVN4c1A4c2dEc2JOMnRlZlpUTjlBbyIsImlkIjoiMVN4c1A4c2dEc2JOMnRlZlpUTjlBbyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0MDNmMjQ1YTk1YWQ5NmNhNDA1OTkzOTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDAzZjI0NWE5NWFkOTZjYTQwNTk5MzkzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0MDNmMjQ1YTk1YWQ5NmNhNDA1OTkzOTMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRG93bnRvd24gKENvdXJvcyBSZW1peCkiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTAxLTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxU3hzUDhzZ0RzYk4ydGVmWlROOUFvIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwiaWQiOiI0cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwibmFtZSI6IkdvZGZvcmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjc5MTEsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJGUkQ5TTE5MDAyODAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNxNER3bkZjcllkcFYxQmxYaWZ5QXYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zcTREd25GY3JZZHBWMUJsWGlmeUF2IiwiaWQiOiIzcTREd25GY3JZZHBWMUJsWGlmeUF2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRvd250b3duIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNxNER3bkZjcllkcFYxQmxYaQ==", + "ZnlBdiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwiaWQiOiI0cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwibmFtZSI6IkdvZGZvcmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZMejJpQjZ4ZkZ2QVdNVXFjdWpHVmsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82THoyaUI2eGZGdkFXTVVxY3VqR1ZrIiwiaWQiOiI2THoyaUI2eGZGdkFXTVVxY3VqR1ZrIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRlMjYzNmMyNjk2MTExNDA4ZGQ4MDRmZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0ZTI2MzZjMjY5NjExMTQwOGRkODA0ZmUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRlMjYzNmMyNjk2MTExNDA4ZGQ4MDRmZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb3dudG93biIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDEtMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZMejJpQjZ4ZkZ2QVdNVXFjdWpHVmsifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80cFV3dG5iUzZGZEJuaUxwNDEwQU91In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJpZCI6IjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJuYW1lIjoiR29kZm9yZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0cFV3dG5iUzZGZEJuaUxwNDEwQU91In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2NzkxMSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkZSRDlNMTkwMDI4MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwcw==", + "Oi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xbUw2Nk5ZYUVqcmlXRmhUUWlMeWVJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMW1MNjZOWWFFanJpV0ZoVFFpTHllSSIsImlkIjoiMW1MNjZOWWFFanJpV0ZoVFFpTHllSSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb3dudG93biIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxbUw2Nk5ZYUVqcmlXRmhUUWlMeWVJIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80cFV3dG5iUzZGZEJuaUxwNDEwQU91In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJpZCI6IjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJuYW1lIjoiR29kZm9yZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0cFV3dG5iUzZGZEJuaUxwNDEwQU91In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMVN4c1A4c2dEc2JOMnRlZlpUTjlBbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFTeHNQOHNnRHNiTjJ0ZWZaVE45QW8iLCJpZCI6IjFTeHNQOHNnRHNiTjJ0ZWZaVE45QW8iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDAzZjI0NWE5NWFkOTZjYTQwNTk5MzkzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQwM2YyNDVhOTVhZDk2Y2E0MDU5OTM5MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDAzZjI0NWE5NWFkOTZjYTQwNTk5MzkzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRvd250b3duIChDb3Vyb3MgUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wMS0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVN4c1A4c2dEc2JOMnRlZlpUTjlBbyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UifSwiaHJlZiI6Imh0dHBzOi8vYQ==", + "cGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwiaWQiOiI0cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwibmFtZSI6IkdvZGZvcmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83ZzBhelAxYUpCdG1oaE9rMDBTcElNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdnMGF6UDFhSkJ0bWhoT2swMFNwSU0iLCJpZCI6IjdnMGF6UDFhSkJ0bWhoT2swMFNwSU0iLCJuYW1lIjoiQ291cm9zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdnMGF6UDFhSkJ0bWhoT2swMFNwSU0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg4NzAxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU1GTUUyMDU1ODEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xdEZ5ZVZkMFI4eXF4cEs4SDRzVVJmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMXRGeWVWZDBSOHlxeHBLOEg0c1VSZiIsImlkIjoiMXRGeWVWZDBSOHlxeHBLOEg0c1VSZiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb3dudG93biAtIENvdXJvcyBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxdEZ5ZVZkMFI4eXF4cEs4SDRzVVJmIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Downtown%22+artist%3A%22Godford%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Breathe%22%20artist%3A%22T%C3%A9l%C3%A9popmusik%22&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=track%3A%22Breathe%22%20artist%3A%22T%C3%A9l%C3%A9popmusik%22&type=track","offset":0,"previous":null,"total":49,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1H10CTGW4xbk0IQewKbK50"},"href":"https://api.spotify.com/v1/albums/1H10CTGW4xbk0IQewKbK50","id":"1H10CTGW4xbk0IQewKbK50","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c65b1f9d6ca322de8b85c505"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c65b1f9d6ca322de8b85c505"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c65b1f9d6ca322de8b85c505"}],"is_playable":true,"name":"Genetic World","release_date":"2001-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1H10CTGW4xbk0IQewKbK50"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"}],"disc_number":1,"duration_ms":282240,"explicit":false,"external_ids":{"isrc":"FR06S0100640"},"external_urls":{"spotify":"https://open.spotify.com/track/0uKrhHBDUQ4w5fv4qwOubP"},"href":"https://api.spotify.com/v1/tracks/0uKrhHBDUQ4w5fv4qwOubP","id":"0uKrhHBDUQ4w5fv4qwOubP","is_local":false,"is_playable":true,"name":"Breathe","track_number":1,"type":"track","uri":"spotify:track:0uKrhHBDUQ4w5fv4qwOubP"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/46OinxqikuTDaz5Nx3e2yf"},"href":"https://api.spotify.com/v1/albums/46OinxqikuTDaz5Nx3e2yf","id":"46OinxqikuTDaz5Nx3e2yf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273547419ecdaac283a77f0d168"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02547419ecdaac283a77f0d168"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851547419ecdaac283a77f0d168"}],"is_playable":true,"name":"Breathe","release_date":"2002-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:46OinxqikuTDaz5Nx3e2yf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"}],"disc_number":1,"duration_ms":282240,"explicit":false,"external_ids":{"isrc":"FR06S0100640"},"external_urls":{"spotify":"https://open.spotify.com/track/3y7do6E0MayKxmr5PA35OJ"},"href":"https://api.spotify.com/v1/tracks/3y7do6E0MayKxmr5PA35OJ","id":"3y7do6E0MayKxmr5PA35OJ","is_local":false,"is_playable":true,"name":"Breathe","track_number":2,"type":"track","uri":"spotify:track:3y7do6E0MayKxmr5PA35OJ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/26V81xoenFivvzHqYrnbOs"},"href":"https://api.spotify.com/v1/albums/26V81xoenFivvzHqYrnbOs","id":"26V81xoenFivvzHqYrnbOs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27320a036e55b3d6d7f22d4abac"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0220a036e55b3d6d7f22d4abac"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485120a036e55b3d6d7f22d4abac"}],"is_playable":true,"name":"Breathe - EP 20th Anniversary","release_date":"2021-07-09","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:26V81xoenFivvzHqYrnbOs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2G7QgTep5IsJHGHm1hXygD"},"href":"https://api.spotify.com/v1/artists/2G7QgTep5IsJHGHm1hXygD","id":"2G7QgTep5IsJHGHm1hXygD","name":"Kid Francescoli","type":"artist","uri":"spotify:artist:2G7QgTep5IsJHGHm1hXygD"}],"disc_number":1,"duration_ms":294240,"explicit":false,"external_ids":{"isrc":"FR99U2100004"},"external_urls":{"spotify":"https://open.spotify.com/track/3w532oVeE29riSdRHFUWMc"},"href":"https://api.spotify.com/v1/tracks/3w532oVeE29riSdRHFUWMc","id":"3w532oVeE29riSdRHFUWMc","is_local":false,"is_playable":true,"name":"Breathe - Kid Francescoli Remix","track_number":3,"type":"track","uri":"spotify:track:3w532oVeE29riSdRHFUWMc"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/0jUTCOLcSrOKpiwgzaEiMp"},"href":"https://api.spotify.com/v1/albums/0jUTCOLcSrOKpiwgzaEiMp","id":"0jUTCOLcSrOKpiwgzaEiMp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346a76f5847161415059e0713"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246a76f5847161415059e0713"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146a76f5847161415059e0713"}],"is_playable":true,"name":"Breathe (Remixes)","release_date":"2017-04-21","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:0jUTCOLcSrOKpiwgzaEiMp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3E4UsjXgFv2GdwshMkkJze"},"href":"https://api.spotify.com/v1/artists/3E4UsjXgFv2GdwshMkkJze","id":"3E4UsjXgFv2GdwshMkkJze","name":"Kartell","type":"artist","uri":"spotify:artist:3E4UsjXgFv2GdwshMkkJze"}],"disc_number":1,"duration_ms":203500,"explicit":false,"external_ids":{"isrc":"FR2X41724050"},"external_urls":{"spotify":"https://open.spotify.com/track/7rHmT1Ks5CPA2xEWpGQ19T"},"href":"https://api.spotify.com/v1/tracks/7rHmT1Ks5CPA2xEWpGQ19T","id":"7rHmT1Ks5CPA2xEWpGQ19T","is_local":false,"is_playable":true,"name":"Breathe - Kartell Slow Remix","track_number":3,"type":"track","uri":"spotify:track:7rHmT1Ks5CPA2xEWpGQ19T"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/0jUTCOLcSrOKpiwgzaEiMp"},"href":"https://api.spotify.com/v1/albums/0jUTCOLcSrOKpiwgzaEiMp","id":"0jUTCOLcSrOKpiwgzaEiMp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346a76f5847161415059e0713"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246a76f5847161415059e0713"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146a76f5847161415059e0713"}],"is_playable":true,"name":"Breathe (Remixes)","release_date":"2017-04-21","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:0jUTCOLcSrOKpiwgzaEiMp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3E4UsjXgFv2GdwshMkkJze"},"href":"https://api.spotify.com/v1/artists/3E4UsjXgFv2GdwshMkkJze","id":"3E4UsjXgFv2GdwshMkkJze","name":"Kartell","type":"artist","uri":"spotify:artist:3E4UsjXgFv2GdwshMkkJze"}],"disc_number":1,"duration_ms":278168,"explicit":false,"external_ids":{"isrc":"FR2X41724051"},"external_urls":{"spotify":"https://open.spotify.com/track/5OooVYLYftkAdVz1k7QY3H"},"href":"https://api.spotify.com/v1/tracks/5OooVYLYftkAdVz1k7QY3H","id":"5OooVYLYftkAdVz1k7QY3H","is_local":false,"is_playable":true,"name":"Breathe - Kartell Club Remix","track_number":4,"type":"track","uri":"spotify:track:5OooVYLYftkAdVz1k7QY3H"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/7uwst1AbxsBqjReIML8ZrP"},"href":"https://api.spotify.com/v1/albums/7uwst1AbxsBqjReIML8ZrP","id":"7uwst1AbxsBqjReIML8ZrP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b7ed02f725653a7c9f727fb9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b7ed02f725653a7c9f727fb9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b7ed02f725653a7c9f727fb9"}],"is_playable":true,"name":"Breathe (Remixes)","release_date":"2001-01-01","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:7uwst1AbxsBqjReIML8ZrP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"}],"disc_number":1,"duration_ms":436306,"explicit":false,"external_ids":{"isrc":"FR06S0100642"},"external_urls":{"spotify":"https://open.spotify.com/track/1M78umlHo6p8w6dl1WZJRt"},"href":"https://api.spotify.com/v1/tracks/1M78umlHo6p8w6dl1WZJRt","id":"1M78umlHo6p8w6dl1WZJRt","is_local":false,"is_playable":true,"name":"Breathe - Extended Mix","track_number":1,"type":"track","uri":"spotify:track:1M78umlHo6p8w6dl1WZJRt"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4L74W177Wc8s7WrQHbVaXt"},"href":"https://api.spotify.com/v1/artists/4L74W177Wc8s7WrQHbVaXt","id":"4L74W177Wc8s7WrQHbVaXt","name":"Caf\u00e9 del Mar","type":"artist","uri":"spotify:artist:4L74W177Wc8s7WrQHbVaXt"}],"external_urls":{"spotify":"https://open.spotify.com/album/5J71VkRlIlb29liyg7UQP5"},"href":"https://api.spotify.com/v1/albums/5J71VkRlIlb29liyg7UQP5","id":"5J71VkRlIlb29liyg7UQP5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737bd55c4b83f9551fc6fd8df4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027bd55c4b83f9551fc6fd8df4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517bd55c4b83f9551fc6fd8df4"}],"is_playable":true,"name":"Caf\u00e9 del Mar Vol. 23","release_date":"2017-06-30","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:5J71VkRlIlb29liyg7UQP5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3E4UsjXgFv2GdwshMkkJze"},"href":"https://api.spotify.com/v1/artists/3E4UsjXgFv2GdwshMkkJze","id":"3E4UsjXgFv2GdwshMkkJze","name":"Kartell","type":"artist","uri":"spotify:artist:3E4UsjXgFv2GdwshMkkJze"}],"disc_number":1,"duration_ms":204500,"explicit":false,"external_ids":{"isrc":"ES8741723101"},"external_urls":{"spotify":"https://open.spotify.com/track/31TQJxKMxLbRVcrGuUUlrZ"},"href":"https://api.spotify.com/v1/tracks/31TQJxKMxLbRVcrGuUUlrZ","id":"31TQJxKMxLbRVcrGuUUlrZ","is_local":false,"is_playable":true,"name":"Breathe - Kartell Slow Remix","track_number":1,"type":"track","uri":"spotify:track:31TQJxKMxLbRVcrGuUUlrZ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/26V81xoenFivvzHqYrnbOs"},"href":"https://api.spotify.com/v1/albums/26V81xoenFivvzHqYrnbOs","id":"26V81xoenFivvzHqYrnbOs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27320a036e55b3d6d7f22d4abac"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0220a036e55b3d6d7f22d4abac"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485120a036e55b3d6d7f22d4abac"}],"is_playable":true,"name":"Breathe - EP 20th Anniversary","release_date":"2021-07-09","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:26V81xoenFivvzHqYrnbOs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"}],"disc_number":1,"duration_ms":282240,"explicit":false,"external_ids":{"isrc":"FR06S0100640"},"external_urls":{"spotify":"https://open.spotify.com/track/3RmPGb3IUCEGIpTELuSlEc"},"href":"https://api.spotify.com/v1/tracks/3RmPGb3IUCEGIpTELuSlEc","id":"3RmPGb3IUCEGIpTELuSlEc","is_local":false,"is_playable":true,"name":"Breathe","track_number":8,"type":"track","uri":"spotify:track:3RmPGb3IUCEGIpTELuSlEc"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6u9m2Ocxutj8gv7UJdwiWJ"},"href":"https://api.spotify.com/v1/artists/6u9m2Ocxutj8gv7UJdwiWJ","id":"6u9m2Ocxutj8gv7UJdwiWJ","name":"Juicy Cola","type":"artist","uri":"spotify:artist:6u9m2Ocxutj8gv7UJdwiWJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/0SIRiM98Jwa8XQygErNnvD"},"href":"https://api.spotify.com/v1/albums/0SIRiM98Jwa8XQygErNnvD","id":"0SIRiM98Jwa8XQygErNnvD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733ca957c9e674e36e5f3b3572"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023ca957c9e674e36e5f3b3572"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513ca957c9e674e36e5f3b3572"}],"is_playable":true,"name":"Breathe - Juicy Cola Remix","release_date":"2021-07-08","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0SIRiM98Jwa8XQygErNnvD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6u9m2Ocxutj8gv7UJdwiWJ"},"href":"https://api.spotify.com/v1/artists/6u9m2Ocxutj8gv7UJdwiWJ","id":"6u9m2Ocxutj8gv7UJdwiWJ","name":"Juicy Cola","type":"artist","uri":"spotify:artist:6u9m2Ocxutj8gv7UJdwiWJ"}],"disc_number":1,"duration_ms":177440,"explicit":false,"external_ids":{"isrc":"FR99U2100006"},"external_urls":{"spotify":"https://open.spotify.com/track/36xHDAuoyzgaLJG6LZz9za"},"href":"https://api.spotify.com/v1/tracks/36xHDAuoyzgaLJG6LZz9za","id":"36xHDAuoyzgaLJG6LZz9za","is_local":false,"is_playable":true,"name":"Breathe - Juicy Cola Remix","track_number":1,"type":"track","uri":"spotify:track:36xHDAuoyzgaLJG6LZz9za"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/46OinxqikuTDaz5Nx3e2yf"},"href":"https://api.spotify.com/v1/albums/46OinxqikuTDaz5Nx3e2yf","id":"46OinxqikuTDaz5Nx3e2yf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273547419ecdaac283a77f0d168"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02547419ecdaac283a77f0d168"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851547419ecdaac283a77f0d168"}],"is_playable":true,"name":"Breathe","release_date":"2002-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:46OinxqikuTDaz5Nx3e2yf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5L4vTbPKWxGWvnWLwEzuLl"},"href":"https://api.spotify.com/v1/artists/5L4vTbPKWxGWvnWLwEzuLl","id":"5L4vTbPKWxGWvnWLwEzuLl","name":"2square","type":"artist","uri":"spotify:artist:5L4vTbPKWxGWvnWLwEzuLl"}],"disc_number":1,"duration_ms":192500,"explicit":false,"external_ids":{"isrc":"FR06S0200647"},"external_urls":{"spotify":"https://open.spotify.com/track/7FHx5qvlbu5VeABLSGuLAX"},"href":"https://api.spotify.com/v1/tracks/7FHx5qvlbu5VeABLSGuLAX","id":"7FHx5qvlbu5VeABLSGuLAX","is_local":false,"is_playable":true,"name":"Breathe - 2square Remix","track_number":1,"type":"track","uri":"spotify:track:7FHx5qvlbu5VeABLSGuLAX"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Breathe%22%20artist%3A%22T%C3%A9l%C3%A9popmusik%22&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=track%3A%22Breathe%22%20artist%3A%22T%C3%A9l%C3%A9popmusik%22&type=track","offset":0,"previous":null,"total":49,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1H10CTGW4xbk0IQewKbK50"},"href":"https://api.spotify.com/v1/albums/1H10CTGW4xbk0IQewKbK50","id":"1H10CTGW4xbk0IQewKbK50","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c65b1f9d6ca322de8b85c505"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c65b1f9d6ca322de8b85c505"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c65b1f9d6ca322de8b85c505"}],"is_playable":true,"name":"Genetic World","release_date":"2001-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1H10CTGW4xbk0IQewKbK50"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"}],"disc_number":1,"duration_ms":282240,"explicit":false,"external_ids":{"isrc":"FR06S0100640"},"external_urls":{"spotify":"https://open.spotify.com/track/0uKrhHBDUQ4w5fv4qwOubP"},"href":"https://api.spotify.com/v1/tracks/0uKrhHBDUQ4w5fv4qwOubP","id":"0uKrhHBDUQ4w5fv4qwOubP","is_local":false,"is_playable":true,"name":"Breathe","track_number":1,"type":"track","uri":"spotify:track:0uKrhHBDUQ4w5fv4qwOubP"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/46OinxqikuTDaz5Nx3e2yf"},"href":"https://api.spotify.com/v1/albums/46OinxqikuTDaz5Nx3e2yf","id":"46OinxqikuTDaz5Nx3e2yf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273547419ecdaac283a77f0d168"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02547419ecdaac283a77f0d168"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851547419ecdaac283a77f0d168"}],"is_playable":true,"name":"Breathe","release_date":"2002-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:46OinxqikuTDaz5Nx3e2yf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"}],"disc_number":1,"duration_ms":282240,"explicit":false,"external_ids":{"isrc":"FR06S0100640"},"external_urls":{"spotify":"https://open.spotify.com/track/3y7do6E0MayKxmr5PA35OJ"},"href":"https://api.spotify.com/v1/tracks/3y7do6E0MayKxmr5PA35OJ","id":"3y7do6E0MayKxmr5PA35OJ","is_local":false,"is_playable":true,"name":"Breathe","track_number":2,"type":"track","uri":"spotify:track:3y7do6E0MayKxmr5PA35OJ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/26V81xoenFivvzHqYrnbOs"},"href":"https://api.spotify.com/v1/albums/26V81xoenFivvzHqYrnbOs","id":"26V81xoenFivvzHqYrnbOs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27320a036e55b3d6d7f22d4abac"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0220a036e55b3d6d7f22d4abac"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485120a036e55b3d6d7f22d4abac"}],"is_playable":true,"name":"Breathe - EP 20th Anniversary","release_date":"2021-07-09","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:26V81xoenFivvzHqYrnbOs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2G7QgTep5IsJHGHm1hXygD"},"href":"https://api.spotify.com/v1/artists/2G7QgTep5IsJHGHm1hXygD","id":"2G7QgTep5IsJHGHm1hXygD","name":"Kid Francescoli","type":"artist","uri":"spotify:artist:2G7QgTep5IsJHGHm1hXygD"}],"disc_number":1,"duration_ms":294240,"explicit":false,"external_ids":{"isrc":"FR99U2100004"},"external_urls":{"spotify":"https://open.spotify.com/track/3w532oVeE29riSdRHFUWMc"},"href":"https://api.spotify.com/v1/tracks/3w532oVeE29riSdRHFUWMc","id":"3w532oVeE29riSdRHFUWMc","is_local":false,"is_playable":true,"name":"Breathe - Kid Francescoli Remix","track_number":3,"type":"track","uri":"spotify:track:3w532oVeE29riSdRHFUWMc"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/0jUTCOLcSrOKpiwgzaEiMp"},"href":"https://api.spotify.com/v1/albums/0jUTCOLcSrOKpiwgzaEiMp","id":"0jUTCOLcSrOKpiwgzaEiMp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346a76f5847161415059e0713"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246a76f5847161415059e0713"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146a76f5847161415059e0713"}],"is_playable":true,"name":"Breathe (Remixes)","release_date":"2017-04-21","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:0jUTCOLcSrOKpiwgzaEiMp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3E4UsjXgFv2GdwshMkkJze"},"href":"https://api.spotify.com/v1/artists/3E4UsjXgFv2GdwshMkkJze","id":"3E4UsjXgFv2GdwshMkkJze","name":"Kartell","type":"artist","uri":"spotify:artist:3E4UsjXgFv2GdwshMkkJze"}],"disc_number":1,"duration_ms":203500,"explicit":false,"external_ids":{"isrc":"FR2X41724050"},"external_urls":{"spotify":"https://open.spotify.com/track/7rHmT1Ks5CPA2xEWpGQ19T"},"href":"https://api.spotify.com/v1/tracks/7rHmT1Ks5CPA2xEWpGQ19T","id":"7rHmT1Ks5CPA2xEWpGQ19T","is_local":false,"is_playable":true,"name":"Breathe - Kartell Slow Remix","track_number":3,"type":"track","uri":"spotify:track:7rHmT1Ks5CPA2xEWpGQ19T"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/0jUTCOLcSrOKpiwgzaEiMp"},"href":"https://api.spotify.com/v1/albums/0jUTCOLcSrOKpiwgzaEiMp","id":"0jUTCOLcSrOKpiwgzaEiMp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346a76f5847161415059e0713"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246a76f5847161415059e0713"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146a76f5847161415059e0713"}],"is_playable":true,"name":"Breathe (Remixes)","release_date":"2017-04-21","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:0jUTCOLcSrOKpiwgzaEiMp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3E4UsjXgFv2GdwshMkkJze"},"href":"https://api.spotify.com/v1/artists/3E4UsjXgFv2GdwshMkkJze","id":"3E4UsjXgFv2GdwshMkkJze","name":"Kartell","type":"artist","uri":"spotify:artist:3E4UsjXgFv2GdwshMkkJze"}],"disc_number":1,"duration_ms":278168,"explicit":false,"external_ids":{"isrc":"FR2X41724051"},"external_urls":{"spotify":"https://open.spotify.com/track/5OooVYLYftkAdVz1k7QY3H"},"href":"https://api.spotify.com/v1/tracks/5OooVYLYftkAdVz1k7QY3H","id":"5OooVYLYftkAdVz1k7QY3H","is_local":false,"is_playable":true,"name":"Breathe - Kartell Club Remix","track_number":4,"type":"track","uri":"spotify:track:5OooVYLYftkAdVz1k7QY3H"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/7uwst1AbxsBqjReIML8ZrP"},"href":"https://api.spotify.com/v1/albums/7uwst1AbxsBqjReIML8ZrP","id":"7uwst1AbxsBqjReIML8ZrP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b7ed02f725653a7c9f727fb9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b7ed02f725653a7c9f727fb9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b7ed02f725653a7c9f727fb9"}],"is_playable":true,"name":"Breathe (Remixes)","release_date":"2001-01-01","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:7uwst1AbxsBqjReIML8ZrP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"}],"disc_number":1,"duration_ms":436306,"explicit":false,"external_ids":{"isrc":"FR06S0100642"},"external_urls":{"spotify":"https://open.spotify.com/track/1M78umlHo6p8w6dl1WZJRt"},"href":"https://api.spotify.com/v1/tracks/1M78umlHo6p8w6dl1WZJRt","id":"1M78umlHo6p8w6dl1WZJRt","is_local":false,"is_playable":true,"name":"Breathe - Extended Mix","track_number":1,"type":"track","uri":"spotify:track:1M78umlHo6p8w6dl1WZJRt"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4L74W177Wc8s7WrQHbVaXt"},"href":"https://api.spotify.com/v1/artists/4L74W177Wc8s7WrQHbVaXt","id":"4L74W177Wc8s7WrQHbVaXt","name":"Caf\u00e9 del Mar","type":"artist","uri":"spotify:artist:4L74W177Wc8s7WrQHbVaXt"}],"external_urls":{"spotify":"https://open.spotify.com/album/5J71VkRlIlb29liyg7UQP5"},"href":"https://api.spotify.com/v1/albums/5J71VkRlIlb29liyg7UQP5","id":"5J71VkRlIlb29liyg7UQP5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737bd55c4b83f9551fc6fd8df4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027bd55c4b83f9551fc6fd8df4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517bd55c4b83f9551fc6fd8df4"}],"is_playable":true,"name":"Caf\u00e9 del Mar Vol. 23","release_date":"2017-06-30","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:5J71VkRlIlb29liyg7UQP5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3E4UsjXgFv2GdwshMkkJze"},"href":"https://api.spotify.com/v1/artists/3E4UsjXgFv2GdwshMkkJze","id":"3E4UsjXgFv2GdwshMkkJze","name":"Kartell","type":"artist","uri":"spotify:artist:3E4UsjXgFv2GdwshMkkJze"}],"disc_number":1,"duration_ms":204500,"explicit":false,"external_ids":{"isrc":"ES8741723101"},"external_urls":{"spotify":"https://open.spotify.com/track/31TQJxKMxLbRVcrGuUUlrZ"},"href":"https://api.spotify.com/v1/tracks/31TQJxKMxLbRVcrGuUUlrZ","id":"31TQJxKMxLbRVcrGuUUlrZ","is_local":false,"is_playable":true,"name":"Breathe - Kartell Slow Remix","track_number":1,"type":"track","uri":"spotify:track:31TQJxKMxLbRVcrGuUUlrZ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/26V81xoenFivvzHqYrnbOs"},"href":"https://api.spotify.com/v1/albums/26V81xoenFivvzHqYrnbOs","id":"26V81xoenFivvzHqYrnbOs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27320a036e55b3d6d7f22d4abac"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0220a036e55b3d6d7f22d4abac"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485120a036e55b3d6d7f22d4abac"}],"is_playable":true,"name":"Breathe - EP 20th Anniversary","release_date":"2021-07-09","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:26V81xoenFivvzHqYrnbOs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"}],"disc_number":1,"duration_ms":282240,"explicit":false,"external_ids":{"isrc":"FR06S0100640"},"external_urls":{"spotify":"https://open.spotify.com/track/3RmPGb3IUCEGIpTELuSlEc"},"href":"https://api.spotify.com/v1/tracks/3RmPGb3IUCEGIpTELuSlEc","id":"3RmPGb3IUCEGIpTELuSlEc","is_local":false,"is_playable":true,"name":"Breathe","track_number":8,"type":"track","uri":"spotify:track:3RmPGb3IUCEGIpTELuSlEc"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6u9m2Ocxutj8gv7UJdwiWJ"},"href":"https://api.spotify.com/v1/artists/6u9m2Ocxutj8gv7UJdwiWJ","id":"6u9m2Ocxutj8gv7UJdwiWJ","name":"Juicy Cola","type":"artist","uri":"spotify:artist:6u9m2Ocxutj8gv7UJdwiWJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/0SIRiM98Jwa8XQygErNnvD"},"href":"https://api.spotify.com/v1/albums/0SIRiM98Jwa8XQygErNnvD","id":"0SIRiM98Jwa8XQygErNnvD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733ca957c9e674e36e5f3b3572"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023ca957c9e674e36e5f3b3572"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513ca957c9e674e36e5f3b3572"}],"is_playable":true,"name":"Breathe - Juicy Cola Remix","release_date":"2021-07-08","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0SIRiM98Jwa8XQygErNnvD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6u9m2Ocxutj8gv7UJdwiWJ"},"href":"https://api.spotify.com/v1/artists/6u9m2Ocxutj8gv7UJdwiWJ","id":"6u9m2Ocxutj8gv7UJdwiWJ","name":"Juicy Cola","type":"artist","uri":"spotify:artist:6u9m2Ocxutj8gv7UJdwiWJ"}],"disc_number":1,"duration_ms":177440,"explicit":false,"external_ids":{"isrc":"FR99U2100006"},"external_urls":{"spotify":"https://open.spotify.com/track/36xHDAuoyzgaLJG6LZz9za"},"href":"https://api.spotify.com/v1/tracks/36xHDAuoyzgaLJG6LZz9za","id":"36xHDAuoyzgaLJG6LZz9za","is_local":false,"is_playable":true,"name":"Breathe - Juicy Cola Remix","track_number":1,"type":"track","uri":"spotify:track:36xHDAuoyzgaLJG6LZz9za"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"}],"external_urls":{"spotify":"https://open.spotify.com/album/46OinxqikuTDaz5Nx3e2yf"},"href":"https://api.spotify.com/v1/albums/46OinxqikuTDaz5Nx3e2yf","id":"46OinxqikuTDaz5Nx3e2yf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273547419ecdaac283a77f0d168"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02547419ecdaac283a77f0d168"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851547419ecdaac283a77f0d168"}],"is_playable":true,"name":"Breathe","release_date":"2002-01-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:46OinxqikuTDaz5Nx3e2yf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3aKCo8gLJfuPYtr88aWKjF"},"href":"https://api.spotify.com/v1/artists/3aKCo8gLJfuPYtr88aWKjF","id":"3aKCo8gLJfuPYtr88aWKjF","name":"T\u00e9l\u00e9popmusik","type":"artist","uri":"spotify:artist:3aKCo8gLJfuPYtr88aWKjF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5AlIxbb8HarTSm2tdA5F0x"},"href":"https://api.spotify.com/v1/artists/5AlIxbb8HarTSm2tdA5F0x","id":"5AlIxbb8HarTSm2tdA5F0x","name":"Angela McCluskey","type":"artist","uri":"spotify:artist:5AlIxbb8HarTSm2tdA5F0x"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5L4vTbPKWxGWvnWLwEzuLl"},"href":"https://api.spotify.com/v1/artists/5L4vTbPKWxGWvnWLwEzuLl","id":"5L4vTbPKWxGWvnWLwEzuLl","name":"2square","type":"artist","uri":"spotify:artist:5L4vTbPKWxGWvnWLwEzuLl"}],"disc_number":1,"duration_ms":192500,"explicit":false,"external_ids":{"isrc":"FR06S0200647"},"external_urls":{"spotify":"https://open.spotify.com/track/7FHx5qvlbu5VeABLSGuLAX"},"href":"https://api.spotify.com/v1/tracks/7FHx5qvlbu5VeABLSGuLAX","id":"7FHx5qvlbu5VeABLSGuLAX","is_local":false,"is_playable":true,"name":"Breathe - 2square Remix","track_number":1,"type":"track","uri":"spotify:track:7FHx5qvlbu5VeABLSGuLAX"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Breathe%22+artist%3A%22T%C3%A9l%C3%A9popmusik%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Nightcall%22%20artist%3A%22Kavinsky%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"external_urls":{"spotify":"https://open.spotify.com/album/07nBld9enf1PyRysZAVSqJ"},"href":"https://api.spotify.com/v1/albums/07nBld9enf1PyRysZAVSqJ","id":"07nBld9enf1PyRysZAVSqJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d6d8c2eaa1f9031b62f7a3f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d6d8c2eaa1f9031b62f7a3f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d6d8c2eaa1f9031b62f7a3f7"}],"is_playable":true,"name":"Nightcall","release_date":"2010","release_date_precision":"year","total_tracks":7,"type":"album","uri":"spotify:album:07nBld9enf1PyRysZAVSqJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":258413,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/0U0ldCRmgCqhVvD6ksG63j"},"href":"https://api.spotify.com/v1/tracks/0U0ldCRmgCqhVvD6ksG63j","id":"0U0ldCRmgCqhVvD6ksG63j","is_local":false,"is_playable":true,"name":"Nightcall","track_number":1,"type":"track","uri":"spotify:track:0U0ldCRmgCqhVvD6ksG63j"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3QVolfxko2UyCOtexhVTli"},"href":"https://api.spotify.com/v1/artists/3QVolfxko2UyCOtexhVTli","id":"3QVolfxko2UyCOtexhVTli","name":"Ang\u00e8le","type":"artist","uri":"spotify:artist:3QVolfxko2UyCOtexhVTli"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1xU878Z1QtBldR7ru9owdU"},"href":"https://api.spotify.com/v1/artists/1xU878Z1QtBldR7ru9owdU","id":"1xU878Z1QtBldR7ru9owdU","name":"Phoenix","type":"artist","uri":"spotify:artist:1xU878Z1QtBldR7ru9owdU"}],"external_urls":{"spotify":"https://open.spotify.com/album/05OLq8nG4L5WYZXTfXVYM7"},"href":"https://api.spotify.com/v1/albums/05OLq8nG4L5WYZXTfXVYM7","id":"05OLq8nG4L5WYZXTfXVYM7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27382e856e42426e69b8bb43461"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0282e856e42426e69b8bb43461"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485182e856e42426e69b8bb43461"}],"is_playable":true,"name":"Nightcall","release_date":"2024-09-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:05OLq8nG4L5WYZXTfXVYM7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3QVolfxko2UyCOtexhVTli"},"href":"https://api.spotify.com/v1/artists/3QVolfxko2UyCOtexhVTli","id":"3QVolfxko2UyCOtexhVTli","name":"Ang\u00e8le","type":"artist","uri":"spotify:artist:3QVolfxko2UyCOtexhVTli"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1xU878Z1QtBldR7ru9owdU"},"href":"https://api.spotify.com/v1/artists/1xU878Z1QtBldR7ru9owdU","id":"1xU878Z1QtBldR7ru9owdU","name":"Phoenix","type":"artist","uri":"spotify:artist:1xU878Z1QtBldR7ru9owdU"}],"disc_number":1,"duration_ms":179306,"explicit":false,"external_ids":{"isrc":"FR9W12445550"},"external_urls":{"spotify":"https://open.spotify.com/track/2KejCKgm7l3uefW9cFt8cH"},"href":"https://api.spotify.com/v1/tracks/2KejCKgm7l3uefW9cFt8cH","id":"2KejCKgm7l3uefW9cFt8cH","is_local":false,"is_playable":true,"name":"Nightcall","track_number":1,"type":"track","uri":"spotify:track:2KejCKgm7l3uefW9cFt8cH"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"external_urls":{"spotify":"https://open.spotify.com/album/3bRM4GQgoFjBRRzhp87Ugb"},"href":"https://api.spotify.com/v1/albums/3bRM4GQgoFjBRRzhp87Ugb","id":"3bRM4GQgoFjBRRzhp87Ugb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c08bca073e89ae32c68ffaa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c08bca073e89ae32c68ffaa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c08bca073e89ae32c68ffaa"}],"is_playable":true,"name":"OutRun","release_date":"2013-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3bRM4GQgoFjBRRzhp87Ugb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/73bDvrmSBh2fr53tLDH9oA"},"href":"https://api.spotify.com/v1/tracks/73bDvrmSBh2fr53tLDH9oA","id":"73bDvrmSBh2fr53tLDH9oA","is_local":false,"is_playable":true,"name":"Nightcall","track_number":8,"type":"track","uri":"spotify:track:73bDvrmSBh2fr53tLDH9oA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"external_urls":{"spotify":"https://open.spotify.com/album/07nBld9enf1PyRysZAVSqJ"},"href":"https://api.spotify.com/v1/albums/07nBld9enf1PyRysZAVSqJ","id":"07nBld9enf1PyRysZAVSqJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d6d8c2eaa1f9031b62f7a3f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d6d8c2eaa1f9031b62f7a3f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d6d8c2eaa1f9031b62f7a3f7"}],"is_playable":true,"name":"Nightcall","release_date":"2010","release_date_precision":"year","total_tracks":7,"type":"album","uri":"spotify:album:07nBld9enf1PyRysZAVSqJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2KYEpWi4Ii0ZfOjXsZfTBg"},"href":"https://api.spotify.com/v1/artists/2KYEpWi4Ii0ZfOjXsZfTBg","id":"2KYEpWi4Ii0ZfOjXsZfTBg","name":"Dustin N'Guyen","type":"artist","uri":"spotify:artist:2KYEpWi4Ii0ZfOjXsZfTBg"}],"disc_number":1,"duration_ms":212946,"explicit":false,"external_ids":{"isrc":"FRS710900430"},"external_urls":{"spotify":"https://open.spotify.com/track/3uEwbhvBSlE3pWT9yQfC1P"},"href":"https://api.spotify.com/v1/tracks/3uEwbhvBSlE3pWT9yQfC1P","id":"3uEwbhvBSlE3pWT9yQfC1P","is_local":false,"is_playable":true,"name":"Nightcall - Dustin N'Guyen Remix","track_number":3,"type":"track","uri":"spotify:track:3uEwbhvBSlE3pWT9yQfC1P"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"external_urls":{"spotify":"https://open.spotify.com/album/07nBld9enf1PyRysZAVSqJ"},"href":"https://api.spotify.com/v1/albums/07nBld9enf1PyRysZAVSqJ","id":"07nBld9enf1PyRysZAVSqJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d6d8c2eaa1f9031b62f7a3f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d6d8c2eaa1f9031b62f7a3f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d6d8c2eaa1f9031b62f7a3f7"}],"is_playable":true,"name":"Nightcall","release_date":"2010","release_date_precision":"year","total_tracks":7,"type":"album","uri":"spotify:album:07nBld9enf1PyRysZAVSqJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0iui2Be5CP8EWxvHYsVspL"},"href":"https://api.spotify.com/v1/artists/0iui2Be5CP8EWxvHYsVspL","id":"0iui2Be5CP8EWxvHYsVspL","name":"Breakbot","type":"artist","uri":"spotify:artist:0iui2Be5CP8EWxvHYsVspL"}],"disc_number":1,"duration_ms":219813,"explicit":false,"external_ids":{"isrc":"FRS711000010"},"external_urls":{"spotify":"https://open.spotify.com/track/199fvGLqoH23blptlIIz86"},"href":"https://api.spotify.com/v1/tracks/199fvGLqoH23blptlIIz86","id":"199fvGLqoH23blptlIIz86","is_local":false,"is_playable":true,"name":"Nightcall - Breakbot Remix","track_number":5,"type":"track","uri":"spotify:track:199fvGLqoH23blptlIIz86"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/54dvmr3KosEXxtqxtC0lVB"},"href":"https://api.spotify.com/v1/albums/54dvmr3KosEXxtqxtC0lVB","id":"54dvmr3KosEXxtqxtC0lVB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ed38e147088a56baa38ab58f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ed38e147088a56baa38ab58f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ed38e147088a56baa38ab58f"}],"is_playable":true,"name":"spooky indie","release_date":"2024-10-08","release_date_precision":"day","total_tracks":52,"type":"album","uri":"spotify:album:54dvmr3KosEXxtqxtC0lVB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/4GoyswkdK97SvkWpzisFBl"},"href":"https://api.spotify.com/v1/tracks/4GoyswkdK97SvkWpzisFBl","id":"4GoyswkdK97SvkWpzisFBl","is_local":false,"is_playable":true,"name":"Nightcall","track_number":15,"type":"track","uri":"spotify:track:4GoyswkdK97SvkWpzisFBl"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/44oeaPEuYMbx6a9UylFLrO"},"href":"https://api.spotify.com/v1/albums/44oeaPEuYMbx6a9UylFLrO","id":"44oeaPEuYMbx6a9UylFLrO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aaeb8bb7de68394c7d91ead2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aaeb8bb7de68394c7d91ead2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aaeb8bb7de68394c7d91ead2"}],"is_playable":true,"name":"Synth Pop Hits","release_date":"2020-04-24","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:44oeaPEuYMbx6a9UylFLrO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/2imyFkTaXdHFjPTv3RhtOb"},"href":"https://api.spotify.com/v1/tracks/2imyFkTaXdHFjPTv3RhtOb","id":"2imyFkTaXdHFjPTv3RhtOb","is_local":false,"is_playable":true,"name":"Nightcall","track_number":2,"type":"track","uri":"spotify:track:2imyFkTaXdHFjPTv3RhtOb"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7qoHhoqGRrHALh4Pk260J6"},"href":"https://api.spotify.com/v1/albums/7qoHhoqGRrHALh4Pk260J6","id":"7qoHhoqGRrHALh4Pk260J6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ca3efb134f8d05e9c2170214"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ca3efb134f8d05e9c2170214"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ca3efb134f8d05e9c2170214"}],"is_playable":true,"name":"2010s Halloween","release_date":"2021-10-29","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:7qoHhoqGRrHALh4Pk260J6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/3hpmpbiQSj7vQKVcGLX65b"},"href":"https://api.spotify.com/v1/tracks/3hpmpbiQSj7vQKVcGLX65b","id":"3hpmpbiQSj7vQKVcGLX65b","is_local":false,"is_playable":true,"name":"Nightcall","track_number":3,"type":"track","uri":"spotify:track:3hpmpbiQSj7vQKVcGLX65b"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Dg7qZZNaOORH2J3RpOzDk"},"href":"https://api.spotify.com/v1/albums/5Dg7qZZNaOORH2J3RpOzDk","id":"5Dg7qZZNaOORH2J3RpOzDk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734bc71e2cb781f0d343c77b93"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024bc71e2cb781f0d343c77b93"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514bc71e2cb781f0d343c77b93"}],"is_playable":true,"name":"Trends Anos 2000","release_date":"2024-09-29","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:5Dg7qZZNaOORH2J3RpOzDk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/2mJpPWhzt0a9Q1gxiObDZE"},"href":"https://api.spotify.com/v1/tracks/2mJpPWhzt0a9Q1gxiObDZE","id":"2mJpPWhzt0a9Q1gxiObDZE","is_local":false,"is_playable":true,"name":"Nightcall","track_number":2,"type":"track","uri":"spotify:track:2mJpPWhzt0a9Q1gxiObDZE"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4hrtczCTsfNDHFwVOVYuxz"},"href":"https://api.spotify.com/v1/albums/4hrtczCTsfNDHFwVOVYuxz","id":"4hrtczCTsfNDHFwVOVYuxz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739e769935cd403a2f02f89371"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029e769935cd403a2f02f89371"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519e769935cd403a2f02f89371"}],"is_playable":true,"name":"Halloween Songs","release_date":"2019-09-27","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:4hrtczCTsfNDHFwVOVYuxz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/1X5NQ4tXvCR5lq4SMre3gp"},"href":"https://api.spotify.com/v1/tracks/1X5NQ4tXvCR5lq4SMre3gp","id":"1X5NQ4tXvCR5lq4SMre3gp","is_local":false,"is_playable":true,"name":"Nightcall","track_number":5,"type":"track","uri":"spotify:track:1X5NQ4tXvCR5lq4SMre3gp"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Nightcall%22%20artist%3A%22Kavinsky%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"external_urls":{"spotify":"https://open.spotify.com/album/07nBld9enf1PyRysZAVSqJ"},"href":"https://api.spotify.com/v1/albums/07nBld9enf1PyRysZAVSqJ","id":"07nBld9enf1PyRysZAVSqJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d6d8c2eaa1f9031b62f7a3f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d6d8c2eaa1f9031b62f7a3f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d6d8c2eaa1f9031b62f7a3f7"}],"is_playable":true,"name":"Nightcall","release_date":"2010","release_date_precision":"year","total_tracks":7,"type":"album","uri":"spotify:album:07nBld9enf1PyRysZAVSqJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":258413,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/0U0ldCRmgCqhVvD6ksG63j"},"href":"https://api.spotify.com/v1/tracks/0U0ldCRmgCqhVvD6ksG63j","id":"0U0ldCRmgCqhVvD6ksG63j","is_local":false,"is_playable":true,"name":"Nightcall","track_number":1,"type":"track","uri":"spotify:track:0U0ldCRmgCqhVvD6ksG63j"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3QVolfxko2UyCOtexhVTli"},"href":"https://api.spotify.com/v1/artists/3QVolfxko2UyCOtexhVTli","id":"3QVolfxko2UyCOtexhVTli","name":"Ang\u00e8le","type":"artist","uri":"spotify:artist:3QVolfxko2UyCOtexhVTli"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1xU878Z1QtBldR7ru9owdU"},"href":"https://api.spotify.com/v1/artists/1xU878Z1QtBldR7ru9owdU","id":"1xU878Z1QtBldR7ru9owdU","name":"Phoenix","type":"artist","uri":"spotify:artist:1xU878Z1QtBldR7ru9owdU"}],"external_urls":{"spotify":"https://open.spotify.com/album/05OLq8nG4L5WYZXTfXVYM7"},"href":"https://api.spotify.com/v1/albums/05OLq8nG4L5WYZXTfXVYM7","id":"05OLq8nG4L5WYZXTfXVYM7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27382e856e42426e69b8bb43461"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0282e856e42426e69b8bb43461"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485182e856e42426e69b8bb43461"}],"is_playable":true,"name":"Nightcall","release_date":"2024-09-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:05OLq8nG4L5WYZXTfXVYM7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3QVolfxko2UyCOtexhVTli"},"href":"https://api.spotify.com/v1/artists/3QVolfxko2UyCOtexhVTli","id":"3QVolfxko2UyCOtexhVTli","name":"Ang\u00e8le","type":"artist","uri":"spotify:artist:3QVolfxko2UyCOtexhVTli"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1xU878Z1QtBldR7ru9owdU"},"href":"https://api.spotify.com/v1/artists/1xU878Z1QtBldR7ru9owdU","id":"1xU878Z1QtBldR7ru9owdU","name":"Phoenix","type":"artist","uri":"spotify:artist:1xU878Z1QtBldR7ru9owdU"}],"disc_number":1,"duration_ms":179306,"explicit":false,"external_ids":{"isrc":"FR9W12445550"},"external_urls":{"spotify":"https://open.spotify.com/track/2KejCKgm7l3uefW9cFt8cH"},"href":"https://api.spotify.com/v1/tracks/2KejCKgm7l3uefW9cFt8cH","id":"2KejCKgm7l3uefW9cFt8cH","is_local":false,"is_playable":true,"name":"Nightcall","track_number":1,"type":"track","uri":"spotify:track:2KejCKgm7l3uefW9cFt8cH"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"external_urls":{"spotify":"https://open.spotify.com/album/3bRM4GQgoFjBRRzhp87Ugb"},"href":"https://api.spotify.com/v1/albums/3bRM4GQgoFjBRRzhp87Ugb","id":"3bRM4GQgoFjBRRzhp87Ugb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c08bca073e89ae32c68ffaa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c08bca073e89ae32c68ffaa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c08bca073e89ae32c68ffaa"}],"is_playable":true,"name":"OutRun","release_date":"2013-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3bRM4GQgoFjBRRzhp87Ugb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/73bDvrmSBh2fr53tLDH9oA"},"href":"https://api.spotify.com/v1/tracks/73bDvrmSBh2fr53tLDH9oA","id":"73bDvrmSBh2fr53tLDH9oA","is_local":false,"is_playable":true,"name":"Nightcall","track_number":8,"type":"track","uri":"spotify:track:73bDvrmSBh2fr53tLDH9oA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"external_urls":{"spotify":"https://open.spotify.com/album/07nBld9enf1PyRysZAVSqJ"},"href":"https://api.spotify.com/v1/albums/07nBld9enf1PyRysZAVSqJ","id":"07nBld9enf1PyRysZAVSqJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d6d8c2eaa1f9031b62f7a3f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d6d8c2eaa1f9031b62f7a3f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d6d8c2eaa1f9031b62f7a3f7"}],"is_playable":true,"name":"Nightcall","release_date":"2010","release_date_precision":"year","total_tracks":7,"type":"album","uri":"spotify:album:07nBld9enf1PyRysZAVSqJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2KYEpWi4Ii0ZfOjXsZfTBg"},"href":"https://api.spotify.com/v1/artists/2KYEpWi4Ii0ZfOjXsZfTBg","id":"2KYEpWi4Ii0ZfOjXsZfTBg","name":"Dustin N'Guyen","type":"artist","uri":"spotify:artist:2KYEpWi4Ii0ZfOjXsZfTBg"}],"disc_number":1,"duration_ms":212946,"explicit":false,"external_ids":{"isrc":"FRS710900430"},"external_urls":{"spotify":"https://open.spotify.com/track/3uEwbhvBSlE3pWT9yQfC1P"},"href":"https://api.spotify.com/v1/tracks/3uEwbhvBSlE3pWT9yQfC1P","id":"3uEwbhvBSlE3pWT9yQfC1P","is_local":false,"is_playable":true,"name":"Nightcall - Dustin N'Guyen Remix","track_number":3,"type":"track","uri":"spotify:track:3uEwbhvBSlE3pWT9yQfC1P"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"external_urls":{"spotify":"https://open.spotify.com/album/07nBld9enf1PyRysZAVSqJ"},"href":"https://api.spotify.com/v1/albums/07nBld9enf1PyRysZAVSqJ","id":"07nBld9enf1PyRysZAVSqJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d6d8c2eaa1f9031b62f7a3f7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d6d8c2eaa1f9031b62f7a3f7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d6d8c2eaa1f9031b62f7a3f7"}],"is_playable":true,"name":"Nightcall","release_date":"2010","release_date_precision":"year","total_tracks":7,"type":"album","uri":"spotify:album:07nBld9enf1PyRysZAVSqJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0iui2Be5CP8EWxvHYsVspL"},"href":"https://api.spotify.com/v1/artists/0iui2Be5CP8EWxvHYsVspL","id":"0iui2Be5CP8EWxvHYsVspL","name":"Breakbot","type":"artist","uri":"spotify:artist:0iui2Be5CP8EWxvHYsVspL"}],"disc_number":1,"duration_ms":219813,"explicit":false,"external_ids":{"isrc":"FRS711000010"},"external_urls":{"spotify":"https://open.spotify.com/track/199fvGLqoH23blptlIIz86"},"href":"https://api.spotify.com/v1/tracks/199fvGLqoH23blptlIIz86","id":"199fvGLqoH23blptlIIz86","is_local":false,"is_playable":true,"name":"Nightcall - Breakbot Remix","track_number":5,"type":"track","uri":"spotify:track:199fvGLqoH23blptlIIz86"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/54dvmr3KosEXxtqxtC0lVB"},"href":"https://api.spotify.com/v1/albums/54dvmr3KosEXxtqxtC0lVB","id":"54dvmr3KosEXxtqxtC0lVB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ed38e147088a56baa38ab58f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ed38e147088a56baa38ab58f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ed38e147088a56baa38ab58f"}],"is_playable":true,"name":"spooky indie","release_date":"2024-10-08","release_date_precision":"day","total_tracks":52,"type":"album","uri":"spotify:album:54dvmr3KosEXxtqxtC0lVB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/4GoyswkdK97SvkWpzisFBl"},"href":"https://api.spotify.com/v1/tracks/4GoyswkdK97SvkWpzisFBl","id":"4GoyswkdK97SvkWpzisFBl","is_local":false,"is_playable":true,"name":"Nightcall","track_number":15,"type":"track","uri":"spotify:track:4GoyswkdK97SvkWpzisFBl"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/44oeaPEuYMbx6a9UylFLrO"},"href":"https://api.spotify.com/v1/albums/44oeaPEuYMbx6a9UylFLrO","id":"44oeaPEuYMbx6a9UylFLrO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aaeb8bb7de68394c7d91ead2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aaeb8bb7de68394c7d91ead2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aaeb8bb7de68394c7d91ead2"}],"is_playable":true,"name":"Synth Pop Hits","release_date":"2020-04-24","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:44oeaPEuYMbx6a9UylFLrO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/2imyFkTaXdHFjPTv3RhtOb"},"href":"https://api.spotify.com/v1/tracks/2imyFkTaXdHFjPTv3RhtOb","id":"2imyFkTaXdHFjPTv3RhtOb","is_local":false,"is_playable":true,"name":"Nightcall","track_number":2,"type":"track","uri":"spotify:track:2imyFkTaXdHFjPTv3RhtOb"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7qoHhoqGRrHALh4Pk260J6"},"href":"https://api.spotify.com/v1/albums/7qoHhoqGRrHALh4Pk260J6","id":"7qoHhoqGRrHALh4Pk260J6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ca3efb134f8d05e9c2170214"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ca3efb134f8d05e9c2170214"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ca3efb134f8d05e9c2170214"}],"is_playable":true,"name":"2010s Halloween","release_date":"2021-10-29","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:7qoHhoqGRrHALh4Pk260J6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/3hpmpbiQSj7vQKVcGLX65b"},"href":"https://api.spotify.com/v1/tracks/3hpmpbiQSj7vQKVcGLX65b","id":"3hpmpbiQSj7vQKVcGLX65b","is_local":false,"is_playable":true,"name":"Nightcall","track_number":3,"type":"track","uri":"spotify:track:3hpmpbiQSj7vQKVcGLX65b"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Dg7qZZNaOORH2J3RpOzDk"},"href":"https://api.spotify.com/v1/albums/5Dg7qZZNaOORH2J3RpOzDk","id":"5Dg7qZZNaOORH2J3RpOzDk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734bc71e2cb781f0d343c77b93"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024bc71e2cb781f0d343c77b93"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514bc71e2cb781f0d343c77b93"}],"is_playable":true,"name":"Trends Anos 2000","release_date":"2024-09-29","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:5Dg7qZZNaOORH2J3RpOzDk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/2mJpPWhzt0a9Q1gxiObDZE"},"href":"https://api.spotify.com/v1/tracks/2mJpPWhzt0a9Q1gxiObDZE","id":"2mJpPWhzt0a9Q1gxiObDZE","is_local":false,"is_playable":true,"name":"Nightcall","track_number":2,"type":"track","uri":"spotify:track:2mJpPWhzt0a9Q1gxiObDZE"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4hrtczCTsfNDHFwVOVYuxz"},"href":"https://api.spotify.com/v1/albums/4hrtczCTsfNDHFwVOVYuxz","id":"4hrtczCTsfNDHFwVOVYuxz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739e769935cd403a2f02f89371"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029e769935cd403a2f02f89371"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519e769935cd403a2f02f89371"}],"is_playable":true,"name":"Halloween Songs","release_date":"2019-09-27","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:4hrtczCTsfNDHFwVOVYuxz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0UF7XLthtbSF2Eur7559oV"},"href":"https://api.spotify.com/v1/artists/0UF7XLthtbSF2Eur7559oV","id":"0UF7XLthtbSF2Eur7559oV","name":"Kavinsky","type":"artist","uri":"spotify:artist:0UF7XLthtbSF2Eur7559oV"}],"disc_number":1,"duration_ms":257320,"explicit":false,"external_ids":{"isrc":"FRS710900410"},"external_urls":{"spotify":"https://open.spotify.com/track/1X5NQ4tXvCR5lq4SMre3gp"},"href":"https://api.spotify.com/v1/tracks/1X5NQ4tXvCR5lq4SMre3gp","id":"1X5NQ4tXvCR5lq4SMre3gp","is_local":false,"is_playable":true,"name":"Nightcall","track_number":5,"type":"track","uri":"spotify:track:1X5NQ4tXvCR5lq4SMre3gp"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Nightcall%22+artist%3A%22Kavinsky%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Porcelain%22%20artist%3A%22Moby%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/4KZWx8zo5ym89aopr0dBIb"},"href":"https://api.spotify.com/v1/albums/4KZWx8zo5ym89aopr0dBIb","id":"4KZWx8zo5ym89aopr0dBIb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f675ddc7a8c113362f983f8b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f675ddc7a8c113362f983f8b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f675ddc7a8c113362f983f8b"}],"is_playable":true,"name":"Play","release_date":"1999-05-17","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:4KZWx8zo5ym89aopr0dBIb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"disc_number":1,"duration_ms":241160,"explicit":false,"external_ids":{"isrc":"GBAJH9900036"},"external_urls":{"spotify":"https://open.spotify.com/track/6EXi6ZqTITKGtVBKqbphjL"},"href":"https://api.spotify.com/v1/tracks/6EXi6ZqTITKGtVBKqbphjL","id":"6EXi6ZqTITKGtVBKqbphjL","is_local":false,"is_playable":true,"name":"Porcelain","track_number":3,"type":"track","uri":"spotify:track:6EXi6ZqTITKGtVBKqbphjL"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/02wbvDMkZ7bGAfaAvV87qi"},"href":"https://api.spotify.com/v1/albums/02wbvDMkZ7bGAfaAvV87qi","id":"02wbvDMkZ7bGAfaAvV87qi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731cd5421dcbe7beaa193be5a8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021cd5421dcbe7beaa193be5a8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511cd5421dcbe7beaa193be5a8"}],"is_playable":true,"name":"Porcelain (The Remixes)","release_date":"2016-08-26","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:02wbvDMkZ7bGAfaAvV87qi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1rSGNXhhYuWoq9BEz5DZGO"},"href":"https://api.spotify.com/v1/artists/1rSGNXhhYuWoq9BEz5DZGO","id":"1rSGNXhhYuWoq9BEz5DZGO","name":"ARTY","type":"artist","uri":"spotify:artist:1rSGNXhhYuWoq9BEz5DZGO"}],"disc_number":1,"duration_ms":211224,"explicit":false,"external_ids":{"isrc":"GBEWA1601001"},"external_urls":{"spotify":"https://open.spotify.com/track/3pUi08Z4eoQdPWfonAXHEn"},"href":"https://api.spotify.com/v1/tracks/3pUi08Z4eoQdPWfonAXHEn","id":"3pUi08Z4eoQdPWfonAXHEn","is_local":false,"is_playable":true,"name":"Porcelain - Arty Remix","track_number":2,"type":"track","uri":"spotify:track:3pUi08Z4eoQdPWfonAXHEn"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/2BqKtTxRbx8jRfLoqZbgro"},"href":"https://api.spotify.com/v1/albums/2BqKtTxRbx8jRfLoqZbgro","id":"2BqKtTxRbx8jRfLoqZbgro","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d8f57bf9b5f108f2f17d2300"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d8f57bf9b5f108f2f17d2300"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d8f57bf9b5f108f2f17d2300"}],"is_playable":true,"name":"Porcelain (Pola & Bryson Remix)","release_date":"2017-04-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2BqKtTxRbx8jRfLoqZbgro"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/79PzyYqAyunWsVH4tY4vpr"},"href":"https://api.spotify.com/v1/artists/79PzyYqAyunWsVH4tY4vpr","id":"79PzyYqAyunWsVH4tY4vpr","name":"Pola & Bryson","type":"artist","uri":"spotify:artist:79PzyYqAyunWsVH4tY4vpr"}],"disc_number":1,"duration_ms":327096,"explicit":false,"external_ids":{"isrc":"GB3AD1700025"},"external_urls":{"spotify":"https://open.spotify.com/track/6Yx3h0pLrblZu1AXQsHtBE"},"href":"https://api.spotify.com/v1/tracks/6Yx3h0pLrblZu1AXQsHtBE","id":"6Yx3h0pLrblZu1AXQsHtBE","is_local":false,"is_playable":true,"name":"Porcelain - Pola & Bryson Remix","track_number":1,"type":"track","uri":"spotify:track:6Yx3h0pLrblZu1AXQsHtBE"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/79ibiw2nOOcNiCt0XdkwLI"},"href":"https://api.spotify.com/v1/albums/79ibiw2nOOcNiCt0XdkwLI","id":"79ibiw2nOOcNiCt0XdkwLI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ebe8aa749bd85d8b839b8051"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ebe8aa749bd85d8b839b8051"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ebe8aa749bd85d8b839b8051"}],"is_playable":true,"name":"Porcelain","release_date":"2000-04-25","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:79ibiw2nOOcNiCt0XdkwLI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"disc_number":1,"duration_ms":211706,"explicit":false,"external_ids":{"isrc":"GBAJH0000143"},"external_urls":{"spotify":"https://open.spotify.com/track/4VVoo5VZH7SduVNYkxXiW5"},"href":"https://api.spotify.com/v1/tracks/4VVoo5VZH7SduVNYkxXiW5","id":"4VVoo5VZH7SduVNYkxXiW5","is_local":false,"is_playable":true,"name":"Porcelain - Single Version","track_number":1,"type":"track","uri":"spotify:track:4VVoo5VZH7SduVNYkxXiW5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/6vcm3ltupPkA4zt82auiKh"},"href":"https://api.spotify.com/v1/albums/6vcm3ltupPkA4zt82auiKh","id":"6vcm3ltupPkA4zt82auiKh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738211d82646eba36b26907b9a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028211d82646eba36b26907b9a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518211d82646eba36b26907b9a"}],"is_playable":true,"name":"Play: The Complete Recordings","release_date":"1999-05-17","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:6vcm3ltupPkA4zt82auiKh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"disc_number":1,"duration_ms":241160,"explicit":false,"external_ids":{"isrc":"GBAJH9900036"},"external_urls":{"spotify":"https://open.spotify.com/track/569ku6CN983WFC42qqZl3S"},"href":"https://api.spotify.com/v1/tracks/569ku6CN983WFC42qqZl3S","id":"569ku6CN983WFC42qqZl3S","is_local":false,"is_playable":true,"name":"Porcelain","track_number":3,"type":"track","uri":"spotify:track:569ku6CN983WFC42qqZl3S"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1kbFHN14lmtf03thEX1vdk"},"href":"https://api.spotify.com/v1/albums/1kbFHN14lmtf03thEX1vdk","id":"1kbFHN14lmtf03thEX1vdk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730424c99289f0871cea032aa1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020424c99289f0871cea032aa1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510424c99289f0871cea032aa1"}],"is_playable":true,"name":"Go - The Very Best of Moby (Deluxe)","release_date":"2006-10-24","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:1kbFHN14lmtf03thEX1vdk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"disc_number":1,"duration_ms":210533,"explicit":false,"external_ids":{"isrc":"GBAJH0602032"},"external_urls":{"spotify":"https://open.spotify.com/track/2XjAm8Qhn8elktHFLMUykm"},"href":"https://api.spotify.com/v1/tracks/2XjAm8Qhn8elktHFLMUykm","id":"2XjAm8Qhn8elktHFLMUykm","is_local":false,"is_playable":true,"name":"Porcelain - 2006 Remaster","track_number":3,"type":"track","uri":"spotify:track:2XjAm8Qhn8elktHFLMUykm"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/02wbvDMkZ7bGAfaAvV87qi"},"href":"https://api.spotify.com/v1/albums/02wbvDMkZ7bGAfaAvV87qi","id":"02wbvDMkZ7bGAfaAvV87qi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731cd5421dcbe7beaa193be5a8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021cd5421dcbe7beaa193be5a8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511cd5421dcbe7beaa193be5a8"}],"is_playable":true,"name":"Porcelain (The Remixes)","release_date":"2016-08-26","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:02wbvDMkZ7bGAfaAvV87qi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/10gzBoINW3cLJfZUka8Zoe"},"href":"https://api.spotify.com/v1/artists/10gzBoINW3cLJfZUka8Zoe","id":"10gzBoINW3cLJfZUka8Zoe","name":"Above & Beyond","type":"artist","uri":"spotify:artist:10gzBoINW3cLJfZUka8Zoe"}],"disc_number":1,"duration_ms":296250,"explicit":false,"external_ids":{"isrc":"GBEWA1601002"},"external_urls":{"spotify":"https://open.spotify.com/track/4XUsTqbmaXJfxO76cIQaja"},"href":"https://api.spotify.com/v1/tracks/4XUsTqbmaXJfxO76cIQaja","id":"4XUsTqbmaXJfxO76cIQaja","is_local":false,"is_playable":true,"name":"Porcelain - Above & Beyond Remix","track_number":1,"type":"track","uri":"spotify:track:4XUsTqbmaXJfxO76cIQaja"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/2fmzud8evWnDZ813M5ahIK"},"href":"https://api.spotify.com/v1/albums/2fmzud8evWnDZ813M5ahIK","id":"2fmzud8evWnDZ813M5ahIK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c0b28e9c666e8ddce63c8cbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c0b28e9c666e8ddce63c8cbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c0b28e9c666e8ddce63c8cbc"}],"is_playable":true,"name":"Go - The Very Best of Moby","release_date":"2006-10-24","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:2fmzud8evWnDZ813M5ahIK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"disc_number":1,"duration_ms":210533,"explicit":false,"external_ids":{"isrc":"GBAJH0602032"},"external_urls":{"spotify":"https://open.spotify.com/track/7Cquena2xvtDpraUJIIfFe"},"href":"https://api.spotify.com/v1/tracks/7Cquena2xvtDpraUJIIfFe","id":"7Cquena2xvtDpraUJIIfFe","is_local":false,"is_playable":true,"name":"Porcelain - 2006 Remaster","track_number":3,"type":"track","uri":"spotify:track:7Cquena2xvtDpraUJIIfFe"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/1bqeVjo54gj4BjjOH8dC97"},"href":"https://api.spotify.com/v1/albums/1bqeVjo54gj4BjjOH8dC97","id":"1bqeVjo54gj4BjjOH8dC97","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273be8d7ee42606954a9019558c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02be8d7ee42606954a9019558c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851be8d7ee42606954a9019558c"}],"is_playable":true,"name":"Reprise","release_date":"2021-05-28","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1bqeVjo54gj4BjjOH8dC97"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1MhtYlJvUqfd2EgHSQTGK4"},"href":"https://api.spotify.com/v1/artists/1MhtYlJvUqfd2EgHSQTGK4","id":"1MhtYlJvUqfd2EgHSQTGK4","name":"Jim James","type":"artist","uri":"spotify:artist:1MhtYlJvUqfd2EgHSQTGK4"}],"disc_number":1,"duration_ms":353878,"explicit":false,"external_ids":{"isrc":"GB3AD1900114"},"external_urls":{"spotify":"https://open.spotify.com/track/3sR3H4iuy9y1O8ETVFlemU"},"href":"https://api.spotify.com/v1/tracks/3sR3H4iuy9y1O8ETVFlemU","id":"3sR3H4iuy9y1O8ETVFlemU","is_local":false,"is_playable":true,"name":"Porcelain - Reprise Version","track_number":4,"type":"track","uri":"spotify:track:3sR3H4iuy9y1O8ETVFlemU"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"}],"external_urls":{"spotify":"https://open.spotify.com/album/4E74Wo8MbwFEJOfj4KsSNY"},"href":"https://api.spotify.com/v1/albums/4E74Wo8MbwFEJOfj4KsSNY","id":"4E74Wo8MbwFEJOfj4KsSNY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273157efe1cac5b03412398e214"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02157efe1cac5b03412398e214"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851157efe1cac5b03412398e214"}],"is_playable":true,"name":"Porcelain (Reprise Version)","release_date":"2021-03-26","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4E74Wo8MbwFEJOfj4KsSNY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3OsRAKCvk37zwYcnzRf5XF"},"href":"https://api.spotify.com/v1/artists/3OsRAKCvk37zwYcnzRf5XF","id":"3OsRAKCvk37zwYcnzRf5XF","name":"Moby","type":"artist","uri":"spotify:artist:3OsRAKCvk37zwYcnzRf5XF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1MhtYlJvUqfd2EgHSQTGK4"},"href":"https://api.spotify.com/v1/artists/1MhtYlJvUqfd2EgHSQTGK4","id":"1MhtYlJvUqfd2EgHSQTGK4","name":"Jim James","type":"artist","uri":"spotify:artist:1MhtYlJvUqfd2EgHSQTGK4"}],"disc_number":1,"duration_ms":353878,"explicit":false,"external_ids":{"isrc":"GB3AD1900114"},"external_urls":{"spotify":"https://open.spotify.com/track/1ulvmAnSa4Hbo9g3NroztA"},"href":"https://api.spotify.com/v1/tracks/1ulvmAnSa4Hbo9g3NroztA","id":"1ulvmAnSa4Hbo9g3NroztA","is_local":false,"is_playable":true,"name":"Porcelain - Reprise Version","track_number":1,"type":"track","uri":"spotify:track:1ulvmAnSa4Hbo9g3NroztA"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlBvcmNlbGFpbiUyMiUyMGFydGlzdCUzQSUyMk1vYnklMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNPc1JBS0N2azM3endZY256UmY1WEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsImlkIjoiM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsIm5hbWUiOiJNb2J5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNPc1JBS0N2azM3endZY256UmY1WEYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80S1pXeDh6bzV5bTg5YW9wcjBkQkliIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNEtaV3g4em81eW04OWFvcHIwZEJJYiIsImlkIjoiNEtaV3g4em81eW04OWFvcHIwZEJJYiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmNjc1ZGRjN2E4YzExMzM2MmY5ODNmOGIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjY3NWRkYzdhOGMxMTMzNjJmOTgzZjhiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmNjc1ZGRjN2E4YzExMzM2MmY5ODNmOGIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUGxheSIsInJlbGVhc2VfZGF0ZSI6IjE5OTktMDUtMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0S1pXeDh6bzV5bTg5YW9wcjBkQkliIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zT3NSQUtDdmszN3p3WWNuelJmNVhGIiwiaWQiOiIzT3NSQUtDdmszN3p3WWNuelJmNVhGIiwibmFtZSI6Ik1vYnkiLCJ0eQ==", + "cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MTE2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUpIOTkwMDAzNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNkVYaTZacVRJVEtHdFZCS3FicGhqTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZFWGk2WnFUSVRLR3RWQktxYnBoakwiLCJpZCI6IjZFWGk2WnFUSVRLR3RWQktxYnBoakwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUG9yY2VsYWluIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZFWGk2WnFUSVRLR3RWQktxYnBoakwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNPc1JBS0N2azM3endZY256UmY1WEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsImlkIjoiM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsIm5hbWUiOiJNb2J5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNPc1JBS0N2azM3endZY256UmY1WEYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wMndidkRNa1o3YkdBZmFBdlY4N3FpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDJ3YnZETWtaN2JHQWZhQXZWODdxaSIsImlkIjoiMDJ3YnZETWtaN2JHQWZhQXZWODdxaSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxY2Q1NDIxZGNiZTdiZWFhMTkzYmU1YTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWNkNTQyMWRjYmU3YmVhYTE5M2JlNWE4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExY2Q1NDIxZGNiZTdiZWFhMTkzYmU1YTgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUG9yY2VsYWluIChUaGUgUmVtaXhlcykiLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTA4LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsXw==", + "dHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjAyd2J2RE1rWjdiR0FmYUF2Vjg3cWkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zT3NSQUtDdmszN3p3WWNuelJmNVhGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNPc1JBS0N2azM3endZY256UmY1WEYiLCJpZCI6IjNPc1JBS0N2azM3endZY256UmY1WEYiLCJuYW1lIjoiTW9ieSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyU0dOWGhoWXVXb3E5QkV6NURaR08ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXJTR05YaGhZdVdvcTlCRXo1RFpHTyIsImlkIjoiMXJTR05YaGhZdVdvcTlCRXo1RFpHTyIsIm5hbWUiOiJBUlRZIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFyU0dOWGhoWXVXb3E5QkV6NURaR08ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjExMjI0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JFV0ExNjAxMDAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zcFVpMDhaNGVvUWRQV2ZvbkFYSEVuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM3BVaTA4WjRlb1FkUFdmb25BWEhFbiIsImlkIjoiM3BVaTA4WjRlb1FkUFdmb25BWEhFbiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQb3JjZWxhaW4gLSBBcnR5IFJlbWl4IiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNwVWkwOFo0ZW9RZFBXZm9uQVhIRW4ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNPc1JBS0N2azM3endZY256UmY1WEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsImlkIjoiM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsIm5hbWUiOiJNb2J5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNPc1JBS0N2azM3endZY256UmY1WEYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbQ==", + "L2FsYnVtLzJCcUt0VHhSYng4alJmTG9xWmJncm8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yQnFLdFR4UmJ4OGpSZkxvcVpiZ3JvIiwiaWQiOiIyQnFLdFR4UmJ4OGpSZkxvcVpiZ3JvIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2Q4ZjU3YmY5YjVmMTA4ZjJmMTdkMjMwMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkOGY1N2JmOWI1ZjEwOGYyZjE3ZDIzMDAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWQ4ZjU3YmY5YjVmMTA4ZjJmMTdkMjMwMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQb3JjZWxhaW4gKFBvbGEgJiBCcnlzb24gUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wNC0xOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MkJxS3RUeFJieDhqUmZMb3FaYmdybyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNPc1JBS0N2azM3endZY256UmY1WEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsImlkIjoiM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsIm5hbWUiOiJNb2J5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNPc1JBS0N2azM3endZY256UmY1WEYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzlQenlZcUF5dW5Xc1ZINHRZNHZwciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83OVB6eVlxQXl1bldzVkg0dFk0dnByIiwiaWQiOiI3OVB6eVlxQXl1bldzVkg0dFk0dnByIiwibmFtZSI6IlBvbGEgJiBCcnlzb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzlQenlZcUF5dW5Xc1ZINHRZNHZwciJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjcwOTYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQjNBRDE3MDAwMjUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZZeDNoMHBMcmJsWnUxQVhRc0h0QkUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZg==", + "eS5jb20vdjEvdHJhY2tzLzZZeDNoMHBMcmJsWnUxQVhRc0h0QkUiLCJpZCI6IjZZeDNoMHBMcmJsWnUxQVhRc0h0QkUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUG9yY2VsYWluIC0gUG9sYSAmIEJyeXNvbiBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2WXgzaDBwTHJibFp1MUFYUXNIdEJFIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zT3NSQUtDdmszN3p3WWNuelJmNVhGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNPc1JBS0N2azM3endZY256UmY1WEYiLCJpZCI6IjNPc1JBS0N2azM3endZY256UmY1WEYiLCJuYW1lIjoiTW9ieSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzlpYml3Mm5PT2NOaUN0MFhka3dMSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc5aWJpdzJuT09jTmlDdDBYZGt3TEkiLCJpZCI6Ijc5aWJpdzJuT09jTmlDdDBYZGt3TEkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZWJlOGFhNzQ5YmQ4NWQ4YjgzOWI4MDUxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmViZThhYTc0OWJkODVkOGI4MzliODA1MSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZWJlOGFhNzQ5YmQ4NWQ4YjgzOWI4MDUxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBvcmNlbGFpbiIsInJlbGVhc2VfZGF0ZSI6IjIwMDAtMDQtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3OWliaXcybk9PY05pQ3QwWGRrd0xJIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zT3NSQUtDdmszN3p3WWNuelJmNVhGIiwiaWQiOiIzT3NSQUtDdmszN3p3WQ==", + "Y256UmY1WEYiLCJuYW1lIjoiTW9ieSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxMTcwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUpIMDAwMDE0MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFZWb281VlpIN1NkdVZOWWt4WGlXNSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRWVm9vNVZaSDdTZHVWTllreFhpVzUiLCJpZCI6IjRWVm9vNVZaSDdTZHVWTllreFhpVzUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUG9yY2VsYWluIC0gU2luZ2xlIFZlcnNpb24iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFZWb281VlpIN1NkdVZOWWt4WGlXNSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zT3NSQUtDdmszN3p3WWNuelJmNVhGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNPc1JBS0N2azM3endZY256UmY1WEYiLCJpZCI6IjNPc1JBS0N2azM3endZY256UmY1WEYiLCJuYW1lIjoiTW9ieSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNnZjbTNsdHVwUGtBNHp0ODJhdWlLaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZ2Y20zbHR1cFBrQTR6dDgyYXVpS2giLCJpZCI6IjZ2Y20zbHR1cFBrQTR6dDgyYXVpS2giLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODIxMWQ4MjY0NmViYTM2YjI2OTA3YjlhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjgyMTFkODI2NDZlYmEzNmIyNjkwN2I5YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODIxMWQ4MjY0NmViYTM2YjI2OTA3YjlhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBsYXk6IFRoZSBDb21wbGV0ZSBSZWNvcmRpbmdzIiwicmVsZWFzZV9kYXRlIjoiMQ==", + "OTk5LTA1LTE3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NnZjbTNsdHVwUGtBNHp0ODJhdWlLaCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNPc1JBS0N2azM3endZY256UmY1WEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsImlkIjoiM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsIm5hbWUiOiJNb2J5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNPc1JBS0N2azM3endZY256UmY1WEYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQxMTYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSkg5OTAwMDM2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81NjlrdTZDTjk4M1dGQzQycXFabDNTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNTY5a3U2Q045ODNXRkM0MnFxWmwzUyIsImlkIjoiNTY5a3U2Q045ODNXRkM0MnFxWmwzUyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQb3JjZWxhaW4iLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NTY5a3U2Q045ODNXRkM0MnFxWmwzUyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zT3NSQUtDdmszN3p3WWNuelJmNVhGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNPc1JBS0N2azM3endZY256UmY1WEYiLCJpZCI6IjNPc1JBS0N2azM3endZY256UmY1WEYiLCJuYW1lIjoiTW9ieSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMWtiRkhOMTRsbXRmMDN0aEVYMXZkayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFrYkZITjE0bG10ZjAzdGhFWDF2ZGsiLCJpZCI6IjFrYkZITjE0bG10ZjAzdGhFWDF2ZGsiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDQyNGM5OQ==", + "Mjg5ZjA4NzFjZWEwMzJhYTEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDQyNGM5OTI4OWYwODcxY2VhMDMyYWExIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwNDI0Yzk5Mjg5ZjA4NzFjZWEwMzJhYTEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR28gLSBUaGUgVmVyeSBCZXN0IG9mIE1vYnkgKERlbHV4ZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTEwLTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MWtiRkhOMTRsbXRmMDN0aEVYMXZkayJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNPc1JBS0N2azM3endZY256UmY1WEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsImlkIjoiM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsIm5hbWUiOiJNb2J5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNPc1JBS0N2azM3endZY256UmY1WEYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjEwNTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSkgwNjAyMDMyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yWGpBbThRaG44ZWxrdEhGTE1VeWttIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMlhqQW04UWhuOGVsa3RIRkxNVXlrbSIsImlkIjoiMlhqQW04UWhuOGVsa3RIRkxNVXlrbSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQb3JjZWxhaW4gLSAyMDA2IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJYakFtOFFobjhlbGt0SEZMTVV5a20ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNPc1JBS0N2azM3endZY256UmY1WEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsImlkIjoiM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsIm5hbWUiOiJNb2J5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6Ig==", + "c3BvdGlmeTphcnRpc3Q6M09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzAyd2J2RE1rWjdiR0FmYUF2Vjg3cWkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wMndidkRNa1o3YkdBZmFBdlY4N3FpIiwiaWQiOiIwMndidkRNa1o3YkdBZmFBdlY4N3FpIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzFjZDU0MjFkY2JlN2JlYWExOTNiZTVhOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxY2Q1NDIxZGNiZTdiZWFhMTkzYmU1YTgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTFjZDU0MjFkY2JlN2JlYWExOTNiZTVhOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQb3JjZWxhaW4gKFRoZSBSZW1peGVzKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTYtMDgtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjAyd2J2RE1rWjdiR0FmYUF2Vjg3cWkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zT3NSQUtDdmszN3p3WWNuelJmNVhGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNPc1JBS0N2azM3endZY256UmY1WEYiLCJpZCI6IjNPc1JBS0N2azM3endZY256UmY1WEYiLCJuYW1lIjoiTW9ieSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzEwZ3pCb0lOVzNjTEpmWlVrYThab2UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTBnekJvSU5XM2NMSmZaVWthOFpvZSIsImlkIjoiMTBnekJvSU5XM2NMSmZaVWthOFpvZSIsIm5hbWUiOiJBYm92ZSAmIEJleW9uZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxMGd6Qm9JTlczY0xKZlpVa2E4Wm9lIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI5NjI1MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCRVdBMTYwMTAwMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZg==", + "eSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80WFVzVHFibWFYSmZ4Tzc2Y0lRYWphIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNFhVc1RxYm1hWEpmeE83NmNJUWFqYSIsImlkIjoiNFhVc1RxYm1hWEpmeE83NmNJUWFqYSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQb3JjZWxhaW4gLSBBYm92ZSAmIEJleW9uZCBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0WFVzVHFibWFYSmZ4Tzc2Y0lRYWphIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNPc1JBS0N2azM3endZY256UmY1WEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsImlkIjoiM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiIsIm5hbWUiOiJNb2J5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNPc1JBS0N2azM3endZY256UmY1WEYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yZm16dWQ4ZXZXbkRaODEzTTVhaElLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMmZtenVkOGV2V25EWjgxM001YWhJSyIsImlkIjoiMmZtenVkOGV2V25EWjgxM001YWhJSyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjMGIyOGU5YzY2NmU4ZGRjZTYzYzhjYmMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzBiMjhlOWM2NjZlOGRkY2U2M2M4Y2JjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjMGIyOGU5YzY2NmU4ZGRjZTYzYzhjYmMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR28gLSBUaGUgVmVyeSBCZXN0IG9mIE1vYnkiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTEwLTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MmZtenVkOGV2V25EWjgxM001YWhJSyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNPcw==", + "UkFLQ3ZrMzd6d1ljbnpSZjVYRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zT3NSQUtDdmszN3p3WWNuelJmNVhGIiwiaWQiOiIzT3NSQUtDdmszN3p3WWNuelJmNVhGIiwibmFtZSI6Ik1vYnkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTA1MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFKSDA2MDIwMzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdDcXVlbmEyeHZ0RHByYVVKSUlmRmUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83Q3F1ZW5hMnh2dERwcmFVSklJZkZlIiwiaWQiOiI3Q3F1ZW5hMnh2dERwcmFVSklJZkZlIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBvcmNlbGFpbiAtIDIwMDYgUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N0NxdWVuYTJ4dnREcHJhVUpJSWZGZSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zT3NSQUtDdmszN3p3WWNuelJmNVhGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNPc1JBS0N2azM3endZY256UmY1WEYiLCJpZCI6IjNPc1JBS0N2azM3endZY256UmY1WEYiLCJuYW1lIjoiTW9ieSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMWJxZVZqbzU0Z2o0QmpqT0g4ZEM5NyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFicWVWam81NGdqNEJqak9IOGRDOTciLCJpZCI6IjFicWVWam81NGdqNEJqak9IOGRDOTciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYmU4ZDdlZTQyNjA2OTU0YTkwMTk1NThjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJlOGQ3ZWU0MjYwNjk1NGE5MDE5NTU4YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMA==", + "MDQ4NTFiZThkN2VlNDI2MDY5NTRhOTAxOTU1OGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVwcmlzZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDUtMjgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxYnFlVmpvNTRnajRCampPSDhkQzk3In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zT3NSQUtDdmszN3p3WWNuelJmNVhGIiwiaWQiOiIzT3NSQUtDdmszN3p3WWNuelJmNVhGIiwibmFtZSI6Ik1vYnkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xTWh0WWxKdlVxZmQyRWdIU1FUR0s0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFNaHRZbEp2VXFmZDJFZ0hTUVRHSzQiLCJpZCI6IjFNaHRZbEp2VXFmZDJFZ0hTUVRHSzQiLCJuYW1lIjoiSmltIEphbWVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFNaHRZbEp2VXFmZDJFZ0hTUVRHSzQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzUzODc4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0IzQUQxOTAwMTE0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zc1IzSDRpdXk5eTFPOEVUVkZsZW1VIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM3NSM0g0aXV5OXkxTzhFVFZGbGVtVSIsImlkIjoiM3NSM0g0aXV5OXkxTzhFVFZGbGVtVSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQb3JjZWxhaW4gLSBSZXByaXNlIFZlcnNpb24iLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M3NSM0g0aXV5OXkxTzhFVFZGbGVtVSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM09zUkFLQ3ZrMzd6d1ljbnpSZjVYRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zT3NSQUtDdmszN3p3WWNuelJmNVhGIiwiaWQiOiIzT3NSQUtDdg==", + "azM3endZY256UmY1WEYiLCJuYW1lIjoiTW9ieSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNEU3NFdvOE1id0ZFSk9majRLc1NOWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRFNzRXbzhNYndGRUpPZmo0S3NTTlkiLCJpZCI6IjRFNzRXbzhNYndGRUpPZmo0S3NTTlkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMTU3ZWZlMWNhYzViMDM0MTIzOThlMjE0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE1N2VmZTFjYWM1YjAzNDEyMzk4ZTIxNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTU3ZWZlMWNhYzViMDM0MTIzOThlMjE0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBvcmNlbGFpbiAoUmVwcmlzZSBWZXJzaW9uKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDMtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRFNzRXbzhNYndGRUpPZmo0S3NTTlkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zT3NSQUtDdmszN3p3WWNuelJmNVhGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNPc1JBS0N2azM3endZY256UmY1WEYiLCJpZCI6IjNPc1JBS0N2azM3endZY256UmY1WEYiLCJuYW1lIjoiTW9ieSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozT3NSQUtDdmszN3p3WWNuelJmNVhGIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFNaHRZbEp2VXFmZDJFZ0hTUVRHSzQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMU1odFlsSnZVcWZkMkVnSFNRVEdLNCIsImlkIjoiMU1odFlsSnZVcWZkMkVnSFNRVEdLNCIsIm5hbWUiOiJKaW0gSmFtZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MU1odFlsSnZVcWZkMkVnSFNRVEdLNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozNTM4NzgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaQ==", + "ZHMiOnsiaXNyYyI6IkdCM0FEMTkwMDExNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXVsdm1BblNhNEhibzlnM05yb3p0QSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzF1bHZtQW5TYTRIYm85ZzNOcm96dEEiLCJpZCI6IjF1bHZtQW5TYTRIYm85ZzNOcm96dEEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUG9yY2VsYWluIC0gUmVwcmlzZSBWZXJzaW9uIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjF1bHZtQW5TYTRIYm85ZzNOcm96dEEifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Porcelain%22+artist%3A%22Moby%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1TaWxrJTIwQ2hpZmZvbiUyME1VTkElMkMlMjBQaG9lYmUlMjBCcmlkZ2VycyZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnhkUmIyR3lwSjdEcW5XQUkybUhHbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82eGRSYjJHeXBKN0RxbldBSTJtSEduIiwiaWQiOiI2eGRSYjJHeXBKN0RxbldBSTJtSEduIiwibmFtZSI6Ik1VTkEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnhkUmIyR3lwSjdEcW5XQUkybUhHbiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRuZFR2VHJOd2dVZlJ3NGcxUjJCNGwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80bmRUdlRyTndnVWZSdzRnMVIyQjRsIiwiaWQiOiI0bmRUdlRyTndnVWZSdzRnMVIyQjRsIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYg==", + "MjczYmI1YTNkZTk3ZDU0OGE2NDljZmFmZTY3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJiNWEzZGU5N2Q1NDhhNjQ5Y2ZhZmU2NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYmI1YTNkZTk3ZDU0OGE2NDljZmFmZTY3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1VTkEiLCJyZWxlYXNlX2RhdGUiOiIyMDIyLTA2LTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NG5kVHZUck53Z1VmUnc0ZzFSMkI0bCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ4ZFJiMkd5cEo3RHFuV0FJMm1IR24ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnhkUmIyR3lwSjdEcW5XQUkybUhHbiIsImlkIjoiNnhkUmIyR3lwSjdEcW5XQUkybUhHbiIsIm5hbWUiOiJNVU5BIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ4ZFJiMkd5cEo3RHFuV0FJMm1IR24ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xcjF1eG95MTlmek14dW50M09OQWtHIiwiaWQiOiIxcjF1eG95MTlmek14dW50M09OQWtHIiwibmFtZSI6IlBob2ViZSBCcmlkZ2VycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxcjF1eG95MTlmek14dW50M09OQWtHIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNjU4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSjVHMjEwMDUwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNUVDeGlLNFZpZ28xeVJSbUFvWmMxZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVFQ3hpSzRWaWdvMXlSUm1Bb1pjMWYiLCJpZCI6IjVFQ3hpSzRWaWdvMXlSUm1Bb1pjMWYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2lsayBDaGlmZm9uIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVFQ3hpSzRWaWdvMXlSUm1Bb1pjMWYifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Silk+Chiffon+MUNA%2C+Phoebe+Bridgers&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Weightless%22%20artist%3A%22Marconi%20Union%22&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=track%3A%22Weightless%22%20artist%3A%22Marconi%20Union%22&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0JsrUHqVkWkXt0vQeNiVkW"},"href":"https://api.spotify.com/v1/albums/0JsrUHqVkWkXt0vQeNiVkW","id":"0JsrUHqVkWkXt0vQeNiVkW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f399efa20097105e9db88560"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f399efa20097105e9db88560"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f399efa20097105e9db88560"}],"is_playable":true,"name":"The Ambient Zone Just Music Cafe Vol 4","release_date":"2012-10-29","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:0JsrUHqVkWkXt0vQeNiVkW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":480106,"explicit":false,"external_ids":{"isrc":"GBDDN1200510"},"external_urls":{"spotify":"https://open.spotify.com/track/6kkwzB6hXLIONkEk9JciA6"},"href":"https://api.spotify.com/v1/tracks/6kkwzB6hXLIONkEk9JciA6","id":"6kkwzB6hXLIONkEk9JciA6","is_local":false,"is_playable":true,"name":"Weightless","track_number":1,"type":"track","uri":"spotify:track:6kkwzB6hXLIONkEk9JciA6"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"external_urls":{"spotify":"https://open.spotify.com/album/3d8apQ32ZVRDPFtllVTKGR"},"href":"https://api.spotify.com/v1/albums/3d8apQ32ZVRDPFtllVTKGR","id":"3d8apQ32ZVRDPFtllVTKGR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732d60677a02438991cc6b25ea"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022d60677a02438991cc6b25ea"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512d60677a02438991cc6b25ea"}],"is_playable":true,"name":"Weightless (Ambient Transmission Vol. 2)","release_date":"2012","release_date_precision":"year","total_tracks":6,"type":"album","uri":"spotify:album:3d8apQ32ZVRDPFtllVTKGR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":486840,"explicit":false,"external_ids":{"isrc":"GBDDN1200510"},"external_urls":{"spotify":"https://open.spotify.com/track/2UZZtkoLOg7IHxeTAdPFvd"},"href":"https://api.spotify.com/v1/tracks/2UZZtkoLOg7IHxeTAdPFvd","id":"2UZZtkoLOg7IHxeTAdPFvd","is_local":false,"is_playable":true,"name":"Weightless Part 1","track_number":1,"type":"track","uri":"spotify:track:2UZZtkoLOg7IHxeTAdPFvd"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"external_urls":{"spotify":"https://open.spotify.com/album/3d8apQ32ZVRDPFtllVTKGR"},"href":"https://api.spotify.com/v1/albums/3d8apQ32ZVRDPFtllVTKGR","id":"3d8apQ32ZVRDPFtllVTKGR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732d60677a02438991cc6b25ea"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022d60677a02438991cc6b25ea"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512d60677a02438991cc6b25ea"}],"is_playable":true,"name":"Weightless (Ambient Transmission Vol. 2)","release_date":"2012","release_date_precision":"year","total_tracks":6,"type":"album","uri":"spotify:album:3d8apQ32ZVRDPFtllVTKGR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":432506,"explicit":false,"external_ids":{"isrc":"GBDDN1200511"},"external_urls":{"spotify":"https://open.spotify.com/track/7b2dMRCVDx7OGekIVjCrs1"},"href":"https://api.spotify.com/v1/tracks/7b2dMRCVDx7OGekIVjCrs1","id":"7b2dMRCVDx7OGekIVjCrs1","is_local":false,"is_playable":true,"name":"Weightless Part 2","track_number":2,"type":"track","uri":"spotify:track:7b2dMRCVDx7OGekIVjCrs1"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"external_urls":{"spotify":"https://open.spotify.com/album/3d8apQ32ZVRDPFtllVTKGR"},"href":"https://api.spotify.com/v1/albums/3d8apQ32ZVRDPFtllVTKGR","id":"3d8apQ32ZVRDPFtllVTKGR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732d60677a02438991cc6b25ea"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022d60677a02438991cc6b25ea"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512d60677a02438991cc6b25ea"}],"is_playable":true,"name":"Weightless (Ambient Transmission Vol. 2)","release_date":"2012","release_date_precision":"year","total_tracks":6,"type":"album","uri":"spotify:album:3d8apQ32ZVRDPFtllVTKGR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":458906,"explicit":false,"external_ids":{"isrc":"GBDDN1200512"},"external_urls":{"spotify":"https://open.spotify.com/track/70FfytITXJOz0s2xY3rOzz"},"href":"https://api.spotify.com/v1/tracks/70FfytITXJOz0s2xY3rOzz","id":"70FfytITXJOz0s2xY3rOzz","is_local":false,"is_playable":true,"name":"Weightless Part 3","track_number":3,"type":"track","uri":"spotify:track:70FfytITXJOz0s2xY3rOzz"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"external_urls":{"spotify":"https://open.spotify.com/album/3d8apQ32ZVRDPFtllVTKGR"},"href":"https://api.spotify.com/v1/albums/3d8apQ32ZVRDPFtllVTKGR","id":"3d8apQ32ZVRDPFtllVTKGR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732d60677a02438991cc6b25ea"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022d60677a02438991cc6b25ea"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512d60677a02438991cc6b25ea"}],"is_playable":true,"name":"Weightless (Ambient Transmission Vol. 2)","release_date":"2012","release_date_precision":"year","total_tracks":6,"type":"album","uri":"spotify:album:3d8apQ32ZVRDPFtllVTKGR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":440333,"explicit":false,"external_ids":{"isrc":"GBDDN1200514"},"external_urls":{"spotify":"https://open.spotify.com/track/56rN3Zh03LVnJ5kR1VTRJN"},"href":"https://api.spotify.com/v1/tracks/56rN3Zh03LVnJ5kR1VTRJN","id":"56rN3Zh03LVnJ5kR1VTRJN","is_local":false,"is_playable":true,"name":"Weightless Part 5","track_number":5,"type":"track","uri":"spotify:track:56rN3Zh03LVnJ5kR1VTRJN"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"external_urls":{"spotify":"https://open.spotify.com/album/3d8apQ32ZVRDPFtllVTKGR"},"href":"https://api.spotify.com/v1/albums/3d8apQ32ZVRDPFtllVTKGR","id":"3d8apQ32ZVRDPFtllVTKGR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732d60677a02438991cc6b25ea"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022d60677a02438991cc6b25ea"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512d60677a02438991cc6b25ea"}],"is_playable":true,"name":"Weightless (Ambient Transmission Vol. 2)","release_date":"2012","release_date_precision":"year","total_tracks":6,"type":"album","uri":"spotify:album:3d8apQ32ZVRDPFtllVTKGR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":437253,"explicit":false,"external_ids":{"isrc":"GBDDN1200513"},"external_urls":{"spotify":"https://open.spotify.com/track/2fTIn1AqeTGR6tSSfiS8zk"},"href":"https://api.spotify.com/v1/tracks/2fTIn1AqeTGR6tSSfiS8zk","id":"2fTIn1AqeTGR6tSSfiS8zk","is_local":false,"is_playable":true,"name":"Weightless Part 4","track_number":4,"type":"track","uri":"spotify:track:2fTIn1AqeTGR6tSSfiS8zk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"external_urls":{"spotify":"https://open.spotify.com/album/2Wum1zhdzrW1d6x028sfdQ"},"href":"https://api.spotify.com/v1/albums/2Wum1zhdzrW1d6x028sfdQ","id":"2Wum1zhdzrW1d6x028sfdQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736e9dfa53cb9744e943f8eb64"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026e9dfa53cb9744e943f8eb64"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516e9dfa53cb9744e943f8eb64"}],"is_playable":true,"name":"Weightless (253 Edit)","release_date":"2019-03-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2Wum1zhdzrW1d6x028sfdQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":253693,"explicit":false,"external_ids":{"isrc":"UKKTD1900054"},"external_urls":{"spotify":"https://open.spotify.com/track/5pwB7pB29fgFLJJsYxgECZ"},"href":"https://api.spotify.com/v1/tracks/5pwB7pB29fgFLJJsYxgECZ","id":"5pwB7pB29fgFLJJsYxgECZ","is_local":false,"is_playable":true,"name":"Weightless - 253 Edit","track_number":1,"type":"track","uri":"spotify:track:5pwB7pB29fgFLJJsYxgECZ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"external_urls":{"spotify":"https://open.spotify.com/album/3d8apQ32ZVRDPFtllVTKGR"},"href":"https://api.spotify.com/v1/albums/3d8apQ32ZVRDPFtllVTKGR","id":"3d8apQ32ZVRDPFtllVTKGR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732d60677a02438991cc6b25ea"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022d60677a02438991cc6b25ea"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512d60677a02438991cc6b25ea"}],"is_playable":true,"name":"Weightless (Ambient Transmission Vol. 2)","release_date":"2012","release_date_precision":"year","total_tracks":6,"type":"album","uri":"spotify:album:3d8apQ32ZVRDPFtllVTKGR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":310146,"explicit":false,"external_ids":{"isrc":"GBDDN1200515"},"external_urls":{"spotify":"https://open.spotify.com/track/1Mua0g96hUldJWj00GDsel"},"href":"https://api.spotify.com/v1/tracks/1Mua0g96hUldJWj00GDsel","id":"1Mua0g96hUldJWj00GDsel","is_local":false,"is_playable":true,"name":"Weightless Part 6","track_number":6,"type":"track","uri":"spotify:track:1Mua0g96hUldJWj00GDsel"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5TATtEeHkOOuvDapyy2GCZ"},"href":"https://api.spotify.com/v1/albums/5TATtEeHkOOuvDapyy2GCZ","id":"5TATtEeHkOOuvDapyy2GCZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27357cc51fdc66800c612efeec4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0257cc51fdc66800c612efeec4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485157cc51fdc66800c612efeec4"}],"is_playable":true,"name":"The Ambient Zone: Collection 003","release_date":"2019-06-05","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5TATtEeHkOOuvDapyy2GCZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":253693,"explicit":false,"external_ids":{"isrc":"UKKTD1900054"},"external_urls":{"spotify":"https://open.spotify.com/track/73eePFqzzFdBqTAtqqFAJp"},"href":"https://api.spotify.com/v1/tracks/73eePFqzzFdBqTAtqqFAJp","id":"73eePFqzzFdBqTAtqqFAJp","is_local":false,"is_playable":true,"name":"Weightless - 253 Edit","track_number":3,"type":"track","uri":"spotify:track:73eePFqzzFdBqTAtqqFAJp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4myfFUSWfuPuuJaU0SlB71"},"href":"https://api.spotify.com/v1/albums/4myfFUSWfuPuuJaU0SlB71","id":"4myfFUSWfuPuuJaU0SlB71","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738fde91d614d232b0f0d7821f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028fde91d614d232b0f0d7821f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518fde91d614d232b0f0d7821f"}],"is_playable":true,"name":"Mindful Meditation 001 : The Ambient Zone","release_date":"2020-12-18","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:4myfFUSWfuPuuJaU0SlB71"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3nZ3ed6p4CKc1McTLypr6H"},"href":"https://api.spotify.com/v1/artists/3nZ3ed6p4CKc1McTLypr6H","id":"3nZ3ed6p4CKc1McTLypr6H","name":"Marconi Union","type":"artist","uri":"spotify:artist:3nZ3ed6p4CKc1McTLypr6H"}],"disc_number":1,"duration_ms":253693,"explicit":false,"external_ids":{"isrc":"UKKTD1900054"},"external_urls":{"spotify":"https://open.spotify.com/track/2v7yCQGOCy4mMaXlpGSsqz"},"href":"https://api.spotify.com/v1/tracks/2v7yCQGOCy4mMaXlpGSsqz","id":"2v7yCQGOCy4mMaXlpGSsqz","is_local":false,"is_playable":true,"name":"Weightless - 253 Edit","track_number":14,"type":"track","uri":"spotify:track:2v7yCQGOCy4mMaXlpGSsqz"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldlaWdodGxlc3MlMjIlMjBhcnRpc3QlM0ElMjJNYXJjb25pJTIwVW5pb24lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MTAmbGltaXQ9MTAmcXVlcnk9dHJhY2slM0ElMjJXZWlnaHRsZXNzJTIyJTIwYXJ0aXN0JTNBJTIyTWFyY29uaSUyMFVuaW9uJTIyJnR5cGU9dHJhY2siLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MTIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBKc3JVSHFWa1drWHQwdlFlTmlWa1cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wSnNyVUhxVmtXa1h0MHZRZU5pVmtXIiwiaWQiOiIwSnNyVUhxVmtXa1h0MHZRZU5pVmtXIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2YzOTllZmEyMDA5NzEwNWU5ZGI4ODU2MCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmMzk5ZWZhMjAwOTcxMDVlOWRiODg1NjAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWYzOTllZmEyMDA5NzEwNWU5ZGI4ODU2MCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgQW1iaWVudCBab25lIEp1c3QgTXVzaWMgQ2FmZSBWb2wgNCIsInJlbGVhc2VfZGF0ZSI6IjIwMTItMTAtMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowSnNyVUhxVmtXa1h0MHZRZU5pVmtXIn0sImFydGlzdHMiOlt7ImV4dGVybmFsXw==", + "dXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJpZCI6IjNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJuYW1lIjoiTWFyY29uaSBVbmlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozblozZWQ2cDRDS2MxTWNUTHlwcjZIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQ4MDEwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCREROMTIwMDUxMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNmtrd3pCNmhYTElPTmtFazlKY2lBNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZra3d6QjZoWExJT05rRWs5SmNpQTYiLCJpZCI6IjZra3d6QjZoWExJT05rRWs5SmNpQTYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2VpZ2h0bGVzcyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2a2t3ekI2aFhMSU9Oa0VrOUpjaUE2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNuWjNlZDZwNENLYzFNY1RMeXByNkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsImlkIjoiM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsIm5hbWUiOiJNYXJjb25pIFVuaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNuWjNlZDZwNENLYzFNY1RMeXByNkgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zZDhhcFEzMlpWUkRQRnRsbFZUS0dSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiIsImlkIjoiM2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyZDYwNjc3YTAyNDM4OTkxY2M2YjI1ZWEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmQ2MDY3N2EwMjQzODk5MWNjNmIyNWVhIn0seyJoZWlnaHQiOg==", + "NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJkNjA2NzdhMDI0Mzg5OTFjYzZiMjVlYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXZWlnaHRsZXNzIChBbWJpZW50IFRyYW5zbWlzc2lvbiBWb2wuIDIpIiwicmVsZWFzZV9kYXRlIjoiMjAxMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjo2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNkOGFwUTMyWlZSRFBGdGxsVlRLR1IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJpZCI6IjNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJuYW1lIjoiTWFyY29uaSBVbmlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozblozZWQ2cDRDS2MxTWNUTHlwcjZIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQ4Njg0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCREROMTIwMDUxMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMlVaWnRrb0xPZzdJSHhlVEFkUEZ2ZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJVWlp0a29MT2c3SUh4ZVRBZFBGdmQiLCJpZCI6IjJVWlp0a29MT2c3SUh4ZVRBZFBGdmQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2VpZ2h0bGVzcyBQYXJ0IDEiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MlVaWnRrb0xPZzdJSHhlVEFkUEZ2ZCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJpZCI6IjNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJuYW1lIjoiTWFyY29uaSBVbmlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozblozZWQ2cDRDS2MxTWNUTHlwcjZIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUg==", + "In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiIsImlkIjoiM2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyZDYwNjc3YTAyNDM4OTkxY2M2YjI1ZWEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmQ2MDY3N2EwMjQzODk5MWNjNmIyNWVhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyZDYwNjc3YTAyNDM4OTkxY2M2YjI1ZWEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2VpZ2h0bGVzcyAoQW1iaWVudCBUcmFuc21pc3Npb24gVm9sLiAyKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6NiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozZDhhcFEzMlpWUkRQRnRsbFZUS0dSIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIiwiaWQiOiIzblozZWQ2cDRDS2MxTWNUTHlwcjZIIiwibmFtZSI6Ik1hcmNvbmkgVW5pb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M25aM2VkNnA0Q0tjMU1jVEx5cHI2SCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MzI1MDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkRETjEyMDA1MTEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdiMmRNUkNWRHg3T0dla0lWakNyczEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83YjJkTVJDVkR4N09HZWtJVmpDcnMxIiwiaWQiOiI3YjJkTVJDVkR4N09HZWtJVmpDcnMxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldlaWdodGxlc3MgUGFydCAyIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdiMmRNUkNWRHg3T0dla0lWakNyczEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dA==", + "cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJpZCI6IjNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJuYW1lIjoiTWFyY29uaSBVbmlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozblozZWQ2cDRDS2MxTWNUTHlwcjZIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNkOGFwUTMyWlZSRFBGdGxsVlRLR1IiLCJpZCI6IjNkOGFwUTMyWlZSRFBGdGxsVlRLR1IiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMmQ2MDY3N2EwMjQzODk5MWNjNmIyNWVhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjJkNjA2NzdhMDI0Mzg5OTFjYzZiMjVlYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMmQ2MDY3N2EwMjQzODk5MWNjNmIyNWVhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldlaWdodGxlc3MgKEFtYmllbnQgVHJhbnNtaXNzaW9uIFZvbC4gMikiLCJyZWxlYXNlX2RhdGUiOiIyMDEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNuWjNlZDZwNENLYzFNY1RMeXByNkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsImlkIjoiM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsIm5hbWUiOiJNYXJjb25pIFVuaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNuWjNlZDZwNENLYzFNY1RMeXByNkgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDU4OTA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JERE4xMjAwNTEyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83MEZmeXRJVFhKT3owczJ4WQ==", + "M3JPenoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83MEZmeXRJVFhKT3owczJ4WTNyT3p6IiwiaWQiOiI3MEZmeXRJVFhKT3owczJ4WTNyT3p6IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldlaWdodGxlc3MgUGFydCAzIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjcwRmZ5dElUWEpPejBzMnhZM3JPenoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIiwiaWQiOiIzblozZWQ2cDRDS2MxTWNUTHlwcjZIIiwibmFtZSI6Ik1hcmNvbmkgVW5pb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M25aM2VkNnA0Q0tjMU1jVEx5cHI2SCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNkOGFwUTMyWlZSRFBGdGxsVlRLR1IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zZDhhcFEzMlpWUkRQRnRsbFZUS0dSIiwiaWQiOiIzZDhhcFEzMlpWUkRQRnRsbFZUS0dSIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzJkNjA2NzdhMDI0Mzg5OTFjYzZiMjVlYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyZDYwNjc3YTAyNDM4OTkxY2M2YjI1ZWEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJkNjA2NzdhMDI0Mzg5OTFjYzZiMjVlYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXZWlnaHRsZXNzIChBbWJpZW50IFRyYW5zbWlzc2lvbiBWb2wuIDIpIiwicmVsZWFzZV9kYXRlIjoiMjAxMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjo2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNkOGFwUTMyWlZSRFBGdGxsVlRLR1IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MQ==", + "L2FydGlzdHMvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsImlkIjoiM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsIm5hbWUiOiJNYXJjb25pIFVuaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNuWjNlZDZwNENLYzFNY1RMeXByNkgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDQwMzMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JERE4xMjAwNTE0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81NnJOM1poMDNMVm5KNWtSMVZUUkpOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNTZyTjNaaDAzTFZuSjVrUjFWVFJKTiIsImlkIjoiNTZyTjNaaDAzTFZuSjVrUjFWVFJKTiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXZWlnaHRsZXNzIFBhcnQgNSIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1NnJOM1poMDNMVm5KNWtSMVZUUkpOIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNuWjNlZDZwNENLYzFNY1RMeXByNkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsImlkIjoiM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsIm5hbWUiOiJNYXJjb25pIFVuaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNuWjNlZDZwNENLYzFNY1RMeXByNkgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zZDhhcFEzMlpWUkRQRnRsbFZUS0dSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiIsImlkIjoiM2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyZDYwNjc3YTAyNDM4OTkxY2M2YjI1ZWEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmQ2MDY3N2EwMjQzODk5MWNjNmIyNWVhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyZDYwNjc3YTAyNDM4OTkxY2M2YjI1ZWEifV0sImlzX3BsYXlhYmxlIg==", + "OnRydWUsIm5hbWUiOiJXZWlnaHRsZXNzIChBbWJpZW50IFRyYW5zbWlzc2lvbiBWb2wuIDIpIiwicmVsZWFzZV9kYXRlIjoiMjAxMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjo2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNkOGFwUTMyWlZSRFBGdGxsVlRLR1IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJpZCI6IjNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJuYW1lIjoiTWFyY29uaSBVbmlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozblozZWQ2cDRDS2MxTWNUTHlwcjZIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQzNzI1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCREROMTIwMDUxMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMmZUSW4xQXFlVEdSNnRTU2ZpUzh6ayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJmVEluMUFxZVRHUjZ0U1NmaVM4emsiLCJpZCI6IjJmVEluMUFxZVRHUjZ0U1NmaVM4emsiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2VpZ2h0bGVzcyBQYXJ0IDQiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MmZUSW4xQXFlVEdSNnRTU2ZpUzh6ayJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIiwiaWQiOiIzblozZWQ2cDRDS2MxTWNUTHlwcjZIIiwibmFtZSI6Ik1hcmNvbmkgVW5pb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M25aM2VkNnA0Q0tjMU1jVEx5cHI2SCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJXdW0xemhkenJXMWQ2eDAyOHNmZFEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yV3VtMXpoZHpyVzFkNngwMjhzZmRRIiwiaWQiOiIyV3VtMXpoZHpyVzFkNngwMjhzZmRRIiwiaQ==", + "bWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmU5ZGZhNTNjYjk3NDRlOTQzZjhlYjY0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZlOWRmYTUzY2I5NzQ0ZTk0M2Y4ZWI2NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmU5ZGZhNTNjYjk3NDRlOTQzZjhlYjY0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldlaWdodGxlc3MgKDI1MyBFZGl0KSIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDMtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJXdW0xemhkenJXMWQ2eDAyOHNmZFEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJpZCI6IjNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJuYW1lIjoiTWFyY29uaSBVbmlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozblozZWQ2cDRDS2MxTWNUTHlwcjZIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1MzY5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVLS1REMTkwMDA1NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNXB3QjdwQjI5ZmdGTEpKc1l4Z0VDWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVwd0I3cEIyOWZnRkxKSnNZeGdFQ1oiLCJpZCI6IjVwd0I3cEIyOWZnRkxKSnNZeGdFQ1oiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2VpZ2h0bGVzcyAtIDI1MyBFZGl0IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVwd0I3cEIyOWZnRkxKSnNZeGdFQ1oifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zblozZWQ2cDRDS2MxTQ==", + "Y1RMeXByNkgiLCJpZCI6IjNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJuYW1lIjoiTWFyY29uaSBVbmlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozblozZWQ2cDRDS2MxTWNUTHlwcjZIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNkOGFwUTMyWlZSRFBGdGxsVlRLR1IiLCJpZCI6IjNkOGFwUTMyWlZSRFBGdGxsVlRLR1IiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMmQ2MDY3N2EwMjQzODk5MWNjNmIyNWVhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjJkNjA2NzdhMDI0Mzg5OTFjYzZiMjVlYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMmQ2MDY3N2EwMjQzODk5MWNjNmIyNWVhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldlaWdodGxlc3MgKEFtYmllbnQgVHJhbnNtaXNzaW9uIFZvbC4gMikiLCJyZWxlYXNlX2RhdGUiOiIyMDEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2Q4YXBRMzJaVlJEUEZ0bGxWVEtHUiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNuWjNlZDZwNENLYzFNY1RMeXByNkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsImlkIjoiM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsIm5hbWUiOiJNYXJjb25pIFVuaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNuWjNlZDZwNENLYzFNY1RMeXByNkgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzEwMTQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JERE4xMjAwNTE1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xTXVhMGc5NmhVbGRKV2owMEdEc2VsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMU11YTBnOTZoVWxkSldqMDBHRHNlbCIsImlkIjoiMU11YTBnOTZoVWxkSldqMDBHRHNlbCIsImlzX2xvYw==", + "YWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldlaWdodGxlc3MgUGFydCA2IiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFNdWEwZzk2aFVsZEpXajAwR0RzZWwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVRBVHRFZUhrT091dkRhcHl5MkdDWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVUQVR0RWVIa09PdXZEYXB5eTJHQ1oiLCJpZCI6IjVUQVR0RWVIa09PdXZEYXB5eTJHQ1oiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTdjYzUxZmRjNjY4MDBjNjEyZWZlZWM0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjU3Y2M1MWZkYzY2ODAwYzYxMmVmZWVjNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTdjYzUxZmRjNjY4MDBjNjEyZWZlZWM0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBBbWJpZW50IFpvbmU6IENvbGxlY3Rpb24gMDAzIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wNi0wNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVUQVR0RWVIa09PdXZEYXB5eTJHQ1oifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zblozZWQ2cDRDS2MxTWNUTHlwcjZIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJpZCI6IjNuWjNlZDZwNENLYzFNY1RMeXByNkgiLCJuYW1lIjoiTWFyY29uaSBVbmlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cg==", + "aSI6InNwb3RpZnk6YXJ0aXN0OjNuWjNlZDZwNENLYzFNY1RMeXByNkgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjUzNjkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVUtLVEQxOTAwMDU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83M2VlUEZxenpGZEJxVEF0cXFGQUpwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNzNlZVBGcXp6RmRCcVRBdHFxRkFKcCIsImlkIjoiNzNlZVBGcXp6RmRCcVRBdHFxRkFKcCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXZWlnaHRsZXNzIC0gMjUzIEVkaXQiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NzNlZVBGcXp6RmRCcVRBdHFxRkFKcCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80bXlmRlVTV2Z1UHV1SmFVMFNsQjcxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNG15ZkZVU1dmdVB1dUphVTBTbEI3MSIsImlkIjoiNG15ZkZVU1dmdVB1dUphVTBTbEI3MSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4ZmRlOTFkNjE0ZDIzMmIwZjBkNzgyMWYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOGZkZTkxZDYxNGQyMzJiMGYwZDc4MjFmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQs", + "InVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4ZmRlOTFkNjE0ZDIzMmIwZjBkNzgyMWYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWluZGZ1bCBNZWRpdGF0aW9uIDAwMSA6IFRoZSBBbWJpZW50IFpvbmUiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTEyLTE4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NG15ZkZVU1dmdVB1dUphVTBTbEI3MSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNuWjNlZDZwNENLYzFNY1RMeXByNkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsImlkIjoiM25aM2VkNnA0Q0tjMU1jVEx5cHI2SCIsIm5hbWUiOiJNYXJjb25pIFVuaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNuWjNlZDZwNENLYzFNY1RMeXByNkgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjUzNjkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVUtLVEQxOTAwMDU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8ydjd5Q1FHT0N5NG1NYVhscEdTc3F6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMnY3eUNRR09DeTRtTWFYbHBHU3NxeiIsImlkIjoiMnY3eUNRR09DeTRtTWFYbHBHU3NxeiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXZWlnaHRsZXNzIC0gMjUzIEVkaXQiLCJ0cmFja19udW1iZXIiOjE0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJ2N3lDUUdPQ3k0bU1hWGxwR1NzcXoifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Weightless%22+artist%3A%22Marconi+Union%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkhvbG9jZW5lJTIyJTIwYXJ0aXN0JTNBJTIyQm9uJTIwSXZlciUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MiwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80TEVpVW0xU1JiRk1nZnFuUVR3VWJRIiwiaWQiOiI0TEVpVW0xU1JiRk1nZnFuUVR3VWJRIiwibmFtZSI6IkJvbiBJdmVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRMRWlVbTFTUmJGTWdmcW5RVHdVYlEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yTHBmTmozdkI1ck9YZmFhd0xjT0JnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMkxwZk5qM3ZCNXJPWGZhYXdMY09CZyIsImlkIjoiMkxwZk5qM3ZCNXJPWGZhYXdMY09CZyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNg==", + "NzYxNmQwMDAwYjI3MzRiNmIxNTQ3NDU1YmJlY2I5ZjZiYmE2NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0YjZiMTU0NzQ1NWJiZWNiOWY2YmJhNjQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRiNmIxNTQ3NDU1YmJlY2I5ZjZiYmE2NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCb24gSXZlciwgQm9uIEl2ZXIiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTA2LTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MkxwZk5qM3ZCNXJPWGZhYXdMY09CZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRMRWlVbTFTUmJGTWdmcW5RVHdVYlEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSIsImlkIjoiNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSIsIm5hbWUiOiJCb24gSXZlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0TEVpVW0xU1JiRk1nZnFuUVR3VWJRIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMzNjYxMywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVMzOFkxMTEzNTAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zNUtpaUlMa2x5ZTFKUlJjdGFMVWI0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzVLaWlJTGtseWUxSlJSY3RhTFViNCIsImlkIjoiMzVLaWlJTGtseWUxSlJSY3RhTFViNCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb2xvY2VuZSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozNUtpaUlMa2x5ZTFKUlJjdGFMVWI0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRMRWlVbTFTUmJGTWdmcW5RVHdVYlEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSIsImlkIjoiNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSIsIm5hbWUiOiJCb24gSXZlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5Og==", + "YXJ0aXN0OjRMRWlVbTFTUmJGTWdmcW5RVHdVYlEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82eGZPQ3FtUXZwdmdSNWFxNmZwS01EIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnhmT0NxbVF2cHZnUjVhcTZmcEtNRCIsImlkIjoiNnhmT0NxbVF2cHZnUjVhcTZmcEtNRCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNGM2MTMyOTIyMDY4ZjdjZDIxNzg2MmQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTRjNjEzMjkyMjA2OGY3Y2QyMTc4NjJkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExNGM2MTMyOTIyMDY4ZjdjZDIxNzg2MmQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQm9uIEl2ZXIsIEJvbiBJdmVyICgxMHRoIEFubml2ZXJzYXJ5IEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAxMS0wNi0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZ4Zk9DcW1RdnB2Z1I1YXE2ZnBLTUQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80TEVpVW0xU1JiRk1nZnFuUVR3VWJRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJpZCI6IjRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJuYW1lIjoiQm9uIEl2ZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExFaVVtMVNSYkZNZ2ZxblFUd1ViUSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMzY2MTMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTMzhZMTExMzUwMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUlMRUs2TlJmeG9zZW9Qbm9sUmNWQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFJTEVLNk5SZnhvc2VvUG5vbFJjVkEiLCJpZCI6IjFJTEVLNk5SZnhvc2VvUG5vbFJjVkEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9sb2NlbmUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwbw==", + "dGlmeTp0cmFjazoxSUxFSzZOUmZ4b3Nlb1Bub2xSY1ZBIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Holocene%22+artist%3A%22Bon+Iver%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Intro%22%20artist%3A%22The%20xx%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3iOvXCl6edW5Um0fXEBRXy"},"href":"https://api.spotify.com/v1/artists/3iOvXCl6edW5Um0fXEBRXy","id":"3iOvXCl6edW5Um0fXEBRXy","name":"The xx","type":"artist","uri":"spotify:artist:3iOvXCl6edW5Um0fXEBRXy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2av2ZSHlvD7rvLSsMvtYCG"},"href":"https://api.spotify.com/v1/albums/2av2ZSHlvD7rvLSsMvtYCG","id":"2av2ZSHlvD7rvLSsMvtYCG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a46d603701aa0342e8cca64e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a46d603701aa0342e8cca64e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a46d603701aa0342e8cca64e"}],"is_playable":true,"name":"xx","release_date":"2009-08-16","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:2av2ZSHlvD7rvLSsMvtYCG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3iOvXCl6edW5Um0fXEBRXy"},"href":"https://api.spotify.com/v1/artists/3iOvXCl6edW5Um0fXEBRXy","id":"3iOvXCl6edW5Um0fXEBRXy","name":"The xx","type":"artist","uri":"spotify:artist:3iOvXCl6edW5Um0fXEBRXy"}],"disc_number":1,"duration_ms":127920,"explicit":false,"external_ids":{"isrc":"GBBKS0900196"},"external_urls":{"spotify":"https://open.spotify.com/track/2usrT8QIbIk9y0NEtQwS4j"},"href":"https://api.spotify.com/v1/tracks/2usrT8QIbIk9y0NEtQwS4j","id":"2usrT8QIbIk9y0NEtQwS4j","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:2usrT8QIbIk9y0NEtQwS4j"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3iOvXCl6edW5Um0fXEBRXy"},"href":"https://api.spotify.com/v1/artists/3iOvXCl6edW5Um0fXEBRXy","id":"3iOvXCl6edW5Um0fXEBRXy","name":"The xx","type":"artist","uri":"spotify:artist:3iOvXCl6edW5Um0fXEBRXy"}],"external_urls":{"spotify":"https://open.spotify.com/album/10p4597ekqFOqMbttkxggC"},"href":"https://api.spotify.com/v1/albums/10p4597ekqFOqMbttkxggC","id":"10p4597ekqFOqMbttkxggC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273789657ec664daa222cab1e5a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02789657ec664daa222cab1e5a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851789657ec664daa222cab1e5a"}],"is_playable":true,"name":"xx (Deluxe)","release_date":"2025-11-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:10p4597ekqFOqMbttkxggC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3iOvXCl6edW5Um0fXEBRXy"},"href":"https://api.spotify.com/v1/artists/3iOvXCl6edW5Um0fXEBRXy","id":"3iOvXCl6edW5Um0fXEBRXy","name":"The xx","type":"artist","uri":"spotify:artist:3iOvXCl6edW5Um0fXEBRXy"}],"disc_number":1,"duration_ms":127920,"explicit":false,"external_ids":{"isrc":"GBBKS0900196"},"external_urls":{"spotify":"https://open.spotify.com/track/2dIi21bJASzEKP20LIutOE"},"href":"https://api.spotify.com/v1/tracks/2dIi21bJASzEKP20LIutOE","id":"2dIi21bJASzEKP20LIutOE","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:2dIi21bJASzEKP20LIutOE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1rC1W1RD96Sp9nlds4YMOb"},"href":"https://api.spotify.com/v1/artists/1rC1W1RD96Sp9nlds4YMOb","id":"1rC1W1RD96Sp9nlds4YMOb","name":"The XX's","type":"artist","uri":"spotify:artist:1rC1W1RD96Sp9nlds4YMOb"}],"external_urls":{"spotify":"https://open.spotify.com/album/3CfmibEuvYTQQzIKxNLrsm"},"href":"https://api.spotify.com/v1/albums/3CfmibEuvYTQQzIKxNLrsm","id":"3CfmibEuvYTQQzIKxNLrsm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27347e6063b566c8242e3d20e41"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0247e6063b566c8242e3d20e41"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485147e6063b566c8242e3d20e41"}],"is_playable":true,"name":"Another Day At The Office","release_date":"2005-11-30","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:3CfmibEuvYTQQzIKxNLrsm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1rC1W1RD96Sp9nlds4YMOb"},"href":"https://api.spotify.com/v1/artists/1rC1W1RD96Sp9nlds4YMOb","id":"1rC1W1RD96Sp9nlds4YMOb","name":"The XX's","type":"artist","uri":"spotify:artist:1rC1W1RD96Sp9nlds4YMOb"}],"disc_number":1,"duration_ms":109946,"explicit":false,"external_ids":{"isrc":"uscgj0570970"},"external_urls":{"spotify":"https://open.spotify.com/track/2QTHumpkGlw5EyH56ltXo5"},"href":"https://api.spotify.com/v1/tracks/2QTHumpkGlw5EyH56ltXo5","id":"2QTHumpkGlw5EyH56ltXo5","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:2QTHumpkGlw5EyH56ltXo5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4ESpOTT25LeAtL0vk7BJvc"},"href":"https://api.spotify.com/v1/artists/4ESpOTT25LeAtL0vk7BJvc","id":"4ESpOTT25LeAtL0vk7BJvc","name":"Xx_ThePiglets_xX","type":"artist","uri":"spotify:artist:4ESpOTT25LeAtL0vk7BJvc"}],"external_urls":{"spotify":"https://open.spotify.com/album/5lzBRCX5x1kpD8MlE9Il1q"},"href":"https://api.spotify.com/v1/albums/5lzBRCX5x1kpD8MlE9Il1q","id":"5lzBRCX5x1kpD8MlE9Il1q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273790875cc9714225f08cd58e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02790875cc9714225f08cd58e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851790875cc9714225f08cd58e7"}],"is_playable":true,"name":"I'm So Sad","release_date":"2024-10-31","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:5lzBRCX5x1kpD8MlE9Il1q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4ESpOTT25LeAtL0vk7BJvc"},"href":"https://api.spotify.com/v1/artists/4ESpOTT25LeAtL0vk7BJvc","id":"4ESpOTT25LeAtL0vk7BJvc","name":"Xx_ThePiglets_xX","type":"artist","uri":"spotify:artist:4ESpOTT25LeAtL0vk7BJvc"}],"disc_number":1,"duration_ms":302741,"explicit":true,"external_ids":{"isrc":"QZMEP2542962"},"external_urls":{"spotify":"https://open.spotify.com/track/3X8wN04e1NPWTBHB6ZpdLa"},"href":"https://api.spotify.com/v1/tracks/3X8wN04e1NPWTBHB6ZpdLa","id":"3X8wN04e1NPWTBHB6ZpdLa","is_local":false,"is_playable":true,"name":"INTRO","track_number":2,"type":"track","uri":"spotify:track:3X8wN04e1NPWTBHB6ZpdLa"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/12DpuAVrnbh8eKi7uMzhs5"},"href":"https://api.spotify.com/v1/artists/12DpuAVrnbh8eKi7uMzhs5","id":"12DpuAVrnbh8eKi7uMzhs5","name":"The Unknown Boyz","type":"artist","uri":"spotify:artist:12DpuAVrnbh8eKi7uMzhs5"}],"external_urls":{"spotify":"https://open.spotify.com/album/4x16RngOkeXYP13uA5NddB"},"href":"https://api.spotify.com/v1/albums/4x16RngOkeXYP13uA5NddB","id":"4x16RngOkeXYP13uA5NddB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738e2996955678287bd0f16755"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028e2996955678287bd0f16755"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518e2996955678287bd0f16755"}],"is_playable":true,"name":"The Unknown Boyz, Vol. 1","release_date":"2024-06-24","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:4x16RngOkeXYP13uA5NddB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/12DpuAVrnbh8eKi7uMzhs5"},"href":"https://api.spotify.com/v1/artists/12DpuAVrnbh8eKi7uMzhs5","id":"12DpuAVrnbh8eKi7uMzhs5","name":"The Unknown Boyz","type":"artist","uri":"spotify:artist:12DpuAVrnbh8eKi7uMzhs5"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3AREjub71vtuhuhkCWmGGE"},"href":"https://api.spotify.com/v1/artists/3AREjub71vtuhuhkCWmGGE","id":"3AREjub71vtuhuhkCWmGGE","name":"Xatarius","type":"artist","uri":"spotify:artist:3AREjub71vtuhuhkCWmGGE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7570sf7UgJq04mwcMUDy54"},"href":"https://api.spotify.com/v1/artists/7570sf7UgJq04mwcMUDy54","id":"7570sf7UgJq04mwcMUDy54","name":"Crybaby","type":"artist","uri":"spotify:artist:7570sf7UgJq04mwcMUDy54"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7gOR8hEJuuRjTWgfKUhlNo"},"href":"https://api.spotify.com/v1/artists/7gOR8hEJuuRjTWgfKUhlNo","id":"7gOR8hEJuuRjTWgfKUhlNo","name":"XXXNIGHTMARE","type":"artist","uri":"spotify:artist:7gOR8hEJuuRjTWgfKUhlNo"}],"disc_number":1,"duration_ms":55309,"explicit":true,"external_ids":{"isrc":"QZNWY2492836"},"external_urls":{"spotify":"https://open.spotify.com/track/05sZPaIxQoENDOruaHq1Xh"},"href":"https://api.spotify.com/v1/tracks/05sZPaIxQoENDOruaHq1Xh","id":"05sZPaIxQoENDOruaHq1Xh","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:05sZPaIxQoENDOruaHq1Xh"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3IKkZkDcR4a0LPdgq9hILc"},"href":"https://api.spotify.com/v1/artists/3IKkZkDcR4a0LPdgq9hILc","id":"3IKkZkDcR4a0LPdgq9hILc","name":"UPN\u039eXX","type":"artist","uri":"spotify:artist:3IKkZkDcR4a0LPdgq9hILc"}],"external_urls":{"spotify":"https://open.spotify.com/album/7dfyJ2sAzhjqs5Qxu1NJMW"},"href":"https://api.spotify.com/v1/albums/7dfyJ2sAzhjqs5Qxu1NJMW","id":"7dfyJ2sAzhjqs5Qxu1NJMW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737926d32952ff66b65f3d6174"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027926d32952ff66b65f3d6174"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517926d32952ff66b65f3d6174"}],"is_playable":true,"name":"Black & White","release_date":"2023-01-28","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7dfyJ2sAzhjqs5Qxu1NJMW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3IKkZkDcR4a0LPdgq9hILc"},"href":"https://api.spotify.com/v1/artists/3IKkZkDcR4a0LPdgq9hILc","id":"3IKkZkDcR4a0LPdgq9hILc","name":"UPN\u039eXX","type":"artist","uri":"spotify:artist:3IKkZkDcR4a0LPdgq9hILc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2x4IG8mHcHVRTjhVnKYiOF"},"href":"https://api.spotify.com/v1/artists/2x4IG8mHcHVRTjhVnKYiOF","id":"2x4IG8mHcHVRTjhVnKYiOF","name":"J$ Savage","type":"artist","uri":"spotify:artist:2x4IG8mHcHVRTjhVnKYiOF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4RmoDiXMcRMGhcajiLJfKa"},"href":"https://api.spotify.com/v1/artists/4RmoDiXMcRMGhcajiLJfKa","id":"4RmoDiXMcRMGhcajiLJfKa","name":"Kin On The Beat","type":"artist","uri":"spotify:artist:4RmoDiXMcRMGhcajiLJfKa"}],"disc_number":1,"duration_ms":86000,"explicit":true,"external_ids":{"isrc":"TCAGR2269138"},"external_urls":{"spotify":"https://open.spotify.com/track/2pBZYGOdw68AAyKvm8Mfeb"},"href":"https://api.spotify.com/v1/tracks/2pBZYGOdw68AAyKvm8Mfeb","id":"2pBZYGOdw68AAyKvm8Mfeb","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:2pBZYGOdw68AAyKvm8Mfeb"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0lG5ysn5WlpW7ZrWFySh2y"},"href":"https://api.spotify.com/v1/artists/0lG5ysn5WlpW7ZrWFySh2y","id":"0lG5ysn5WlpW7ZrWFySh2y","name":"mari0xx","type":"artist","uri":"spotify:artist:0lG5ysn5WlpW7ZrWFySh2y"}],"external_urls":{"spotify":"https://open.spotify.com/album/5gAp0c0x4WGR3E9sEdQU5D"},"href":"https://api.spotify.com/v1/albums/5gAp0c0x4WGR3E9sEdQU5D","id":"5gAp0c0x4WGR3E9sEdQU5D","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273834da921925755f79f3c7899"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02834da921925755f79f3c7899"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851834da921925755f79f3c7899"}],"is_playable":true,"name":"Elysium","release_date":"2023-10-22","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5gAp0c0x4WGR3E9sEdQU5D"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0lG5ysn5WlpW7ZrWFySh2y"},"href":"https://api.spotify.com/v1/artists/0lG5ysn5WlpW7ZrWFySh2y","id":"0lG5ysn5WlpW7ZrWFySh2y","name":"mari0xx","type":"artist","uri":"spotify:artist:0lG5ysn5WlpW7ZrWFySh2y"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2uG1RmNQvDtON1rNtFhH6p"},"href":"https://api.spotify.com/v1/artists/2uG1RmNQvDtON1rNtFhH6p","id":"2uG1RmNQvDtON1rNtFhH6p","name":"The Image","type":"artist","uri":"spotify:artist:2uG1RmNQvDtON1rNtFhH6p"}],"disc_number":1,"duration_ms":96053,"explicit":false,"external_ids":{"isrc":"UKXN22362723"},"external_urls":{"spotify":"https://open.spotify.com/track/77KuRaEaWZUYUP5D6LHAMe"},"href":"https://api.spotify.com/v1/tracks/77KuRaEaWZUYUP5D6LHAMe","id":"77KuRaEaWZUYUP5D6LHAMe","is_local":false,"is_playable":true,"name":"Heaven Sent - Intro","track_number":1,"type":"track","uri":"spotify:track:77KuRaEaWZUYUP5D6LHAMe"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0mBKhMlUBD6mbk4PdnN7St"},"href":"https://api.spotify.com/v1/artists/0mBKhMlUBD6mbk4PdnN7St","id":"0mBKhMlUBD6mbk4PdnN7St","name":"The Schola Cantorum of St. John XXIII Parish","type":"artist","uri":"spotify:artist:0mBKhMlUBD6mbk4PdnN7St"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ZK7DrrbHvhGKJzKgwPlnx"},"href":"https://api.spotify.com/v1/albums/4ZK7DrrbHvhGKJzKgwPlnx","id":"4ZK7DrrbHvhGKJzKgwPlnx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273154a46917805384208c78998"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02154a46917805384208c78998"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851154a46917805384208c78998"}],"is_playable":true,"name":"Christum Natum Adoremus","release_date":"2015-01-23","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4ZK7DrrbHvhGKJzKgwPlnx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0mBKhMlUBD6mbk4PdnN7St"},"href":"https://api.spotify.com/v1/artists/0mBKhMlUBD6mbk4PdnN7St","id":"0mBKhMlUBD6mbk4PdnN7St","name":"The Schola Cantorum of St. John XXIII Parish","type":"artist","uri":"spotify:artist:0mBKhMlUBD6mbk4PdnN7St"}],"disc_number":1,"duration_ms":174410,"explicit":false,"external_ids":{"isrc":"TCACD1544723"},"external_urls":{"spotify":"https://open.spotify.com/track/1xrqm8I1SCqhRzqGGEFeKL"},"href":"https://api.spotify.com/v1/tracks/1xrqm8I1SCqhRzqGGEFeKL","id":"1xrqm8I1SCqhRzqGGEFeKL","is_local":false,"is_playable":true,"name":"Introit: Puer Natus","track_number":7,"type":"track","uri":"spotify:track:1xrqm8I1SCqhRzqGGEFeKL"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Intro%22%20artist%3A%22The%20xx%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3iOvXCl6edW5Um0fXEBRXy"},"href":"https://api.spotify.com/v1/artists/3iOvXCl6edW5Um0fXEBRXy","id":"3iOvXCl6edW5Um0fXEBRXy","name":"The xx","type":"artist","uri":"spotify:artist:3iOvXCl6edW5Um0fXEBRXy"}],"external_urls":{"spotify":"https://open.spotify.com/album/2av2ZSHlvD7rvLSsMvtYCG"},"href":"https://api.spotify.com/v1/albums/2av2ZSHlvD7rvLSsMvtYCG","id":"2av2ZSHlvD7rvLSsMvtYCG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a46d603701aa0342e8cca64e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a46d603701aa0342e8cca64e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a46d603701aa0342e8cca64e"}],"is_playable":true,"name":"xx","release_date":"2009-08-16","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:2av2ZSHlvD7rvLSsMvtYCG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3iOvXCl6edW5Um0fXEBRXy"},"href":"https://api.spotify.com/v1/artists/3iOvXCl6edW5Um0fXEBRXy","id":"3iOvXCl6edW5Um0fXEBRXy","name":"The xx","type":"artist","uri":"spotify:artist:3iOvXCl6edW5Um0fXEBRXy"}],"disc_number":1,"duration_ms":127920,"explicit":false,"external_ids":{"isrc":"GBBKS0900196"},"external_urls":{"spotify":"https://open.spotify.com/track/2usrT8QIbIk9y0NEtQwS4j"},"href":"https://api.spotify.com/v1/tracks/2usrT8QIbIk9y0NEtQwS4j","id":"2usrT8QIbIk9y0NEtQwS4j","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:2usrT8QIbIk9y0NEtQwS4j"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3iOvXCl6edW5Um0fXEBRXy"},"href":"https://api.spotify.com/v1/artists/3iOvXCl6edW5Um0fXEBRXy","id":"3iOvXCl6edW5Um0fXEBRXy","name":"The xx","type":"artist","uri":"spotify:artist:3iOvXCl6edW5Um0fXEBRXy"}],"external_urls":{"spotify":"https://open.spotify.com/album/10p4597ekqFOqMbttkxggC"},"href":"https://api.spotify.com/v1/albums/10p4597ekqFOqMbttkxggC","id":"10p4597ekqFOqMbttkxggC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273789657ec664daa222cab1e5a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02789657ec664daa222cab1e5a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851789657ec664daa222cab1e5a"}],"is_playable":true,"name":"xx (Deluxe)","release_date":"2025-11-19","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:10p4597ekqFOqMbttkxggC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3iOvXCl6edW5Um0fXEBRXy"},"href":"https://api.spotify.com/v1/artists/3iOvXCl6edW5Um0fXEBRXy","id":"3iOvXCl6edW5Um0fXEBRXy","name":"The xx","type":"artist","uri":"spotify:artist:3iOvXCl6edW5Um0fXEBRXy"}],"disc_number":1,"duration_ms":127920,"explicit":false,"external_ids":{"isrc":"GBBKS0900196"},"external_urls":{"spotify":"https://open.spotify.com/track/2dIi21bJASzEKP20LIutOE"},"href":"https://api.spotify.com/v1/tracks/2dIi21bJASzEKP20LIutOE","id":"2dIi21bJASzEKP20LIutOE","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:2dIi21bJASzEKP20LIutOE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1rC1W1RD96Sp9nlds4YMOb"},"href":"https://api.spotify.com/v1/artists/1rC1W1RD96Sp9nlds4YMOb","id":"1rC1W1RD96Sp9nlds4YMOb","name":"The XX's","type":"artist","uri":"spotify:artist:1rC1W1RD96Sp9nlds4YMOb"}],"external_urls":{"spotify":"https://open.spotify.com/album/3CfmibEuvYTQQzIKxNLrsm"},"href":"https://api.spotify.com/v1/albums/3CfmibEuvYTQQzIKxNLrsm","id":"3CfmibEuvYTQQzIKxNLrsm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27347e6063b566c8242e3d20e41"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0247e6063b566c8242e3d20e41"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485147e6063b566c8242e3d20e41"}],"is_playable":true,"name":"Another Day At The Office","release_date":"2005-11-30","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:3CfmibEuvYTQQzIKxNLrsm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1rC1W1RD96Sp9nlds4YMOb"},"href":"https://api.spotify.com/v1/artists/1rC1W1RD96Sp9nlds4YMOb","id":"1rC1W1RD96Sp9nlds4YMOb","name":"The XX's","type":"artist","uri":"spotify:artist:1rC1W1RD96Sp9nlds4YMOb"}],"disc_number":1,"duration_ms":109946,"explicit":false,"external_ids":{"isrc":"uscgj0570970"},"external_urls":{"spotify":"https://open.spotify.com/track/2QTHumpkGlw5EyH56ltXo5"},"href":"https://api.spotify.com/v1/tracks/2QTHumpkGlw5EyH56ltXo5","id":"2QTHumpkGlw5EyH56ltXo5","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:2QTHumpkGlw5EyH56ltXo5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4ESpOTT25LeAtL0vk7BJvc"},"href":"https://api.spotify.com/v1/artists/4ESpOTT25LeAtL0vk7BJvc","id":"4ESpOTT25LeAtL0vk7BJvc","name":"Xx_ThePiglets_xX","type":"artist","uri":"spotify:artist:4ESpOTT25LeAtL0vk7BJvc"}],"external_urls":{"spotify":"https://open.spotify.com/album/5lzBRCX5x1kpD8MlE9Il1q"},"href":"https://api.spotify.com/v1/albums/5lzBRCX5x1kpD8MlE9Il1q","id":"5lzBRCX5x1kpD8MlE9Il1q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273790875cc9714225f08cd58e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02790875cc9714225f08cd58e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851790875cc9714225f08cd58e7"}],"is_playable":true,"name":"I'm So Sad","release_date":"2024-10-31","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:5lzBRCX5x1kpD8MlE9Il1q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4ESpOTT25LeAtL0vk7BJvc"},"href":"https://api.spotify.com/v1/artists/4ESpOTT25LeAtL0vk7BJvc","id":"4ESpOTT25LeAtL0vk7BJvc","name":"Xx_ThePiglets_xX","type":"artist","uri":"spotify:artist:4ESpOTT25LeAtL0vk7BJvc"}],"disc_number":1,"duration_ms":302741,"explicit":true,"external_ids":{"isrc":"QZMEP2542962"},"external_urls":{"spotify":"https://open.spotify.com/track/3X8wN04e1NPWTBHB6ZpdLa"},"href":"https://api.spotify.com/v1/tracks/3X8wN04e1NPWTBHB6ZpdLa","id":"3X8wN04e1NPWTBHB6ZpdLa","is_local":false,"is_playable":true,"name":"INTRO","track_number":2,"type":"track","uri":"spotify:track:3X8wN04e1NPWTBHB6ZpdLa"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/12DpuAVrnbh8eKi7uMzhs5"},"href":"https://api.spotify.com/v1/artists/12DpuAVrnbh8eKi7uMzhs5","id":"12DpuAVrnbh8eKi7uMzhs5","name":"The Unknown Boyz","type":"artist","uri":"spotify:artist:12DpuAVrnbh8eKi7uMzhs5"}],"external_urls":{"spotify":"https://open.spotify.com/album/4x16RngOkeXYP13uA5NddB"},"href":"https://api.spotify.com/v1/albums/4x16RngOkeXYP13uA5NddB","id":"4x16RngOkeXYP13uA5NddB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738e2996955678287bd0f16755"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028e2996955678287bd0f16755"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518e2996955678287bd0f16755"}],"is_playable":true,"name":"The Unknown Boyz, Vol. 1","release_date":"2024-06-24","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:4x16RngOkeXYP13uA5NddB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/12DpuAVrnbh8eKi7uMzhs5"},"href":"https://api.spotify.com/v1/artists/12DpuAVrnbh8eKi7uMzhs5","id":"12DpuAVrnbh8eKi7uMzhs5","name":"The Unknown Boyz","type":"artist","uri":"spotify:artist:12DpuAVrnbh8eKi7uMzhs5"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3AREjub71vtuhuhkCWmGGE"},"href":"https://api.spotify.com/v1/artists/3AREjub71vtuhuhkCWmGGE","id":"3AREjub71vtuhuhkCWmGGE","name":"Xatarius","type":"artist","uri":"spotify:artist:3AREjub71vtuhuhkCWmGGE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7570sf7UgJq04mwcMUDy54"},"href":"https://api.spotify.com/v1/artists/7570sf7UgJq04mwcMUDy54","id":"7570sf7UgJq04mwcMUDy54","name":"Crybaby","type":"artist","uri":"spotify:artist:7570sf7UgJq04mwcMUDy54"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7gOR8hEJuuRjTWgfKUhlNo"},"href":"https://api.spotify.com/v1/artists/7gOR8hEJuuRjTWgfKUhlNo","id":"7gOR8hEJuuRjTWgfKUhlNo","name":"XXXNIGHTMARE","type":"artist","uri":"spotify:artist:7gOR8hEJuuRjTWgfKUhlNo"}],"disc_number":1,"duration_ms":55309,"explicit":true,"external_ids":{"isrc":"QZNWY2492836"},"external_urls":{"spotify":"https://open.spotify.com/track/05sZPaIxQoENDOruaHq1Xh"},"href":"https://api.spotify.com/v1/tracks/05sZPaIxQoENDOruaHq1Xh","id":"05sZPaIxQoENDOruaHq1Xh","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:05sZPaIxQoENDOruaHq1Xh"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3IKkZkDcR4a0LPdgq9hILc"},"href":"https://api.spotify.com/v1/artists/3IKkZkDcR4a0LPdgq9hILc","id":"3IKkZkDcR4a0LPdgq9hILc","name":"UPN\u039eXX","type":"artist","uri":"spotify:artist:3IKkZkDcR4a0LPdgq9hILc"}],"external_urls":{"spotify":"https://open.spotify.com/album/7dfyJ2sAzhjqs5Qxu1NJMW"},"href":"https://api.spotify.com/v1/albums/7dfyJ2sAzhjqs5Qxu1NJMW","id":"7dfyJ2sAzhjqs5Qxu1NJMW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737926d32952ff66b65f3d6174"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027926d32952ff66b65f3d6174"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517926d32952ff66b65f3d6174"}],"is_playable":true,"name":"Black & White","release_date":"2023-01-28","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7dfyJ2sAzhjqs5Qxu1NJMW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3IKkZkDcR4a0LPdgq9hILc"},"href":"https://api.spotify.com/v1/artists/3IKkZkDcR4a0LPdgq9hILc","id":"3IKkZkDcR4a0LPdgq9hILc","name":"UPN\u039eXX","type":"artist","uri":"spotify:artist:3IKkZkDcR4a0LPdgq9hILc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2x4IG8mHcHVRTjhVnKYiOF"},"href":"https://api.spotify.com/v1/artists/2x4IG8mHcHVRTjhVnKYiOF","id":"2x4IG8mHcHVRTjhVnKYiOF","name":"J$ Savage","type":"artist","uri":"spotify:artist:2x4IG8mHcHVRTjhVnKYiOF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4RmoDiXMcRMGhcajiLJfKa"},"href":"https://api.spotify.com/v1/artists/4RmoDiXMcRMGhcajiLJfKa","id":"4RmoDiXMcRMGhcajiLJfKa","name":"Kin On The Beat","type":"artist","uri":"spotify:artist:4RmoDiXMcRMGhcajiLJfKa"}],"disc_number":1,"duration_ms":86000,"explicit":true,"external_ids":{"isrc":"TCAGR2269138"},"external_urls":{"spotify":"https://open.spotify.com/track/2pBZYGOdw68AAyKvm8Mfeb"},"href":"https://api.spotify.com/v1/tracks/2pBZYGOdw68AAyKvm8Mfeb","id":"2pBZYGOdw68AAyKvm8Mfeb","is_local":false,"is_playable":true,"name":"Intro","track_number":1,"type":"track","uri":"spotify:track:2pBZYGOdw68AAyKvm8Mfeb"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0lG5ysn5WlpW7ZrWFySh2y"},"href":"https://api.spotify.com/v1/artists/0lG5ysn5WlpW7ZrWFySh2y","id":"0lG5ysn5WlpW7ZrWFySh2y","name":"mari0xx","type":"artist","uri":"spotify:artist:0lG5ysn5WlpW7ZrWFySh2y"}],"external_urls":{"spotify":"https://open.spotify.com/album/5gAp0c0x4WGR3E9sEdQU5D"},"href":"https://api.spotify.com/v1/albums/5gAp0c0x4WGR3E9sEdQU5D","id":"5gAp0c0x4WGR3E9sEdQU5D","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273834da921925755f79f3c7899"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02834da921925755f79f3c7899"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851834da921925755f79f3c7899"}],"is_playable":true,"name":"Elysium","release_date":"2023-10-22","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5gAp0c0x4WGR3E9sEdQU5D"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0lG5ysn5WlpW7ZrWFySh2y"},"href":"https://api.spotify.com/v1/artists/0lG5ysn5WlpW7ZrWFySh2y","id":"0lG5ysn5WlpW7ZrWFySh2y","name":"mari0xx","type":"artist","uri":"spotify:artist:0lG5ysn5WlpW7ZrWFySh2y"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2uG1RmNQvDtON1rNtFhH6p"},"href":"https://api.spotify.com/v1/artists/2uG1RmNQvDtON1rNtFhH6p","id":"2uG1RmNQvDtON1rNtFhH6p","name":"The Image","type":"artist","uri":"spotify:artist:2uG1RmNQvDtON1rNtFhH6p"}],"disc_number":1,"duration_ms":96053,"explicit":false,"external_ids":{"isrc":"UKXN22362723"},"external_urls":{"spotify":"https://open.spotify.com/track/77KuRaEaWZUYUP5D6LHAMe"},"href":"https://api.spotify.com/v1/tracks/77KuRaEaWZUYUP5D6LHAMe","id":"77KuRaEaWZUYUP5D6LHAMe","is_local":false,"is_playable":true,"name":"Heaven Sent - Intro","track_number":1,"type":"track","uri":"spotify:track:77KuRaEaWZUYUP5D6LHAMe"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0mBKhMlUBD6mbk4PdnN7St"},"href":"https://api.spotify.com/v1/artists/0mBKhMlUBD6mbk4PdnN7St","id":"0mBKhMlUBD6mbk4PdnN7St","name":"The Schola Cantorum of St. John XXIII Parish","type":"artist","uri":"spotify:artist:0mBKhMlUBD6mbk4PdnN7St"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ZK7DrrbHvhGKJzKgwPlnx"},"href":"https://api.spotify.com/v1/albums/4ZK7DrrbHvhGKJzKgwPlnx","id":"4ZK7DrrbHvhGKJzKgwPlnx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273154a46917805384208c78998"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02154a46917805384208c78998"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851154a46917805384208c78998"}],"is_playable":true,"name":"Christum Natum Adoremus","release_date":"2015-01-23","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4ZK7DrrbHvhGKJzKgwPlnx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0mBKhMlUBD6mbk4PdnN7St"},"href":"https://api.spotify.com/v1/artists/0mBKhMlUBD6mbk4PdnN7St","id":"0mBKhMlUBD6mbk4PdnN7St","name":"The Schola Cantorum of St. John XXIII Parish","type":"artist","uri":"spotify:artist:0mBKhMlUBD6mbk4PdnN7St"}],"disc_number":1,"duration_ms":174410,"explicit":false,"external_ids":{"isrc":"TCACD1544723"},"external_urls":{"spotify":"https://open.spotify.com/track/1xrqm8I1SCqhRzqGGEFeKL"},"href":"https://api.spotify.com/v1/tracks/1xrqm8I1SCqhRzqGGEFeKL","id":"1xrqm8I1SCqhRzqGGEFeKL","is_local":false,"is_playable":true,"name":"Introit: Puer Natus","track_number":7,"type":"track","uri":"spotify:track:1xrqm8I1SCqhRzqGGEFeKL"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Intro%22+artist%3A%22The+xx%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Divenire%22%20artist%3A%22Ludovico%20Einaudi%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/2EhFeiWsTdfqzdFskVUxBg"},"href":"https://api.spotify.com/v1/albums/2EhFeiWsTdfqzdFskVUxBg","id":"2EhFeiWsTdfqzdFskVUxBg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f58c2d280edcb6931a108fbd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f58c2d280edcb6931a108fbd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f58c2d280edcb6931a108fbd"}],"is_playable":true,"name":"Divenire (Deluxe Edition)","release_date":"2006-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2EhFeiWsTdfqzdFskVUxBg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6c3mMiMnHQtu4mGWN87CFx"},"href":"https://api.spotify.com/v1/artists/6c3mMiMnHQtu4mGWN87CFx","id":"6c3mMiMnHQtu4mGWN87CFx","name":"Robert Ziegler","type":"artist","uri":"spotify:artist:6c3mMiMnHQtu4mGWN87CFx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0MvSBMGRQJY3mRwIbJsqF1"},"href":"https://api.spotify.com/v1/artists/0MvSBMGRQJY3mRwIbJsqF1","id":"0MvSBMGRQJY3mRwIbJsqF1","name":"Royal Philharmonic Orchestra","type":"artist","uri":"spotify:artist:0MvSBMGRQJY3mRwIbJsqF1"}],"disc_number":1,"duration_ms":402240,"explicit":false,"external_ids":{"isrc":"ITB280600002"},"external_urls":{"spotify":"https://open.spotify.com/track/6KpO4neDXxGdiEgsivZieY"},"href":"https://api.spotify.com/v1/tracks/6KpO4neDXxGdiEgsivZieY","id":"6KpO4neDXxGdiEgsivZieY","is_local":false,"is_playable":true,"name":"Divenire","track_number":2,"type":"track","uri":"spotify:track:6KpO4neDXxGdiEgsivZieY"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/7k1Ki5pYinGM3lME2Tv3AM"},"href":"https://api.spotify.com/v1/albums/7k1Ki5pYinGM3lME2Tv3AM","id":"7k1Ki5pYinGM3lME2Tv3AM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739d706d33e975dfa107e11b1e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029d706d33e975dfa107e11b1e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519d706d33e975dfa107e11b1e"}],"is_playable":true,"name":"Islands - Essential Einaudi","release_date":"2011-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:7k1Ki5pYinGM3lME2Tv3AM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"disc_number":1,"duration_ms":402466,"explicit":false,"external_ids":{"isrc":"ITB280600002"},"external_urls":{"spotify":"https://open.spotify.com/track/3uuXITRf0o9WApETIMyjhj"},"href":"https://api.spotify.com/v1/tracks/3uuXITRf0o9WApETIMyjhj","id":"3uuXITRf0o9WApETIMyjhj","is_local":false,"is_playable":true,"name":"Divenire","track_number":5,"type":"track","uri":"spotify:track:3uuXITRf0o9WApETIMyjhj"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/4xFNo2OWDR8wEm5I2dRdS7"},"href":"https://api.spotify.com/v1/albums/4xFNo2OWDR8wEm5I2dRdS7","id":"4xFNo2OWDR8wEm5I2dRdS7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f3070ac545f3c6c4106ce916"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f3070ac545f3c6c4106ce916"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f3070ac545f3c6c4106ce916"}],"is_playable":true,"name":"Divenire","release_date":"2006-10-23","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:4xFNo2OWDR8wEm5I2dRdS7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6c3mMiMnHQtu4mGWN87CFx"},"href":"https://api.spotify.com/v1/artists/6c3mMiMnHQtu4mGWN87CFx","id":"6c3mMiMnHQtu4mGWN87CFx","name":"Robert Ziegler","type":"artist","uri":"spotify:artist:6c3mMiMnHQtu4mGWN87CFx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0MvSBMGRQJY3mRwIbJsqF1"},"href":"https://api.spotify.com/v1/artists/0MvSBMGRQJY3mRwIbJsqF1","id":"0MvSBMGRQJY3mRwIbJsqF1","name":"Royal Philharmonic Orchestra","type":"artist","uri":"spotify:artist:0MvSBMGRQJY3mRwIbJsqF1"}],"disc_number":1,"duration_ms":402240,"explicit":false,"external_ids":{"isrc":"ITB280600002"},"external_urls":{"spotify":"https://open.spotify.com/track/39H9bPCzk6wowylEGgDCNC"},"href":"https://api.spotify.com/v1/tracks/39H9bPCzk6wowylEGgDCNC","id":"39H9bPCzk6wowylEGgDCNC","is_local":false,"is_playable":true,"name":"Divenire","track_number":2,"type":"track","uri":"spotify:track:39H9bPCzk6wowylEGgDCNC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/6HrjdZBesenIY3JJjldQF3"},"href":"https://api.spotify.com/v1/albums/6HrjdZBesenIY3JJjldQF3","id":"6HrjdZBesenIY3JJjldQF3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739f285b934e6ee403ce86f745"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029f285b934e6ee403ce86f745"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519f285b934e6ee403ce86f745"}],"is_playable":true,"name":"The Royal Albert Hall Concert","release_date":"2010-09-28","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6HrjdZBesenIY3JJjldQF3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"disc_number":1,"duration_ms":547720,"explicit":false,"external_ids":{"isrc":"ITB281000033"},"external_urls":{"spotify":"https://open.spotify.com/track/26CrLiV7DRibZGAcX394sn"},"href":"https://api.spotify.com/v1/tracks/26CrLiV7DRibZGAcX394sn","id":"26CrLiV7DRibZGAcX394sn","is_local":false,"is_playable":true,"name":"Divenire - Live","track_number":17,"type":"track","uri":"spotify:track:26CrLiV7DRibZGAcX394sn"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/670EXb4x6t2MAvRvqCixyx"},"href":"https://api.spotify.com/v1/artists/670EXb4x6t2MAvRvqCixyx","id":"670EXb4x6t2MAvRvqCixyx","name":"Mari Samuelsen","type":"artist","uri":"spotify:artist:670EXb4x6t2MAvRvqCixyx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0PveFynDT0XrxSZFPnm40C"},"href":"https://api.spotify.com/v1/artists/0PveFynDT0XrxSZFPnm40C","id":"0PveFynDT0XrxSZFPnm40C","name":"Hakon Samuelsen","type":"artist","uri":"spotify:artist:0PveFynDT0XrxSZFPnm40C"}],"external_urls":{"spotify":"https://open.spotify.com/album/76fwH1XZ2tC53fCMKSkQRF"},"href":"https://api.spotify.com/v1/albums/76fwH1XZ2tC53fCMKSkQRF","id":"76fwH1XZ2tC53fCMKSkQRF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735d8786a0a27222e40aa1d17e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025d8786a0a27222e40aa1d17e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515d8786a0a27222e40aa1d17e"}],"is_playable":true,"name":"James Horner: Pas de Deux","release_date":"2015-05-04","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:76fwH1XZ2tC53fCMKSkQRF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/670EXb4x6t2MAvRvqCixyx"},"href":"https://api.spotify.com/v1/artists/670EXb4x6t2MAvRvqCixyx","id":"670EXb4x6t2MAvRvqCixyx","name":"Mari Samuelsen","type":"artist","uri":"spotify:artist:670EXb4x6t2MAvRvqCixyx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0PveFynDT0XrxSZFPnm40C"},"href":"https://api.spotify.com/v1/artists/0PveFynDT0XrxSZFPnm40C","id":"0PveFynDT0XrxSZFPnm40C","name":"Hakon Samuelsen","type":"artist","uri":"spotify:artist:0PveFynDT0XrxSZFPnm40C"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6I6fmQU7HGrUsCm4B5Nlk3"},"href":"https://api.spotify.com/v1/artists/6I6fmQU7HGrUsCm4B5Nlk3","id":"6I6fmQU7HGrUsCm4B5Nlk3","name":"Royal Liverpool Philharmonic Orchestra","type":"artist","uri":"spotify:artist:6I6fmQU7HGrUsCm4B5Nlk3"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3sz82fjwBXhH7AWlkIA4qS"},"href":"https://api.spotify.com/v1/artists/3sz82fjwBXhH7AWlkIA4qS","id":"3sz82fjwBXhH7AWlkIA4qS","name":"Clark Rundell","type":"artist","uri":"spotify:artist:3sz82fjwBXhH7AWlkIA4qS"}],"disc_number":1,"duration_ms":421797,"explicit":false,"external_ids":{"isrc":"GBUM71501026"},"external_urls":{"spotify":"https://open.spotify.com/track/1zjrsrwHc6AhCeGSI0wzKx"},"href":"https://api.spotify.com/v1/tracks/1zjrsrwHc6AhCeGSI0wzKx","id":"1zjrsrwHc6AhCeGSI0wzKx","is_local":false,"is_playable":true,"name":"Divenire","track_number":6,"type":"track","uri":"spotify:track:1zjrsrwHc6AhCeGSI0wzKx"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/1lpEBD9vIdVI20168grGLq"},"href":"https://api.spotify.com/v1/albums/1lpEBD9vIdVI20168grGLq","id":"1lpEBD9vIdVI20168grGLq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734322168060123f68148f318e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024322168060123f68148f318e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514322168060123f68148f318e"}],"is_playable":true,"name":"Live In Berlin","release_date":"2008-03-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1lpEBD9vIdVI20168grGLq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"disc_number":1,"duration_ms":434720,"explicit":false,"external_ids":{"isrc":"ITB280800002"},"external_urls":{"spotify":"https://open.spotify.com/track/2cRpF2ijQVn7OooKLozYU5"},"href":"https://api.spotify.com/v1/tracks/2cRpF2ijQVn7OooKLozYU5","id":"2cRpF2ijQVn7OooKLozYU5","is_local":false,"is_playable":true,"name":"Divenire - Live","track_number":3,"type":"track","uri":"spotify:track:2cRpF2ijQVn7OooKLozYU5"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Evwg6qRqIUgGDTs82Gbea"},"href":"https://api.spotify.com/v1/albums/0Evwg6qRqIUgGDTs82Gbea","id":"0Evwg6qRqIUgGDTs82Gbea","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bf7254d4f118eda7361fc28f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bf7254d4f118eda7361fc28f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bf7254d4f118eda7361fc28f"}],"is_playable":true,"name":"Islands - Essential Einaudi (Deluxe Version)","release_date":"2011-01-01","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:0Evwg6qRqIUgGDTs82Gbea"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"disc_number":1,"duration_ms":402156,"explicit":false,"external_ids":{"isrc":"ITB280600002"},"external_urls":{"spotify":"https://open.spotify.com/track/6FgxHfKSMUiMA6Tlhmdmrh"},"href":"https://api.spotify.com/v1/tracks/6FgxHfKSMUiMA6Tlhmdmrh","id":"6FgxHfKSMUiMA6Tlhmdmrh","is_local":false,"is_playable":true,"name":"Divenire","track_number":5,"type":"track","uri":"spotify:track:6FgxHfKSMUiMA6Tlhmdmrh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/0VZo00CZ7kv8GH7fUzSqTr"},"href":"https://api.spotify.com/v1/albums/0VZo00CZ7kv8GH7fUzSqTr","id":"0VZo00CZ7kv8GH7fUzSqTr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c956134d6d38031a5f15d1ec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c956134d6d38031a5f15d1ec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c956134d6d38031a5f15d1ec"}],"is_playable":true,"name":"Experience","release_date":"2024-09-21","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0VZo00CZ7kv8GH7fUzSqTr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6c3mMiMnHQtu4mGWN87CFx"},"href":"https://api.spotify.com/v1/artists/6c3mMiMnHQtu4mGWN87CFx","id":"6c3mMiMnHQtu4mGWN87CFx","name":"Robert Ziegler","type":"artist","uri":"spotify:artist:6c3mMiMnHQtu4mGWN87CFx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0MvSBMGRQJY3mRwIbJsqF1"},"href":"https://api.spotify.com/v1/artists/0MvSBMGRQJY3mRwIbJsqF1","id":"0MvSBMGRQJY3mRwIbJsqF1","name":"Royal Philharmonic Orchestra","type":"artist","uri":"spotify:artist:0MvSBMGRQJY3mRwIbJsqF1"}],"disc_number":1,"duration_ms":402240,"explicit":false,"external_ids":{"isrc":"ITB280600002"},"external_urls":{"spotify":"https://open.spotify.com/track/6gB9jOOorKEqqPdF57IL08"},"href":"https://api.spotify.com/v1/tracks/6gB9jOOorKEqqPdF57IL08","id":"6gB9jOOorKEqqPdF57IL08","is_local":false,"is_playable":true,"name":"Divenire","track_number":3,"type":"track","uri":"spotify:track:6gB9jOOorKEqqPdF57IL08"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/5SabDF53NWopX6Z9CB4qqF"},"href":"https://api.spotify.com/v1/albums/5SabDF53NWopX6Z9CB4qqF","id":"5SabDF53NWopX6Z9CB4qqF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736648c128d2d740f673bd0947"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026648c128d2d740f673bd0947"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516648c128d2d740f673bd0947"}],"is_playable":true,"name":"Velvet Road","release_date":"2023-09-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:5SabDF53NWopX6Z9CB4qqF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2uFUBdaVGtyMqckSeCl0Qj"},"href":"https://api.spotify.com/v1/artists/2uFUBdaVGtyMqckSeCl0Qj","id":"2uFUBdaVGtyMqckSeCl0Qj","name":"Ludovico Einaudi","type":"artist","uri":"spotify:artist:2uFUBdaVGtyMqckSeCl0Qj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1rwDpyhfCIGcutXf9kmLkY"},"href":"https://api.spotify.com/v1/artists/1rwDpyhfCIGcutXf9kmLkY","id":"1rwDpyhfCIGcutXf9kmLkY","name":"Mercan Dede","type":"artist","uri":"spotify:artist:1rwDpyhfCIGcutXf9kmLkY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7lHiOFpepHokhLTy6PNAL9"},"href":"https://api.spotify.com/v1/artists/7lHiOFpepHokhLTy6PNAL9","id":"7lHiOFpepHokhLTy6PNAL9","name":"Kora (CA)","type":"artist","uri":"spotify:artist:7lHiOFpepHokhLTy6PNAL9"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3rUklV20Ft3YvJPETNw3aC"},"href":"https://api.spotify.com/v1/artists/3rUklV20Ft3YvJPETNw3aC","id":"3rUklV20Ft3YvJPETNw3aC","name":"Alp Akmaz","type":"artist","uri":"spotify:artist:3rUklV20Ft3YvJPETNw3aC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6c3mMiMnHQtu4mGWN87CFx"},"href":"https://api.spotify.com/v1/artists/6c3mMiMnHQtu4mGWN87CFx","id":"6c3mMiMnHQtu4mGWN87CFx","name":"Robert Ziegler","type":"artist","uri":"spotify:artist:6c3mMiMnHQtu4mGWN87CFx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6I6fmQU7HGrUsCm4B5Nlk3"},"href":"https://api.spotify.com/v1/artists/6I6fmQU7HGrUsCm4B5Nlk3","id":"6I6fmQU7HGrUsCm4B5Nlk3","name":"Royal Liverpool Philharmonic Orchestra","type":"artist","uri":"spotify:artist:6I6fmQU7HGrUsCm4B5Nlk3"}],"disc_number":1,"duration_ms":438285,"explicit":false,"external_ids":{"isrc":"ITB282200001"},"external_urls":{"spotify":"https://open.spotify.com/track/5FtMdnN8MuhM9dI7YgSvTu"},"href":"https://api.spotify.com/v1/tracks/5FtMdnN8MuhM9dI7YgSvTu","id":"5FtMdnN8MuhM9dI7YgSvTu","is_local":false,"is_playable":true,"name":"Divenire - Reimagined by Mercan Dede & Kora","track_number":4,"type":"track","uri":"spotify:track:5FtMdnN8MuhM9dI7YgSvTu"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRpdmVuaXJlJTIyJTIwYXJ0aXN0JTNBJTIyTHVkb3ZpY28lMjBFaW5hdWRpJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo5LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJpZCI6IjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJuYW1lIjoiTHVkb3ZpY28gRWluYXVkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkVoRmVpV3NUZGZxemRGc2tWVXhCZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJFaEZlaVdzVGRmcXpkRnNrVlV4QmciLCJpZCI6IjJFaEZlaVdzVGRmcXpkRnNrVlV4QmciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2ku", + "c2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjU4YzJkMjgwZWRjYjY5MzFhMTA4ZmJkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY1OGMyZDI4MGVkY2I2OTMxYTEwOGZiZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjU4YzJkMjgwZWRjYjY5MzFhMTA4ZmJkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpdmVuaXJlIChEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MkVoRmVpV3NUZGZxemRGc2tWVXhCZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsImlkIjoiMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsIm5hbWUiOiJMdWRvdmljbyBFaW5hdWRpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmMzbU1pTW5IUXR1NG1HV044N0NGeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82YzNtTWlNbkhRdHU0bUdXTjg3Q0Z4IiwiaWQiOiI2YzNtTWlNbkhRdHU0bUdXTjg3Q0Z4IiwibmFtZSI6IlJvYmVydCBaaWVnbGVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZjM21NaU1uSFF0dTRtR1dOODdDRngifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvME12U0JNR1JRSlkzbVJ3SWJKc3FGMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTXZTQk1HUlFKWTNtUndJYkpzcUYxIiwiaWQiOiIwTXZTQk1HUlFKWTNtUndJYkpzcUYxIiwibmFtZSI6IlJveWFsIFBoaWxoYXJtb25pYyBPcmNoZXN0cmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6ME12U0JNR1JRSlkzbVJ3SWJKc3FGMSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MDIyNDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJJVEIyODA2MDAwMDIifQ==", + "LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNktwTzRuZURYeEdkaUVnc2l2WmllWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZLcE80bmVEWHhHZGlFZ3NpdlppZVkiLCJpZCI6IjZLcE80bmVEWHhHZGlFZ3NpdlppZVkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGl2ZW5pcmUiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NktwTzRuZURYeEdkaUVnc2l2WmllWSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJpZCI6IjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJuYW1lIjoiTHVkb3ZpY28gRWluYXVkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN2sxS2k1cFlpbkdNM2xNRTJUdjNBTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdrMUtpNXBZaW5HTTNsTUUyVHYzQU0iLCJpZCI6IjdrMUtpNXBZaW5HTTNsTUUyVHYzQU0iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWQ3MDZkMzNlOTc1ZGZhMTA3ZTExYjFlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjlkNzA2ZDMzZTk3NWRmYTEwN2UxMWIxZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWQ3MDZkMzNlOTc1ZGZhMTA3ZTExYjFlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IklzbGFuZHMgLSBFc3NlbnRpYWwgRWluYXVkaSIsInJlbGVhc2VfZGF0ZSI6IjIwMTEtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3azFLaTVwWWluR00zbE1FMlR2M0FNIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5Lg==", + "Y29tL2FydGlzdC8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJpZCI6IjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJuYW1lIjoiTHVkb3ZpY28gRWluYXVkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQwMjQ2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IklUQjI4MDYwMDAwMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM3V1WElUUmYwbzlXQXBFVElNeWpoaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzN1dVhJVFJmMG85V0FwRVRJTXlqaGoiLCJpZCI6IjN1dVhJVFJmMG85V0FwRVRJTXlqaGoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGl2ZW5pcmUiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M3V1WElUUmYwbzlXQXBFVElNeWpoaiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJpZCI6IjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJuYW1lIjoiTHVkb3ZpY28gRWluYXVkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNHhGTm8yT1dEUjh3RW01STJkUmRTNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzR4Rk5vMk9XRFI4d0VtNUkyZFJkUzciLCJpZCI6IjR4Rk5vMk9XRFI4d0VtNUkyZFJkUzciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjMwNzBhYzU0NWYzYzZjNDEwNmNlOTE2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmYzMDcwYWM1NDVmM2M2YzQxMDZjZTkxNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbg==", + "LmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmMzA3MGFjNTQ1ZjNjNmM0MTA2Y2U5MTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGl2ZW5pcmUiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTEwLTIzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NHhGTm8yT1dEUjh3RW01STJkUmRTNyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsImlkIjoiMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsIm5hbWUiOiJMdWRvdmljbyBFaW5hdWRpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmMzbU1pTW5IUXR1NG1HV044N0NGeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82YzNtTWlNbkhRdHU0bUdXTjg3Q0Z4IiwiaWQiOiI2YzNtTWlNbkhRdHU0bUdXTjg3Q0Z4IiwibmFtZSI6IlJvYmVydCBaaWVnbGVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZjM21NaU1uSFF0dTRtR1dOODdDRngifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvME12U0JNR1JRSlkzbVJ3SWJKc3FGMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTXZTQk1HUlFKWTNtUndJYkpzcUYxIiwiaWQiOiIwTXZTQk1HUlFKWTNtUndJYkpzcUYxIiwibmFtZSI6IlJveWFsIFBoaWxoYXJtb25pYyBPcmNoZXN0cmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6ME12U0JNR1JRSlkzbVJ3SWJKc3FGMSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MDIyNDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJJVEIyODA2MDAwMDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzM5SDliUEN6azZ3b3d5bEVHZ0RDTkMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zOUg5YlBDems2d293eWxFR2dEQ05DIiwiaWQiOiIzOUg5YlBDems2d293eWxFR2dEQ05DIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibg==", + "YW1lIjoiRGl2ZW5pcmUiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MzlIOWJQQ3prNndvd3lsRUdnRENOQyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJpZCI6IjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJuYW1lIjoiTHVkb3ZpY28gRWluYXVkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkhyamRaQmVzZW5JWTNKSmpsZFFGMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZIcmpkWkJlc2VuSVkzSkpqbGRRRjMiLCJpZCI6IjZIcmpkWkJlc2VuSVkzSkpqbGRRRjMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWYyODViOTM0ZTZlZTQwM2NlODZmNzQ1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjlmMjg1YjkzNGU2ZWU0MDNjZTg2Zjc0NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWYyODViOTM0ZTZlZTQwM2NlODZmNzQ1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBSb3lhbCBBbGJlcnQgSGFsbCBDb25jZXJ0IiwicmVsZWFzZV9kYXRlIjoiMjAxMC0wOS0yOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZIcmpkWkJlc2VuSVkzSkpqbGRRRjMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJpZCI6IjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJuYW1lIjoiTHVkb3ZpY28gRWluYXVkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn1dLA==", + "ImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NTQ3NzIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiSVRCMjgxMDAwMDMzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yNkNyTGlWN0RSaWJaR0FjWDM5NHNuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMjZDckxpVjdEUmliWkdBY1gzOTRzbiIsImlkIjoiMjZDckxpVjdEUmliWkdBY1gzOTRzbiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaXZlbmlyZSAtIExpdmUiLCJ0cmFja19udW1iZXIiOjE3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjI2Q3JMaVY3RFJpYlpHQWNYMzk0c24ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNjcwRVhiNHg2dDJNQXZSdnFDaXh5eCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82NzBFWGI0eDZ0Mk1BdlJ2cUNpeHl4IiwiaWQiOiI2NzBFWGI0eDZ0Mk1BdlJ2cUNpeHl4IiwibmFtZSI6Ik1hcmkgU2FtdWVsc2VuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjY3MEVYYjR4NnQyTUF2UnZxQ2l4eXgifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFB2ZUZ5bkRUMFhyeFNaRlBubTQwQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUHZlRnluRFQwWHJ4U1pGUG5tNDBDIiwiaWQiOiIwUHZlRnluRFQwWHJ4U1pGUG5tNDBDIiwibmFtZSI6Ikhha29uIFNhbXVlbHNlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUHZlRnluRFQwWHJ4U1pGUG5tNDBDIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzZmd0gxWFoydEM1M2ZDTUtTa1FSRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc2ZndIMVhaMnRDNTNmQ01LU2tRUkYiLCJpZCI6Ijc2ZndIMVhaMnRDNTNmQ01LU2tRUkYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNWQ4Nzg2YTBhMjcyMjJlNDBhYTFkMTdlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjVkODc4NmEwYTI3MjIyZTQwYQ==", + "YTFkMTdlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1ZDg3ODZhMGEyNzIyMmU0MGFhMWQxN2UifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSmFtZXMgSG9ybmVyOiBQYXMgZGUgRGV1eCIsInJlbGVhc2VfZGF0ZSI6IjIwMTUtMDUtMDQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc2ZndIMVhaMnRDNTNmQ01LU2tRUkYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJpZCI6IjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJuYW1lIjoiTHVkb3ZpY28gRWluYXVkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY3MEVYYjR4NnQyTUF2UnZxQ2l4eXgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjcwRVhiNHg2dDJNQXZSdnFDaXh5eCIsImlkIjoiNjcwRVhiNHg2dDJNQXZSdnFDaXh5eCIsIm5hbWUiOiJNYXJpIFNhbXVlbHNlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2NzBFWGI0eDZ0Mk1BdlJ2cUNpeHl4In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBQdmVGeW5EVDBYcnhTWkZQbm00MEMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFB2ZUZ5bkRUMFhyeFNaRlBubTQwQyIsImlkIjoiMFB2ZUZ5bkRUMFhyeFNaRlBubTQwQyIsIm5hbWUiOiJIYWtvbiBTYW11ZWxzZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFB2ZUZ5bkRUMFhyeFNaRlBubTQwQyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82STZmbVFVN0hHclVzQ200QjVObGszIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZJNmZtUVU3SEdyVXNDbTRCNU5sazMiLCJpZCI6IjZJNmZtUVU3SEdyVXNDbTRCNU5sazMiLCJuYW1lIjoiUm95YWwgTGl2ZXJwb29sIFBoaWxoYXJtb25pYyBPcmNoZXN0cmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoicw==", + "cG90aWZ5OmFydGlzdDo2STZmbVFVN0hHclVzQ200QjVObGszIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNzejgyZmp3QlhoSDdBV2xrSUE0cVMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3N6ODJmandCWGhIN0FXbGtJQTRxUyIsImlkIjoiM3N6ODJmandCWGhIN0FXbGtJQTRxUyIsIm5hbWUiOiJDbGFyayBSdW5kZWxsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNzejgyZmp3QlhoSDdBV2xrSUE0cVMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDIxNzk3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JVTTcxNTAxMDI2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xempyc3J3SGM2QWhDZUdTSTB3ekt4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMXpqcnNyd0hjNkFoQ2VHU0kwd3pLeCIsImlkIjoiMXpqcnNyd0hjNkFoQ2VHU0kwd3pLeCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaXZlbmlyZSIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxempyc3J3SGM2QWhDZUdTSTB3ekt4In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsImlkIjoiMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsIm5hbWUiOiJMdWRvdmljbyBFaW5hdWRpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xbHBFQkQ5dklkVkkyMDE2OGdyR0xxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWxwRUJEOXZJZFZJMjAxNjhnckdMcSIsImlkIjoiMWxwRUJEOXZJZFZJMjAxNjhnckdMcSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0MzIyMTY4MDYwMTIzZjY4MTQ4ZjMxOGUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYg==", + "Njc2MTZkMDAwMDFlMDI0MzIyMTY4MDYwMTIzZjY4MTQ4ZjMxOGUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQzMjIxNjgwNjAxMjNmNjgxNDhmMzE4ZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMaXZlIEluIEJlcmxpbiIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMDMtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxbHBFQkQ5dklkVkkyMDE2OGdyR0xxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIiwiaWQiOiIydUZVQmRhVkd0eU1xY2tTZUNsMFFqIiwibmFtZSI6Ikx1ZG92aWNvIEVpbmF1ZGkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MnVGVUJkYVZHdHlNcWNrU2VDbDBRaiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MzQ3MjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJJVEIyODA4MDAwMDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJjUnBGMmlqUVZuN09vb0tMb3pZVTUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yY1JwRjJpalFWbjdPb29LTG96WVU1IiwiaWQiOiIyY1JwRjJpalFWbjdPb29LTG96WVU1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpdmVuaXJlIC0gTGl2ZSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyY1JwRjJpalFWbjdPb29LTG96WVU1In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsImlkIjoiMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsIm5hbWUiOiJMdWRvdmljbyBFaW5hdWRpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbg==", + "LnNwb3RpZnkuY29tL2FsYnVtLzBFdndnNnFScUlVZ0dEVHM4MkdiZWEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wRXZ3ZzZxUnFJVWdHRFRzODJHYmVhIiwiaWQiOiIwRXZ3ZzZxUnFJVWdHRFRzODJHYmVhIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2JmNzI1NGQ0ZjExOGVkYTczNjFmYzI4ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiZjcyNTRkNGYxMThlZGE3MzYxZmMyOGYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWJmNzI1NGQ0ZjExOGVkYTczNjFmYzI4ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJc2xhbmRzIC0gRXNzZW50aWFsIEVpbmF1ZGkgKERlbHV4ZSBWZXJzaW9uKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTEtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowRXZ3ZzZxUnFJVWdHRFRzODJHYmVhIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIiwiaWQiOiIydUZVQmRhVkd0eU1xY2tTZUNsMFFqIiwibmFtZSI6Ikx1ZG92aWNvIEVpbmF1ZGkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MnVGVUJkYVZHdHlNcWNrU2VDbDBRaiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MDIxNTYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJJVEIyODA2MDAwMDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZGZ3hIZktTTVVpTUE2VGxobWRtcmgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82Rmd4SGZLU01VaU1BNlRsaG1kbXJoIiwiaWQiOiI2Rmd4SGZLU01VaU1BNlRsaG1kbXJoIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpdmVuaXJlIiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZGZ3hIZktTTVVpTUE2VGxobWRtcmgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waQ==", + "bGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJpZCI6IjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJuYW1lIjoiTHVkb3ZpY28gRWluYXVkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMFZabzAwQ1o3a3Y4R0g3ZlV6U3FUciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBWWm8wMENaN2t2OEdIN2ZVelNxVHIiLCJpZCI6IjBWWm8wMENaN2t2OEdIN2ZVelNxVHIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzk1NjEzNGQ2ZDM4MDMxYTVmMTVkMWVjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM5NTYxMzRkNmQzODAzMWE1ZjE1ZDFlYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzk1NjEzNGQ2ZDM4MDMxYTVmMTVkMWVjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkV4cGVyaWVuY2UiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTA5LTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNw", + "b3RpZnk6YWxidW06MFZabzAwQ1o3a3Y4R0g3ZlV6U3FUciJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsImlkIjoiMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsIm5hbWUiOiJMdWRvdmljbyBFaW5hdWRpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmMzbU1pTW5IUXR1NG1HV044N0NGeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82YzNtTWlNbkhRdHU0bUdXTjg3Q0Z4IiwiaWQiOiI2YzNtTWlNbkhRdHU0bUdXTjg3Q0Z4IiwibmFtZSI6IlJvYmVydCBaaWVnbGVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZjM21NaU1uSFF0dTRtR1dOODdDRngifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvME12U0JNR1JRSlkzbVJ3SWJKc3FGMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTXZTQk1HUlFKWTNtUndJYkpzcUYxIiwiaWQiOiIwTXZTQk1HUlFKWTNtUndJYkpzcUYxIiwibmFtZSI6IlJveWFsIFBoaWxoYXJtb25pYyBPcmNoZXN0cmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6ME12U0JNR1JRSlkzbVJ3SWJKc3FGMSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0MDIyNDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJJVEIyODA2MDAwMDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZnQjlqT09vcktFcXFQZEY1N0lMMDgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82Z0I5ak9Pb3JLRXFxUGRGNTdJTDA4IiwiaWQiOiI2Z0I5ak9Pb3JLRXFxUGRGNTdJTDA4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpdmVuaXJlIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZnQjlqT09vcktFcXFQZEY1N0lMMDgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcg==", + "dGlzdC8ydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJpZCI6IjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoiLCJuYW1lIjoiTHVkb3ZpY28gRWluYXVkaSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoydUZVQmRhVkd0eU1xY2tTZUNsMFFqIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVNhYkRGNTNOV29wWDZaOUNCNHFxRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVTYWJERjUzTldvcFg2WjlDQjRxcUYiLCJpZCI6IjVTYWJERjUzTldvcFg2WjlDQjRxcUYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNjY0OGMxMjhkMmQ3NDBmNjczYmQwOTQ3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjY2NDhjMTI4ZDJkNzQwZjY3M2JkMDk0NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjY0OGMxMjhkMmQ3NDBmNjczYmQwOTQ3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZlbHZldCBSb2FkIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wOS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVNhYkRGNTNOV29wWDZaOUNCNHFxRiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsImlkIjoiMnVGVUJkYVZHdHlNcWNrU2VDbDBRaiIsIm5hbWUiOiJMdWRvdmljbyBFaW5hdWRpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJ1RlVCZGFWR3R5TXFja1NlQ2wwUWoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXJ3RHB5aGZDSUdjdXRYZjlrbUxrWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xcndEcHloZkNJR2N1dFhmOWttTGtZIiwiaWQiOiIxcndEcHloZkNJR2N1dFhmOWttTGtZIiwibmFtZSI6Ik1lcmNhbiBEZWRlIiwidHlwZSI6Ig==", + "YXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXJ3RHB5aGZDSUdjdXRYZjlrbUxrWSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83bEhpT0ZwZXBIb2toTFR5NlBOQUw5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdsSGlPRnBlcEhva2hMVHk2UE5BTDkiLCJpZCI6IjdsSGlPRnBlcEhva2hMVHk2UE5BTDkiLCJuYW1lIjoiS29yYSAoQ0EpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdsSGlPRnBlcEhva2hMVHk2UE5BTDkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3JVa2xWMjBGdDNZdkpQRVROdzNhQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zclVrbFYyMEZ0M1l2SlBFVE53M2FDIiwiaWQiOiIzclVrbFYyMEZ0M1l2SlBFVE53M2FDIiwibmFtZSI6IkFscCBBa21heiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozclVrbFYyMEZ0M1l2SlBFVE53M2FDIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZjM21NaU1uSFF0dTRtR1dOODdDRngifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmMzbU1pTW5IUXR1NG1HV044N0NGeCIsImlkIjoiNmMzbU1pTW5IUXR1NG1HV044N0NGeCIsIm5hbWUiOiJSb2JlcnQgWmllZ2xlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2YzNtTWlNbkhRdHU0bUdXTjg3Q0Z4In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZJNmZtUVU3SEdyVXNDbTRCNU5sazMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkk2Zm1RVTdIR3JVc0NtNEI1TmxrMyIsImlkIjoiNkk2Zm1RVTdIR3JVc0NtNEI1TmxrMyIsIm5hbWUiOiJSb3lhbCBMaXZlcnBvb2wgUGhpbGhhcm1vbmljIE9yY2hlc3RyYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2STZmbVFVN0hHclVzQ200QjVObGszIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQzODI4NSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IklUQjI4MjIwMDAwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNUZ0TWRuTjhNdWhNOWRJN1lnU3ZUdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVGdE1kbk44TQ==", + "dWhNOWRJN1lnU3ZUdSIsImlkIjoiNUZ0TWRuTjhNdWhNOWRJN1lnU3ZUdSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaXZlbmlyZSAtIFJlaW1hZ2luZWQgYnkgTWVyY2FuIERlZGUgJiBLb3JhIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVGdE1kbk44TXVoTTlkSTdZZ1N2VHUifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Divenire%22+artist%3A%22Ludovico+Einaudi%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Midnight%20City%22%20artist%3A%22M83%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6EB14IXV5oyOiItGBv7mtG"},"href":"https://api.spotify.com/v1/albums/6EB14IXV5oyOiItGBv7mtG","id":"6EB14IXV5oyOiItGBv7mtG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27362100064780b1d919a95fcf4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0262100064780b1d919a95fcf4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485162100064780b1d919a95fcf4"}],"is_playable":true,"name":"Hurry up, We're Dreaming","release_date":"2011-10-17","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6EB14IXV5oyOiItGBv7mtG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":243960,"explicit":false,"external_ids":{"isrc":"GB55H1100002"},"external_urls":{"spotify":"https://open.spotify.com/track/6GyFP1nfCDB8lbD2bG0Hq9"},"href":"https://api.spotify.com/v1/tracks/6GyFP1nfCDB8lbD2bG0Hq9","id":"6GyFP1nfCDB8lbD2bG0Hq9","is_local":false,"is_playable":true,"name":"Midnight City","track_number":2,"type":"track","uri":"spotify:track:6GyFP1nfCDB8lbD2bG0Hq9"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5sm0jQ1mq0dusiLtDJ2b4R"},"href":"https://api.spotify.com/v1/artists/5sm0jQ1mq0dusiLtDJ2b4R","id":"5sm0jQ1mq0dusiLtDJ2b4R","name":"Eric Prydz","type":"artist","uri":"spotify:artist:5sm0jQ1mq0dusiLtDJ2b4R"}],"external_urls":{"spotify":"https://open.spotify.com/album/7lOidIGDpO6imOl4zDGQ9p"},"href":"https://api.spotify.com/v1/albums/7lOidIGDpO6imOl4zDGQ9p","id":"7lOidIGDpO6imOl4zDGQ9p","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732e119106a5e213ea4f34e12d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022e119106a5e213ea4f34e12d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512e119106a5e213ea4f34e12d"}],"is_playable":true,"name":"Midnight City (Eric Prydz Private Remix)","release_date":"2012-02-24","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7lOidIGDpO6imOl4zDGQ9p"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5sm0jQ1mq0dusiLtDJ2b4R"},"href":"https://api.spotify.com/v1/artists/5sm0jQ1mq0dusiLtDJ2b4R","id":"5sm0jQ1mq0dusiLtDJ2b4R","name":"Eric Prydz","type":"artist","uri":"spotify:artist:5sm0jQ1mq0dusiLtDJ2b4R"}],"disc_number":1,"duration_ms":361740,"explicit":false,"external_ids":{"isrc":"GB55H1200001"},"external_urls":{"spotify":"https://open.spotify.com/track/0FoSiffuAmaJ3VyPaebY6I"},"href":"https://api.spotify.com/v1/tracks/0FoSiffuAmaJ3VyPaebY6I","id":"0FoSiffuAmaJ3VyPaebY6I","is_local":false,"is_playable":true,"name":"Midnight City - Eric Prydz Private Remix","track_number":1,"type":"track","uri":"spotify:track:0FoSiffuAmaJ3VyPaebY6I"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":243960,"explicit":false,"external_ids":{"isrc":"GB55H1100002"},"external_urls":{"spotify":"https://open.spotify.com/track/3qskhJwO5DsJzHO5n39TXj"},"href":"https://api.spotify.com/v1/tracks/3qskhJwO5DsJzHO5n39TXj","id":"3qskhJwO5DsJzHO5n39TXj","is_local":false,"is_playable":true,"name":"Midnight City","track_number":1,"type":"track","uri":"spotify:track:3qskhJwO5DsJzHO5n39TXj"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":449142,"explicit":false,"external_ids":{"isrc":"GB55H1100025"},"external_urls":{"spotify":"https://open.spotify.com/track/6RUq6kyIQhQehUH4v2NZoh"},"href":"https://api.spotify.com/v1/tracks/6RUq6kyIQhQehUH4v2NZoh","id":"6RUq6kyIQhQehUH4v2NZoh","is_local":false,"is_playable":true,"name":"Midnight City - Trentemoller Remix","track_number":3,"type":"track","uri":"spotify:track:6RUq6kyIQhQehUH4v2NZoh"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":253245,"explicit":false,"external_ids":{"isrc":"GB55H1100026"},"external_urls":{"spotify":"https://open.spotify.com/track/2zfPIphC5ysSeCMpsw7ges"},"href":"https://api.spotify.com/v1/tracks/2zfPIphC5ysSeCMpsw7ges","id":"2zfPIphC5ysSeCMpsw7ges","is_local":false,"is_playable":true,"name":"Midnight City - Man Without Country Remix","track_number":4,"type":"track","uri":"spotify:track:2zfPIphC5ysSeCMpsw7ges"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1FsAT1PtUSxjopGkhUZPsU"},"href":"https://api.spotify.com/v1/artists/1FsAT1PtUSxjopGkhUZPsU","id":"1FsAT1PtUSxjopGkhUZPsU","name":"Gildas Kitsun\u00e9","type":"artist","uri":"spotify:artist:1FsAT1PtUSxjopGkhUZPsU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0odCQ1NOW9JfbEKDE2FaAb"},"href":"https://api.spotify.com/v1/artists/0odCQ1NOW9JfbEKDE2FaAb","id":"0odCQ1NOW9JfbEKDE2FaAb","name":"Jerry Bouthier","type":"artist","uri":"spotify:artist:0odCQ1NOW9JfbEKDE2FaAb"}],"external_urls":{"spotify":"https://open.spotify.com/album/1sws0UqJUdvOAgV9y2hlhT"},"href":"https://api.spotify.com/v1/albums/1sws0UqJUdvOAgV9y2hlhT","id":"1sws0UqJUdvOAgV9y2hlhT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273baca0656285d3852a5ba52e6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02baca0656285d3852a5ba52e6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851baca0656285d3852a5ba52e6"}],"is_playable":true,"name":"Gildas & Jerry Kitsun\u00e9 Soleil Mix","release_date":"2012-05-02","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:1sws0UqJUdvOAgV9y2hlhT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4O71i7ke5iIBX6RNSFoZbS"},"href":"https://api.spotify.com/v1/artists/4O71i7ke5iIBX6RNSFoZbS","id":"4O71i7ke5iIBX6RNSFoZbS","name":"trentem\u00f8ller","type":"artist","uri":"spotify:artist:4O71i7ke5iIBX6RNSFoZbS"}],"disc_number":1,"duration_ms":181416,"explicit":false,"external_ids":{"isrc":"GB55H1100025"},"external_urls":{"spotify":"https://open.spotify.com/track/3Mscm7k7xjAPxtl1FikYk5"},"href":"https://api.spotify.com/v1/tracks/3Mscm7k7xjAPxtl1FikYk5","id":"3Mscm7k7xjAPxtl1FikYk5","is_local":false,"is_playable":true,"name":"Midnight City (Trentem\u00f8ller Remix) - Mixed","track_number":20,"type":"track","uri":"spotify:track:3Mscm7k7xjAPxtl1FikYk5"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":220352,"explicit":false,"external_ids":{"isrc":"GB55H1100024"},"external_urls":{"spotify":"https://open.spotify.com/track/6LFSqdJyfET9T7nIUqF1Ng"},"href":"https://api.spotify.com/v1/tracks/6LFSqdJyfET9T7nIUqF1Ng","id":"6LFSqdJyfET9T7nIUqF1Ng","is_local":false,"is_playable":true,"name":"Midnight City - Big Black Delta Remix","track_number":2,"type":"track","uri":"spotify:track:6LFSqdJyfET9T7nIUqF1Ng"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":237737,"explicit":false,"external_ids":{"isrc":"GB55H1100027"},"external_urls":{"spotify":"https://open.spotify.com/track/3fHvbgyHSWoUJz65TPrh89"},"href":"https://api.spotify.com/v1/tracks/3fHvbgyHSWoUJz65TPrh89","id":"3fHvbgyHSWoUJz65TPrh89","is_local":false,"is_playable":true,"name":"Midnight City - Team Ghost Remix","track_number":5,"type":"track","uri":"spotify:track:3fHvbgyHSWoUJz65TPrh89"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/00b3RKsk2pv5VWSnYAKW8u"},"href":"https://api.spotify.com/v1/artists/00b3RKsk2pv5VWSnYAKW8u","id":"00b3RKsk2pv5VWSnYAKW8u","name":"Man Without Country","type":"artist","uri":"spotify:artist:00b3RKsk2pv5VWSnYAKW8u"}],"external_urls":{"spotify":"https://open.spotify.com/album/4vyjxqF7CGOElPEgKMIFWH"},"href":"https://api.spotify.com/v1/albums/4vyjxqF7CGOElPEgKMIFWH","id":"4vyjxqF7CGOElPEgKMIFWH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736d2a3abad7d3d0a8f6f61b95"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026d2a3abad7d3d0a8f6f61b95"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516d2a3abad7d3d0a8f6f61b95"}],"is_playable":true,"name":"RMX: Remixes by Man Without Country","release_date":"2013-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:4vyjxqF7CGOElPEgKMIFWH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":253245,"explicit":false,"external_ids":{"isrc":"GB55H1100026"},"external_urls":{"spotify":"https://open.spotify.com/track/4cewwFTigK24kSwbV7GS2C"},"href":"https://api.spotify.com/v1/tracks/4cewwFTigK24kSwbV7GS2C","id":"4cewwFTigK24kSwbV7GS2C","is_local":false,"is_playable":true,"name":"Midnight City - Man Without Country Remix","track_number":11,"type":"track","uri":"spotify:track:4cewwFTigK24kSwbV7GS2C"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Midnight%20City%22%20artist%3A%22M83%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6EB14IXV5oyOiItGBv7mtG"},"href":"https://api.spotify.com/v1/albums/6EB14IXV5oyOiItGBv7mtG","id":"6EB14IXV5oyOiItGBv7mtG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27362100064780b1d919a95fcf4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0262100064780b1d919a95fcf4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485162100064780b1d919a95fcf4"}],"is_playable":true,"name":"Hurry up, We're Dreaming","release_date":"2011-10-17","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:6EB14IXV5oyOiItGBv7mtG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":243960,"explicit":false,"external_ids":{"isrc":"GB55H1100002"},"external_urls":{"spotify":"https://open.spotify.com/track/6GyFP1nfCDB8lbD2bG0Hq9"},"href":"https://api.spotify.com/v1/tracks/6GyFP1nfCDB8lbD2bG0Hq9","id":"6GyFP1nfCDB8lbD2bG0Hq9","is_local":false,"is_playable":true,"name":"Midnight City","track_number":2,"type":"track","uri":"spotify:track:6GyFP1nfCDB8lbD2bG0Hq9"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5sm0jQ1mq0dusiLtDJ2b4R"},"href":"https://api.spotify.com/v1/artists/5sm0jQ1mq0dusiLtDJ2b4R","id":"5sm0jQ1mq0dusiLtDJ2b4R","name":"Eric Prydz","type":"artist","uri":"spotify:artist:5sm0jQ1mq0dusiLtDJ2b4R"}],"external_urls":{"spotify":"https://open.spotify.com/album/7lOidIGDpO6imOl4zDGQ9p"},"href":"https://api.spotify.com/v1/albums/7lOidIGDpO6imOl4zDGQ9p","id":"7lOidIGDpO6imOl4zDGQ9p","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732e119106a5e213ea4f34e12d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022e119106a5e213ea4f34e12d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512e119106a5e213ea4f34e12d"}],"is_playable":true,"name":"Midnight City (Eric Prydz Private Remix)","release_date":"2012-02-24","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7lOidIGDpO6imOl4zDGQ9p"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5sm0jQ1mq0dusiLtDJ2b4R"},"href":"https://api.spotify.com/v1/artists/5sm0jQ1mq0dusiLtDJ2b4R","id":"5sm0jQ1mq0dusiLtDJ2b4R","name":"Eric Prydz","type":"artist","uri":"spotify:artist:5sm0jQ1mq0dusiLtDJ2b4R"}],"disc_number":1,"duration_ms":361740,"explicit":false,"external_ids":{"isrc":"GB55H1200001"},"external_urls":{"spotify":"https://open.spotify.com/track/0FoSiffuAmaJ3VyPaebY6I"},"href":"https://api.spotify.com/v1/tracks/0FoSiffuAmaJ3VyPaebY6I","id":"0FoSiffuAmaJ3VyPaebY6I","is_local":false,"is_playable":true,"name":"Midnight City - Eric Prydz Private Remix","track_number":1,"type":"track","uri":"spotify:track:0FoSiffuAmaJ3VyPaebY6I"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":243960,"explicit":false,"external_ids":{"isrc":"GB55H1100002"},"external_urls":{"spotify":"https://open.spotify.com/track/3qskhJwO5DsJzHO5n39TXj"},"href":"https://api.spotify.com/v1/tracks/3qskhJwO5DsJzHO5n39TXj","id":"3qskhJwO5DsJzHO5n39TXj","is_local":false,"is_playable":true,"name":"Midnight City","track_number":1,"type":"track","uri":"spotify:track:3qskhJwO5DsJzHO5n39TXj"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":449142,"explicit":false,"external_ids":{"isrc":"GB55H1100025"},"external_urls":{"spotify":"https://open.spotify.com/track/6RUq6kyIQhQehUH4v2NZoh"},"href":"https://api.spotify.com/v1/tracks/6RUq6kyIQhQehUH4v2NZoh","id":"6RUq6kyIQhQehUH4v2NZoh","is_local":false,"is_playable":true,"name":"Midnight City - Trentemoller Remix","track_number":3,"type":"track","uri":"spotify:track:6RUq6kyIQhQehUH4v2NZoh"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":253245,"explicit":false,"external_ids":{"isrc":"GB55H1100026"},"external_urls":{"spotify":"https://open.spotify.com/track/2zfPIphC5ysSeCMpsw7ges"},"href":"https://api.spotify.com/v1/tracks/2zfPIphC5ysSeCMpsw7ges","id":"2zfPIphC5ysSeCMpsw7ges","is_local":false,"is_playable":true,"name":"Midnight City - Man Without Country Remix","track_number":4,"type":"track","uri":"spotify:track:2zfPIphC5ysSeCMpsw7ges"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1FsAT1PtUSxjopGkhUZPsU"},"href":"https://api.spotify.com/v1/artists/1FsAT1PtUSxjopGkhUZPsU","id":"1FsAT1PtUSxjopGkhUZPsU","name":"Gildas Kitsun\u00e9","type":"artist","uri":"spotify:artist:1FsAT1PtUSxjopGkhUZPsU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0odCQ1NOW9JfbEKDE2FaAb"},"href":"https://api.spotify.com/v1/artists/0odCQ1NOW9JfbEKDE2FaAb","id":"0odCQ1NOW9JfbEKDE2FaAb","name":"Jerry Bouthier","type":"artist","uri":"spotify:artist:0odCQ1NOW9JfbEKDE2FaAb"}],"external_urls":{"spotify":"https://open.spotify.com/album/1sws0UqJUdvOAgV9y2hlhT"},"href":"https://api.spotify.com/v1/albums/1sws0UqJUdvOAgV9y2hlhT","id":"1sws0UqJUdvOAgV9y2hlhT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273baca0656285d3852a5ba52e6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02baca0656285d3852a5ba52e6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851baca0656285d3852a5ba52e6"}],"is_playable":true,"name":"Gildas & Jerry Kitsun\u00e9 Soleil Mix","release_date":"2012-05-02","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:1sws0UqJUdvOAgV9y2hlhT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4O71i7ke5iIBX6RNSFoZbS"},"href":"https://api.spotify.com/v1/artists/4O71i7ke5iIBX6RNSFoZbS","id":"4O71i7ke5iIBX6RNSFoZbS","name":"trentem\u00f8ller","type":"artist","uri":"spotify:artist:4O71i7ke5iIBX6RNSFoZbS"}],"disc_number":1,"duration_ms":181416,"explicit":false,"external_ids":{"isrc":"GB55H1100025"},"external_urls":{"spotify":"https://open.spotify.com/track/3Mscm7k7xjAPxtl1FikYk5"},"href":"https://api.spotify.com/v1/tracks/3Mscm7k7xjAPxtl1FikYk5","id":"3Mscm7k7xjAPxtl1FikYk5","is_local":false,"is_playable":true,"name":"Midnight City (Trentem\u00f8ller Remix) - Mixed","track_number":20,"type":"track","uri":"spotify:track:3Mscm7k7xjAPxtl1FikYk5"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":220352,"explicit":false,"external_ids":{"isrc":"GB55H1100024"},"external_urls":{"spotify":"https://open.spotify.com/track/6LFSqdJyfET9T7nIUqF1Ng"},"href":"https://api.spotify.com/v1/tracks/6LFSqdJyfET9T7nIUqF1Ng","id":"6LFSqdJyfET9T7nIUqF1Ng","is_local":false,"is_playable":true,"name":"Midnight City - Big Black Delta Remix","track_number":2,"type":"track","uri":"spotify:track:6LFSqdJyfET9T7nIUqF1Ng"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nN5b5w93prVcCpLex1xdZ"},"href":"https://api.spotify.com/v1/albums/6nN5b5w93prVcCpLex1xdZ","id":"6nN5b5w93prVcCpLex1xdZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27374436a2f31ed7a8dec173470"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0274436a2f31ed7a8dec173470"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485174436a2f31ed7a8dec173470"}],"is_playable":true,"name":"Midnight City","release_date":"2011-09-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6nN5b5w93prVcCpLex1xdZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":237737,"explicit":false,"external_ids":{"isrc":"GB55H1100027"},"external_urls":{"spotify":"https://open.spotify.com/track/3fHvbgyHSWoUJz65TPrh89"},"href":"https://api.spotify.com/v1/tracks/3fHvbgyHSWoUJz65TPrh89","id":"3fHvbgyHSWoUJz65TPrh89","is_local":false,"is_playable":true,"name":"Midnight City - Team Ghost Remix","track_number":5,"type":"track","uri":"spotify:track:3fHvbgyHSWoUJz65TPrh89"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/00b3RKsk2pv5VWSnYAKW8u"},"href":"https://api.spotify.com/v1/artists/00b3RKsk2pv5VWSnYAKW8u","id":"00b3RKsk2pv5VWSnYAKW8u","name":"Man Without Country","type":"artist","uri":"spotify:artist:00b3RKsk2pv5VWSnYAKW8u"}],"external_urls":{"spotify":"https://open.spotify.com/album/4vyjxqF7CGOElPEgKMIFWH"},"href":"https://api.spotify.com/v1/albums/4vyjxqF7CGOElPEgKMIFWH","id":"4vyjxqF7CGOElPEgKMIFWH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736d2a3abad7d3d0a8f6f61b95"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026d2a3abad7d3d0a8f6f61b95"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516d2a3abad7d3d0a8f6f61b95"}],"is_playable":true,"name":"RMX: Remixes by Man Without Country","release_date":"2013-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:4vyjxqF7CGOElPEgKMIFWH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/63MQldklfxkjYDoUE4Tppz"},"href":"https://api.spotify.com/v1/artists/63MQldklfxkjYDoUE4Tppz","id":"63MQldklfxkjYDoUE4Tppz","name":"M83","type":"artist","uri":"spotify:artist:63MQldklfxkjYDoUE4Tppz"}],"disc_number":1,"duration_ms":253245,"explicit":false,"external_ids":{"isrc":"GB55H1100026"},"external_urls":{"spotify":"https://open.spotify.com/track/4cewwFTigK24kSwbV7GS2C"},"href":"https://api.spotify.com/v1/tracks/4cewwFTigK24kSwbV7GS2C","id":"4cewwFTigK24kSwbV7GS2C","is_local":false,"is_playable":true,"name":"Midnight City - Man Without Country Remix","track_number":11,"type":"track","uri":"spotify:track:4cewwFTigK24kSwbV7GS2C"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Midnight+City%22+artist%3A%22M83%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22River%20Flows%20in%20You%22%20artist%3A%22Yiruma%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":5,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0fauHpmSHwodVYIjTqOGHz"},"href":"https://api.spotify.com/v1/artists/0fauHpmSHwodVYIjTqOGHz","id":"0fauHpmSHwodVYIjTqOGHz","name":"Yiruma","type":"artist","uri":"spotify:artist:0fauHpmSHwodVYIjTqOGHz"}],"external_urls":{"spotify":"https://open.spotify.com/album/1N6p8qmf8PJgYQdktQQYYh"},"href":"https://api.spotify.com/v1/albums/1N6p8qmf8PJgYQdktQQYYh","id":"1N6p8qmf8PJgYQdktQQYYh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734bdb66d1335f8571240e755f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024bdb66d1335f8571240e755f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514bdb66d1335f8571240e755f"}],"is_playable":true,"name":"First Love (The Original & the Very First Recording)","release_date":"2001-11-27","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:1N6p8qmf8PJgYQdktQQYYh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0fauHpmSHwodVYIjTqOGHz"},"href":"https://api.spotify.com/v1/artists/0fauHpmSHwodVYIjTqOGHz","id":"0fauHpmSHwodVYIjTqOGHz","name":"Yiruma","type":"artist","uri":"spotify:artist:0fauHpmSHwodVYIjTqOGHz"}],"disc_number":1,"duration_ms":188786,"explicit":false,"external_ids":{"isrc":"HKOA10616988"},"external_urls":{"spotify":"https://open.spotify.com/track/2agBDIr9MYDUducQPC1sFU"},"href":"https://api.spotify.com/v1/tracks/2agBDIr9MYDUducQPC1sFU","id":"2agBDIr9MYDUducQPC1sFU","is_local":false,"is_playable":true,"name":"River Flows In You","track_number":4,"type":"track","uri":"spotify:track:2agBDIr9MYDUducQPC1sFU"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0fauHpmSHwodVYIjTqOGHz"},"href":"https://api.spotify.com/v1/artists/0fauHpmSHwodVYIjTqOGHz","id":"0fauHpmSHwodVYIjTqOGHz","name":"Yiruma","type":"artist","uri":"spotify:artist:0fauHpmSHwodVYIjTqOGHz"}],"external_urls":{"spotify":"https://open.spotify.com/album/7dZ49XnPBaF4e6SMYmsNQ1"},"href":"https://api.spotify.com/v1/albums/7dZ49XnPBaF4e6SMYmsNQ1","id":"7dZ49XnPBaF4e6SMYmsNQ1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273753900acd464d31f3c7e6e4e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02753900acd464d31f3c7e6e4e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851753900acd464d31f3c7e6e4e"}],"is_playable":true,"name":"The Best - Reminiscent 10th Anniversary","release_date":"2011-12-09","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:7dZ49XnPBaF4e6SMYmsNQ1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0fauHpmSHwodVYIjTqOGHz"},"href":"https://api.spotify.com/v1/artists/0fauHpmSHwodVYIjTqOGHz","id":"0fauHpmSHwodVYIjTqOGHz","name":"Yiruma","type":"artist","uri":"spotify:artist:0fauHpmSHwodVYIjTqOGHz"}],"disc_number":1,"duration_ms":218293,"explicit":false,"external_ids":{"isrc":"KRA031103194"},"external_urls":{"spotify":"https://open.spotify.com/track/3xr8COed4nPPn6XWZ0iCGr"},"href":"https://api.spotify.com/v1/tracks/3xr8COed4nPPn6XWZ0iCGr","id":"3xr8COed4nPPn6XWZ0iCGr","is_local":false,"is_playable":true,"name":"River Flows in You","track_number":2,"type":"track","uri":"spotify:track:3xr8COed4nPPn6XWZ0iCGr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0fauHpmSHwodVYIjTqOGHz"},"href":"https://api.spotify.com/v1/artists/0fauHpmSHwodVYIjTqOGHz","id":"0fauHpmSHwodVYIjTqOGHz","name":"Yiruma","type":"artist","uri":"spotify:artist:0fauHpmSHwodVYIjTqOGHz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6B9JssCvQa6Z5RtcMQaK7n"},"href":"https://api.spotify.com/v1/albums/6B9JssCvQa6Z5RtcMQaK7n","id":"6B9JssCvQa6Z5RtcMQaK7n","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fdd44a56fa51f6b1519b9401"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fdd44a56fa51f6b1519b9401"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fdd44a56fa51f6b1519b9401"}],"is_playable":true,"name":"SOLO","release_date":"2021-09-24","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:6B9JssCvQa6Z5RtcMQaK7n"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0fauHpmSHwodVYIjTqOGHz"},"href":"https://api.spotify.com/v1/artists/0fauHpmSHwodVYIjTqOGHz","id":"0fauHpmSHwodVYIjTqOGHz","name":"Yiruma","type":"artist","uri":"spotify:artist:0fauHpmSHwodVYIjTqOGHz"}],"disc_number":1,"duration_ms":210562,"explicit":false,"external_ids":{"isrc":"KRUM72100079"},"external_urls":{"spotify":"https://open.spotify.com/track/3IEl5LLYsvTEQmnxMaxBQa"},"href":"https://api.spotify.com/v1/tracks/3IEl5LLYsvTEQmnxMaxBQa","id":"3IEl5LLYsvTEQmnxMaxBQa","is_local":false,"is_playable":true,"name":"River Flows In You","track_number":6,"type":"track","uri":"spotify:track:3IEl5LLYsvTEQmnxMaxBQa"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5QSJvIB7Mn1xQiTHfkvxjP"},"href":"https://api.spotify.com/v1/albums/5QSJvIB7Mn1xQiTHfkvxjP","id":"5QSJvIB7Mn1xQiTHfkvxjP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731a9d989530fdafb54a1d0290"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021a9d989530fdafb54a1d0290"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511a9d989530fdafb54a1d0290"}],"is_playable":true,"name":"Piano In You","release_date":"2011-06-02","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:5QSJvIB7Mn1xQiTHfkvxjP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0fauHpmSHwodVYIjTqOGHz"},"href":"https://api.spotify.com/v1/artists/0fauHpmSHwodVYIjTqOGHz","id":"0fauHpmSHwodVYIjTqOGHz","name":"Yiruma","type":"artist","uri":"spotify:artist:0fauHpmSHwodVYIjTqOGHz"}],"disc_number":2,"duration_ms":188240,"explicit":false,"external_ids":{"isrc":"USA371336157"},"external_urls":{"spotify":"https://open.spotify.com/track/13NC44aS3d0EFF58oVQ8T7"},"href":"https://api.spotify.com/v1/tracks/13NC44aS3d0EFF58oVQ8T7","id":"13NC44aS3d0EFF58oVQ8T7","is_local":false,"is_playable":true,"name":"River Flows In You","track_number":1,"type":"track","uri":"spotify:track:13NC44aS3d0EFF58oVQ8T7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0fauHpmSHwodVYIjTqOGHz"},"href":"https://api.spotify.com/v1/artists/0fauHpmSHwodVYIjTqOGHz","id":"0fauHpmSHwodVYIjTqOGHz","name":"Yiruma","type":"artist","uri":"spotify:artist:0fauHpmSHwodVYIjTqOGHz"}],"external_urls":{"spotify":"https://open.spotify.com/album/73YLmvCxBSzesjqxCOBAWS"},"href":"https://api.spotify.com/v1/albums/73YLmvCxBSzesjqxCOBAWS","id":"73YLmvCxBSzesjqxCOBAWS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f38431d036be50439043b08"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f38431d036be50439043b08"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f38431d036be50439043b08"}],"is_playable":true,"name":"The Rewritten Memories","release_date":"2021-03-26","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:73YLmvCxBSzesjqxCOBAWS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0fauHpmSHwodVYIjTqOGHz"},"href":"https://api.spotify.com/v1/artists/0fauHpmSHwodVYIjTqOGHz","id":"0fauHpmSHwodVYIjTqOGHz","name":"Yiruma","type":"artist","uri":"spotify:artist:0fauHpmSHwodVYIjTqOGHz"}],"disc_number":1,"duration_ms":285251,"explicit":false,"external_ids":{"isrc":"KRUM72001036"},"external_urls":{"spotify":"https://open.spotify.com/track/02xd7yuAEiLOF7rt4zlPep"},"href":"https://api.spotify.com/v1/tracks/02xd7yuAEiLOF7rt4zlPep","id":"02xd7yuAEiLOF7rt4zlPep","is_local":false,"is_playable":true,"name":"River Flows in You - Orchestra Version","track_number":3,"type":"track","uri":"spotify:track:02xd7yuAEiLOF7rt4zlPep"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJpdmVyJTIwRmxvd3MlMjBpbiUyMFlvdSUyMiUyMGFydGlzdCUzQSUyMllpcnVtYSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGZhdUhwbVNId29kVllJalRxT0dIeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wZmF1SHBtU0h3b2RWWUlqVHFPR0h6IiwiaWQiOiIwZmF1SHBtU0h3b2RWWUlqVHFPR0h6IiwibmFtZSI6IllpcnVtYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZmF1SHBtU0h3b2RWWUlqVHFPR0h6In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMU42cDhxbWY4UEpnWVFka3RRUVlZaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFONnA4cW1mOFBKZ1lRZGt0UVFZWWgiLCJpZCI6IjFONnA4cW1mOFBKZ1lRZGt0UVFZWWgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jbw==", + "L2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0YmRiNjZkMTMzNWY4NTcxMjQwZTc1NWYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNGJkYjY2ZDEzMzVmODU3MTI0MGU3NTVmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0YmRiNjZkMTMzNWY4NTcxMjQwZTc1NWYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmlyc3QgTG92ZSAoVGhlIE9yaWdpbmFsICYgdGhlIFZlcnkgRmlyc3QgUmVjb3JkaW5nKSIsInJlbGVhc2VfZGF0ZSI6IjIwMDEtMTEtMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxTjZwOHFtZjhQSmdZUWRrdFFRWVloIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGZhdUhwbVNId29kVllJalRxT0dIeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wZmF1SHBtU0h3b2RWWUlqVHFPR0h6IiwiaWQiOiIwZmF1SHBtU0h3b2RWWUlqVHFPR0h6IiwibmFtZSI6IllpcnVtYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZmF1SHBtU0h3b2RWWUlqVHFPR0h6In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4ODc4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkhLT0ExMDYxNjk4OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMmFnQkRJcjlNWURVZHVjUVBDMXNGVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJhZ0JESXI5TVlEVWR1Y1FQQzFzRlUiLCJpZCI6IjJhZ0JESXI5TVlEVWR1Y1FQQzFzRlUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUml2ZXIgRmxvd3MgSW4gWW91IiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJhZ0JESXI5TVlEVWR1Y1FQQzFzRlUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGZhdUhwbVNId29kVllJalRxT0dIeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wZmF1SHBtU0h3b2RWWUlqVHFPR0h6IiwiaWQiOiIwZmF1SHBtU0h3b2RWWUlqVHFPRw==", + "SHoiLCJuYW1lIjoiWWlydW1hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBmYXVIcG1TSHdvZFZZSWpUcU9HSHoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83ZFo0OVhuUEJhRjRlNlNNWW1zTlExIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN2RaNDlYblBCYUY0ZTZTTVltc05RMSIsImlkIjoiN2RaNDlYblBCYUY0ZTZTTVltc05RMSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3NTM5MDBhY2Q0NjRkMzFmM2M3ZTZlNGUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzUzOTAwYWNkNDY0ZDMxZjNjN2U2ZTRlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3NTM5MDBhY2Q0NjRkMzFmM2M3ZTZlNGUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEJlc3QgLSBSZW1pbmlzY2VudCAxMHRoIEFubml2ZXJzYXJ5IiwicmVsZWFzZV9kYXRlIjoiMjAxMS0xMi0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdkWjQ5WG5QQmFGNGU2U01ZbXNOUTEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZmF1SHBtU0h3b2RWWUlqVHFPR0h6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBmYXVIcG1TSHdvZFZZSWpUcU9HSHoiLCJpZCI6IjBmYXVIcG1TSHdvZFZZSWpUcU9HSHoiLCJuYW1lIjoiWWlydW1hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBmYXVIcG1TSHdvZFZZSWpUcU9HSHoifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE4MjkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiS1JBMDMxMTAzMTk0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zeHI4Q09lZDRuUFBuNlhXWjBpQ0dyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM3hyOENPZWQ0blBQbjZYV1owaUNHciIsImlkIjoiM3hyOENPZWQ0blBQbjZYV1owaUNHciIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaXZlciBGbA==", + "b3dzIGluIFlvdSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozeHI4Q09lZDRuUFBuNlhXWjBpQ0dyIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBmYXVIcG1TSHdvZFZZSWpUcU9HSHoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGZhdUhwbVNId29kVllJalRxT0dIeiIsImlkIjoiMGZhdUhwbVNId29kVllJalRxT0dIeiIsIm5hbWUiOiJZaXJ1bWEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGZhdUhwbVNId29kVllJalRxT0dIeiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZCOUpzc0N2UWE2WjVSdGNNUWFLN24ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82QjlKc3NDdlFhNlo1UnRjTVFhSzduIiwiaWQiOiI2QjlKc3NDdlFhNlo1UnRjTVFhSzduIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ZkZDQ0YTU2ZmE1MWY2YjE1MTliOTQwMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmZGQ0NGE1NmZhNTFmNmIxNTE5Yjk0MDEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWZkZDQ0YTU2ZmE1MWY2YjE1MTliOTQwMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTT0xPIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wOS0yNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZCOUpzc0N2UWE2WjVSdGNNUWFLN24ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZmF1SHBtU0h3b2RWWUlqVHFPR0h6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBmYXVIcG1TSHdvZFZZSWpUcU9HSHoiLCJpZCI6IjBmYXVIcG1TSHdvZFZZSWpUcU9HSHoiLCJuYW1lIjoiWWlydW1hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBmYXVIcG1TSHdvZFZZSWpUcU9HSHoifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjEwNTYyLCJleHBsaWNpdCI6Zg==", + "YWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJLUlVNNzIxMDAwNzkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNJRWw1TExZc3ZURVFtbnhNYXhCUWEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zSUVsNUxMWXN2VEVRbW54TWF4QlFhIiwiaWQiOiIzSUVsNUxMWXN2VEVRbW54TWF4QlFhIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJpdmVyIEZsb3dzIEluIFlvdSIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozSUVsNUxMWXN2VEVRbW54TWF4QlFhIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVRU0p2SUI3TW4xeFFpVEhma3Z4alAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81UVNKdklCN01uMXhRaVRIZmt2eGpQIiwiaWQiOiI1UVNKdklCN01uMXhRaVRIZmt2eGpQIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzFhOWQ5ODk1MzBmZGFmYjU0YTFkMDI5MCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxYTlkOTg5NTMwZmRhZmI1NGExZDAyOTAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTFhOWQ5ODk1MzBmZGFmYjU0YTFkMDI5MCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQaWFubyBJbiBZb3UiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTA2LTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVFTSnZJQjdNbjF4UWlUSGZrdnhqUCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cg==", + "bHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGZhdUhwbVNId29kVllJalRxT0dIeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wZmF1SHBtU0h3b2RWWUlqVHFPR0h6IiwiaWQiOiIwZmF1SHBtU0h3b2RWWUlqVHFPR0h6IiwibmFtZSI6IllpcnVtYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZmF1SHBtU0h3b2RWWUlqVHFPR0h6In1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjE4ODI0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQTM3MTMzNjE1NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMTNOQzQ0YVMzZDBFRkY1OG9WUThUNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzEzTkM0NGFTM2QwRUZGNThvVlE4VDciLCJpZCI6IjEzTkM0NGFTM2QwRUZGNThvVlE4VDciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUml2ZXIgRmxvd3MgSW4gWW91IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjEzTkM0NGFTM2QwRUZGNThvVlE4VDcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGZhdUhwbVNId29kVllJalRxT0dIeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wZmF1SHBtU0h3b2RWWUlqVHFPR0h6IiwiaWQiOiIwZmF1SHBtU0h3b2RWWUlqVHFPR0h6IiwibmFtZSI6IllpcnVtYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZmF1SHBtU0h3b2RWWUlqVHFPR0h6In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzNZTG12Q3hCU3plc2pxeENPQkFXUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzczWUxtdkN4QlN6ZXNqcXhDT0JBV1MiLCJpZCI6IjczWUxtdkN4QlN6ZXNqcXhDT0JBV1MiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNWYzODQzMWQwMzZiZTUwNDM5MDQzYjA4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjVmMzg0MzFkMDM2YmU1MDQzOTA0M2IwOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdA==", + "aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1ZjM4NDMxZDAzNmJlNTA0MzkwNDNiMDgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIFJld3JpdHRlbiBNZW1vcmllcyIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDMtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjczWUxtdkN4QlN6ZXNqcXhDT0JBV1MifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZmF1SHBtU0h3b2RWWUlqVHFPR0h6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBmYXVIcG1TSHdvZFZZSWpUcU9HSHoiLCJpZCI6IjBmYXVIcG1TSHdvZFZZSWpUcU9HSHoiLCJuYW1lIjoiWWlydW1hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBmYXVIcG1TSHdvZFZZSWpUcU9HSHoifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjg1MjUxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiS1JVTTcyMDAxMDM2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wMnhkN3l1QUVpTE9GN3J0NHpsUGVwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDJ4ZDd5dUFFaUxPRjdydDR6bFBlcCIsImlkIjoiMDJ4ZDd5dUFFaUxPRjdydDR6bFBlcCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaXZlciBGbG93cyBpbiBZb3UgLSBPcmNoZXN0cmEgVmVyc2lvbiIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowMnhkN3l1QUVpTE9GN3J0NHpsUGVwIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22River+Flows+in+You%22+artist%3A%22Yiruma%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Teardrop%22%20artist%3A%22Massive%20Attack%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"}],"external_urls":{"spotify":"https://open.spotify.com/album/49MNmJhZQewjt06rpwp6QR"},"href":"https://api.spotify.com/v1/albums/49MNmJhZQewjt06rpwp6QR","id":"49MNmJhZQewjt06rpwp6QR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732fcb0a3c7a66e516b11cd26e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022fcb0a3c7a66e516b11cd26e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512fcb0a3c7a66e516b11cd26e"}],"is_playable":true,"name":"Mezzanine","release_date":"1998-01-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:49MNmJhZQewjt06rpwp6QR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/791Z3924aa619hZ3xsOJEx"},"href":"https://api.spotify.com/v1/artists/791Z3924aa619hZ3xsOJEx","id":"791Z3924aa619hZ3xsOJEx","name":"Elizabeth Fraser","type":"artist","uri":"spotify:artist:791Z3924aa619hZ3xsOJEx"}],"disc_number":1,"duration_ms":330773,"explicit":false,"external_ids":{"isrc":"GBAAA9800322"},"external_urls":{"spotify":"https://open.spotify.com/track/67Hna13dNDkZvBpTXRIaOJ"},"href":"https://api.spotify.com/v1/tracks/67Hna13dNDkZvBpTXRIaOJ","id":"67Hna13dNDkZvBpTXRIaOJ","is_local":false,"is_playable":true,"name":"Teardrop","track_number":3,"type":"track","uri":"spotify:track:67Hna13dNDkZvBpTXRIaOJ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"}],"external_urls":{"spotify":"https://open.spotify.com/album/0NDZWNHJ5ySx3YeFLbsdMe"},"href":"https://api.spotify.com/v1/albums/0NDZWNHJ5ySx3YeFLbsdMe","id":"0NDZWNHJ5ySx3YeFLbsdMe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735a34af7f2b06eb84c17d833e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025a34af7f2b06eb84c17d833e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515a34af7f2b06eb84c17d833e"}],"is_playable":true,"name":"Mezzanine (Deluxe)","release_date":"2019-08-23","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:0NDZWNHJ5ySx3YeFLbsdMe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/791Z3924aa619hZ3xsOJEx"},"href":"https://api.spotify.com/v1/artists/791Z3924aa619hZ3xsOJEx","id":"791Z3924aa619hZ3xsOJEx","name":"Elizabeth Fraser","type":"artist","uri":"spotify:artist:791Z3924aa619hZ3xsOJEx"}],"disc_number":1,"duration_ms":330453,"explicit":false,"external_ids":{"isrc":"GBUM71805233"},"external_urls":{"spotify":"https://open.spotify.com/track/36G7q9VtOVEYhuALFcO04W"},"href":"https://api.spotify.com/v1/tracks/36G7q9VtOVEYhuALFcO04W","id":"36G7q9VtOVEYhuALFcO04W","is_local":false,"is_playable":true,"name":"Teardrop - Remastered 2019","track_number":3,"type":"track","uri":"spotify:track:36G7q9VtOVEYhuALFcO04W"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"}],"external_urls":{"spotify":"https://open.spotify.com/album/2QDfjpDXtJDNASyvjc4Yvz"},"href":"https://api.spotify.com/v1/albums/2QDfjpDXtJDNASyvjc4Yvz","id":"2QDfjpDXtJDNASyvjc4Yvz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aa140e59e14175bea9385389"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aa140e59e14175bea9385389"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aa140e59e14175bea9385389"}],"is_playable":true,"name":"Teardrop","release_date":"1998-04-27","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:2QDfjpDXtJDNASyvjc4Yvz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/791Z3924aa619hZ3xsOJEx"},"href":"https://api.spotify.com/v1/artists/791Z3924aa619hZ3xsOJEx","id":"791Z3924aa619hZ3xsOJEx","name":"Elizabeth Fraser","type":"artist","uri":"spotify:artist:791Z3924aa619hZ3xsOJEx"}],"disc_number":1,"duration_ms":293760,"explicit":false,"external_ids":{"isrc":"GBAAA9800321"},"external_urls":{"spotify":"https://open.spotify.com/track/4wL5s83Ft705ZNtMh3Lzgg"},"href":"https://api.spotify.com/v1/tracks/4wL5s83Ft705ZNtMh3Lzgg","id":"4wL5s83Ft705ZNtMh3Lzgg","is_local":false,"is_playable":true,"name":"Teardrop - Edit","track_number":7,"type":"track","uri":"spotify:track:4wL5s83Ft705ZNtMh3Lzgg"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"}],"external_urls":{"spotify":"https://open.spotify.com/album/1xzKSxHdGEiHKVKfI8zrd9"},"href":"https://api.spotify.com/v1/albums/1xzKSxHdGEiHKVKfI8zrd9","id":"1xzKSxHdGEiHKVKfI8zrd9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a599f2960ace12ca8f380bba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a599f2960ace12ca8f380bba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a599f2960ace12ca8f380bba"}],"is_playable":true,"name":"Teardrop","release_date":"1998-04-27","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:1xzKSxHdGEiHKVKfI8zrd9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/791Z3924aa619hZ3xsOJEx"},"href":"https://api.spotify.com/v1/artists/791Z3924aa619hZ3xsOJEx","id":"791Z3924aa619hZ3xsOJEx","name":"Elizabeth Fraser","type":"artist","uri":"spotify:artist:791Z3924aa619hZ3xsOJEx"}],"disc_number":1,"duration_ms":331293,"explicit":false,"external_ids":{"isrc":"GBAAA9800322"},"external_urls":{"spotify":"https://open.spotify.com/track/1CFXBugUwX57RzV0v23LLX"},"href":"https://api.spotify.com/v1/tracks/1CFXBugUwX57RzV0v23LLX","id":"1CFXBugUwX57RzV0v23LLX","is_local":false,"is_playable":true,"name":"Teardrop","track_number":1,"type":"track","uri":"spotify:track:1CFXBugUwX57RzV0v23LLX"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"}],"external_urls":{"spotify":"https://open.spotify.com/album/5AmrF5hA0d8djSRpnZVmZH"},"href":"https://api.spotify.com/v1/albums/5AmrF5hA0d8djSRpnZVmZH","id":"5AmrF5hA0d8djSRpnZVmZH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27350569a7d207b807a94763b43"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0250569a7d207b807a94763b43"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485150569a7d207b807a94763b43"}],"is_playable":true,"name":"Singles Collection","release_date":"1998-01-01","release_date_precision":"day","total_tracks":61,"type":"album","uri":"spotify:album:5AmrF5hA0d8djSRpnZVmZH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/791Z3924aa619hZ3xsOJEx"},"href":"https://api.spotify.com/v1/artists/791Z3924aa619hZ3xsOJEx","id":"791Z3924aa619hZ3xsOJEx","name":"Elizabeth Fraser","type":"artist","uri":"spotify:artist:791Z3924aa619hZ3xsOJEx"}],"disc_number":9,"duration_ms":331293,"explicit":false,"external_ids":{"isrc":"GBAAA9800322"},"external_urls":{"spotify":"https://open.spotify.com/track/5jGXMBRsDfnQYystTNQKZP"},"href":"https://api.spotify.com/v1/tracks/5jGXMBRsDfnQYystTNQKZP","id":"5jGXMBRsDfnQYystTNQKZP","is_local":false,"is_playable":true,"name":"Teardrop","track_number":1,"type":"track","uri":"spotify:track:5jGXMBRsDfnQYystTNQKZP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"}],"external_urls":{"spotify":"https://open.spotify.com/album/1X4zW7kIY8bQHO9gDTsIVh"},"href":"https://api.spotify.com/v1/albums/1X4zW7kIY8bQHO9gDTsIVh","id":"1X4zW7kIY8bQHO9gDTsIVh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737fb18164a998591a94662aef"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027fb18164a998591a94662aef"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517fb18164a998591a94662aef"}],"is_playable":true,"name":"Collected","release_date":"2006-03-27","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:1X4zW7kIY8bQHO9gDTsIVh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/791Z3924aa619hZ3xsOJEx"},"href":"https://api.spotify.com/v1/artists/791Z3924aa619hZ3xsOJEx","id":"791Z3924aa619hZ3xsOJEx","name":"Elizabeth Fraser","type":"artist","uri":"spotify:artist:791Z3924aa619hZ3xsOJEx"}],"disc_number":1,"duration_ms":328026,"explicit":false,"external_ids":{"isrc":"GBAAA0600010"},"external_urls":{"spotify":"https://open.spotify.com/track/35mj4RS00QlYlYeHr89kTW"},"href":"https://api.spotify.com/v1/tracks/35mj4RS00QlYlYeHr89kTW","id":"35mj4RS00QlYlYeHr89kTW","is_local":false,"is_playable":true,"name":"Teardrop - Remastered 2006","track_number":4,"type":"track","uri":"spotify:track:35mj4RS00QlYlYeHr89kTW"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"}],"external_urls":{"spotify":"https://open.spotify.com/album/0NDZWNHJ5ySx3YeFLbsdMe"},"href":"https://api.spotify.com/v1/albums/0NDZWNHJ5ySx3YeFLbsdMe","id":"0NDZWNHJ5ySx3YeFLbsdMe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735a34af7f2b06eb84c17d833e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025a34af7f2b06eb84c17d833e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515a34af7f2b06eb84c17d833e"}],"is_playable":true,"name":"Mezzanine (Deluxe)","release_date":"2019-08-23","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:0NDZWNHJ5ySx3YeFLbsdMe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3hbnUwHvxyFxeJ9veCzOE7"},"href":"https://api.spotify.com/v1/artists/3hbnUwHvxyFxeJ9veCzOE7","id":"3hbnUwHvxyFxeJ9veCzOE7","name":"Mad Professor","type":"artist","uri":"spotify:artist:3hbnUwHvxyFxeJ9veCzOE7"}],"disc_number":2,"duration_ms":364898,"explicit":false,"external_ids":{"isrc":"GBUM71805032"},"external_urls":{"spotify":"https://open.spotify.com/track/73VmRvHBXVOerJiwvk7a9X"},"href":"https://api.spotify.com/v1/tracks/73VmRvHBXVOerJiwvk7a9X","id":"73VmRvHBXVOerJiwvk7a9X","is_local":false,"is_playable":true,"name":"Teardrop - Mazaruni Dub One","track_number":3,"type":"track","uri":"spotify:track:73VmRvHBXVOerJiwvk7a9X"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"}],"external_urls":{"spotify":"https://open.spotify.com/album/2QDfjpDXtJDNASyvjc4Yvz"},"href":"https://api.spotify.com/v1/albums/2QDfjpDXtJDNASyvjc4Yvz","id":"2QDfjpDXtJDNASyvjc4Yvz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aa140e59e14175bea9385389"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aa140e59e14175bea9385389"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aa140e59e14175bea9385389"}],"is_playable":true,"name":"Teardrop","release_date":"1998-04-27","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:2QDfjpDXtJDNASyvjc4Yvz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/791Z3924aa619hZ3xsOJEx"},"href":"https://api.spotify.com/v1/artists/791Z3924aa619hZ3xsOJEx","id":"791Z3924aa619hZ3xsOJEx","name":"Elizabeth Fraser","type":"artist","uri":"spotify:artist:791Z3924aa619hZ3xsOJEx"}],"disc_number":1,"duration_ms":331066,"explicit":false,"external_ids":{"isrc":"GBAAA9800322"},"external_urls":{"spotify":"https://open.spotify.com/track/6uGs60NyaZuPTtRmuva6AC"},"href":"https://api.spotify.com/v1/tracks/6uGs60NyaZuPTtRmuva6AC","id":"6uGs60NyaZuPTtRmuva6AC","is_local":false,"is_playable":true,"name":"Teardrop","track_number":1,"type":"track","uri":"spotify:track:6uGs60NyaZuPTtRmuva6AC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/13D6E5anevTTtCCbzmdpoB"},"href":"https://api.spotify.com/v1/albums/13D6E5anevTTtCCbzmdpoB","id":"13D6E5anevTTtCCbzmdpoB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f9d5c946c085c46c7823ffb3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f9d5c946c085c46c7823ffb3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f9d5c946c085c46c7823ffb3"}],"is_playable":true,"name":"Fascinating Rhythms (Sound Systems & Dancefloor)","release_date":"2013-01-01","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:13D6E5anevTTtCCbzmdpoB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6FXMGgJwohJLUSr5nVlf9X"},"href":"https://api.spotify.com/v1/artists/6FXMGgJwohJLUSr5nVlf9X","id":"6FXMGgJwohJLUSr5nVlf9X","name":"Massive Attack","type":"artist","uri":"spotify:artist:6FXMGgJwohJLUSr5nVlf9X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/791Z3924aa619hZ3xsOJEx"},"href":"https://api.spotify.com/v1/artists/791Z3924aa619hZ3xsOJEx","id":"791Z3924aa619hZ3xsOJEx","name":"Elizabeth Fraser","type":"artist","uri":"spotify:artist:791Z3924aa619hZ3xsOJEx"}],"disc_number":3,"duration_ms":330693,"explicit":false,"external_ids":{"isrc":"GBAAA0600010"},"external_urls":{"spotify":"https://open.spotify.com/track/2lNjU5Rb32VVpGYZezlOhx"},"href":"https://api.spotify.com/v1/tracks/2lNjU5Rb32VVpGYZezlOhx","id":"2lNjU5Rb32VVpGYZezlOhx","is_local":false,"is_playable":true,"name":"Teardrop - Remastered 2006","track_number":1,"type":"track","uri":"spotify:track:2lNjU5Rb32VVpGYZezlOhx"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRlYXJkcm9wJTIyJTIwYXJ0aXN0JTNBJTIyTWFzc2l2ZSUyMEF0dGFjayUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RlhNR2dKd29oSkxVU3I1blZsZjlYIiwiaWQiOiI2RlhNR2dKd29oSkxVU3I1blZsZjlYIiwibmFtZSI6Ik1hc3NpdmUgQXR0YWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80OU1ObUpoWlFld2p0MDZycHdwNlFSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNDlNTm1KaFpRZXdqdDA2cnB3cDZRUiIsImlkIjoiNDlNTm1KaFpRZXdqdDA2cnB3cDZRUiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2Ru", + "LmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyZmNiMGEzYzdhNjZlNTE2YjExY2QyNmUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmZjYjBhM2M3YTY2ZTUxNmIxMWNkMjZlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyZmNiMGEzYzdhNjZlNTE2YjExY2QyNmUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWV6emFuaW5lIiwicmVsZWFzZV9kYXRlIjoiMTk5OC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjQ5TU5tSmhaUWV3anQwNnJwd3A2UVIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RlhNR2dKd29oSkxVU3I1blZsZjlYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJpZCI6IjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJuYW1lIjoiTWFzc2l2ZSBBdHRhY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83OTFaMzkyNGFhNjE5aFozeHNPSkV4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc5MVozOTI0YWE2MTloWjN4c09KRXgiLCJpZCI6Ijc5MVozOTI0YWE2MTloWjN4c09KRXgiLCJuYW1lIjoiRWxpemFiZXRoIEZyYXNlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3OTFaMzkyNGFhNjE5aFozeHNPSkV4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMzMDc3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUFBOTgwMDMyMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNjdIbmExM2RORGtadkJwVFhSSWFPSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzY3SG5hMTNkTkRrWnZCcFRYUklhT0oiLCJpZCI6IjY3SG5hMTNkTkRrWnZCcFRYUklhT0oiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGVhcmRyb3AiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NjdIbmExM2RORGtadkJwVA==", + "WFJJYU9KIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCIsImlkIjoiNkZYTUdnSndvaEpMVVNyNW5WbGY5WCIsIm5hbWUiOiJNYXNzaXZlIEF0dGFjayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2RlhNR2dKd29oSkxVU3I1blZsZjlYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vME5EWldOSEo1eVN4M1llRkxic2RNZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBORFpXTkhKNXlTeDNZZUZMYnNkTWUiLCJpZCI6IjBORFpXTkhKNXlTeDNZZUZMYnNkTWUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNWEzNGFmN2YyYjA2ZWI4NGMxN2Q4MzNlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjVhMzRhZjdmMmIwNmViODRjMTdkODMzZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNWEzNGFmN2YyYjA2ZWI4NGMxN2Q4MzNlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1lenphbmluZSAoRGVsdXhlKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDgtMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowTkRaV05ISjV5U3gzWWVGTGJzZE1lIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RlhNR2dKd29oSkxVU3I1blZsZjlYIiwiaWQiOiI2RlhNR2dKd29oSkxVU3I1blZsZjlYIiwibmFtZSI6Ik1hc3NpdmUgQXR0YWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzkxWjM5MjRhYTYxOWhaM3hzT0pFeCJ9LCJocmVmIjoiaHR0cHM6Lw==", + "L2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc5MVozOTI0YWE2MTloWjN4c09KRXgiLCJpZCI6Ijc5MVozOTI0YWE2MTloWjN4c09KRXgiLCJuYW1lIjoiRWxpemFiZXRoIEZyYXNlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3OTFaMzkyNGFhNjE5aFozeHNPSkV4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMzMDQ1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MTgwNTIzMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMzZHN3E5VnRPVkVZaHVBTEZjTzA0VyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzM2RzdxOVZ0T1ZFWWh1QUxGY08wNFciLCJpZCI6IjM2RzdxOVZ0T1ZFWWh1QUxGY08wNFciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGVhcmRyb3AgLSBSZW1hc3RlcmVkIDIwMTkiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MzZHN3E5VnRPVkVZaHVBTEZjTzA0VyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RlhNR2dKd29oSkxVU3I1blZsZjlYIiwiaWQiOiI2RlhNR2dKd29oSkxVU3I1blZsZjlYIiwibmFtZSI6Ik1hc3NpdmUgQXR0YWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yUURmanBEWHRKRE5BU3l2amM0WXZ6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMlFEZmpwRFh0SkROQVN5dmpjNFl2eiIsImlkIjoiMlFEZmpwRFh0SkROQVN5dmpjNFl2eiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhYTE0MGU1OWUxNDE3NWJlYTkzODUzODkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWExNDBlNTllMTQxNzViZWE5Mzg1Mzg5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhYTE0MGU1OQ==", + "ZTE0MTc1YmVhOTM4NTM4OSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUZWFyZHJvcCIsInJlbGVhc2VfZGF0ZSI6IjE5OTgtMDQtMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJRRGZqcERYdEpETkFTeXZqYzRZdnoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RlhNR2dKd29oSkxVU3I1blZsZjlYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJpZCI6IjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJuYW1lIjoiTWFzc2l2ZSBBdHRhY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83OTFaMzkyNGFhNjE5aFozeHNPSkV4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc5MVozOTI0YWE2MTloWjN4c09KRXgiLCJpZCI6Ijc5MVozOTI0YWE2MTloWjN4c09KRXgiLCJuYW1lIjoiRWxpemFiZXRoIEZyYXNlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3OTFaMzkyNGFhNjE5aFozeHNPSkV4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI5Mzc2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUFBOTgwMDMyMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNHdMNXM4M0Z0NzA1Wk50TWgzTHpnZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzR3TDVzODNGdDcwNVpOdE1oM0x6Z2ciLCJpZCI6IjR3TDVzODNGdDcwNVpOdE1oM0x6Z2ciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGVhcmRyb3AgLSBFZGl0IiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjR3TDVzODNGdDcwNVpOdE1oM0x6Z2cifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCIsImlkIjoiNkZYTUdnSndvaEpMVVNyNQ==", + "blZsZjlYIiwibmFtZSI6Ik1hc3NpdmUgQXR0YWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xeHpLU3hIZEdFaUhLVktmSTh6cmQ5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMXh6S1N4SGRHRWlIS1ZLZkk4enJkOSIsImlkIjoiMXh6S1N4SGRHRWlIS1ZLZkk4enJkOSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhNTk5ZjI5NjBhY2UxMmNhOGYzODBiYmEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTU5OWYyOTYwYWNlMTJjYThmMzgwYmJhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhNTk5ZjI5NjBhY2UxMmNhOGYzODBiYmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGVhcmRyb3AiLCJyZWxlYXNlX2RhdGUiOiIxOTk4LTA0LTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxeHpLU3hIZEdFaUhLVktmSTh6cmQ5In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RlhNR2dKd29oSkxVU3I1blZsZjlYIiwiaWQiOiI2RlhNR2dKd29oSkxVU3I1blZsZjlYIiwibmFtZSI6Ik1hc3NpdmUgQXR0YWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzkxWjM5MjRhYTYxOWhaM3hzT0pFeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83OTFaMzkyNGFhNjE5aFozeHNPSkV4IiwiaWQiOiI3OTFaMzkyNGFhNjE5aFozeHNPSkV4IiwibmFtZSI6IkVsaXphYmV0aCBGcmFzZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzkxWjM5MjRhYTYxOWhaM3hzT0pFeCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMzEyOTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaQ==", + "ZHMiOnsiaXNyYyI6IkdCQUFBOTgwMDMyMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUNGWEJ1Z1V3WDU3UnpWMHYyM0xMWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFDRlhCdWdVd1g1N1J6VjB2MjNMTFgiLCJpZCI6IjFDRlhCdWdVd1g1N1J6VjB2MjNMTFgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGVhcmRyb3AiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUNGWEJ1Z1V3WDU3UnpWMHYyM0xMWCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RlhNR2dKd29oSkxVU3I1blZsZjlYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJpZCI6IjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJuYW1lIjoiTWFzc2l2ZSBBdHRhY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVBbXJGNWhBMGQ4ZGpTUnBuWlZtWkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81QW1yRjVoQTBkOGRqU1JwblpWbVpIIiwiaWQiOiI1QW1yRjVoQTBkOGRqU1JwblpWbVpIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzUwNTY5YTdkMjA3YjgwN2E5NDc2M2I0MyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1MDU2OWE3ZDIwN2I4MDdhOTQ3NjNiNDMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTUwNTY5YTdkMjA3YjgwN2E5NDc2M2I0MyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTaW5nbGVzIENvbGxlY3Rpb24iLCJyZWxlYXNlX2RhdGUiOiIxOTk4LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUFtckY1aEEwZDhkalNScG5aVm1aSCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwcw==", + "Oi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RlhNR2dKd29oSkxVU3I1blZsZjlYIiwiaWQiOiI2RlhNR2dKd29oSkxVU3I1blZsZjlYIiwibmFtZSI6Ik1hc3NpdmUgQXR0YWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzkxWjM5MjRhYTYxOWhaM3hzT0pFeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83OTFaMzkyNGFhNjE5aFozeHNPSkV4IiwiaWQiOiI3OTFaMzkyNGFhNjE5aFozeHNPSkV4IiwibmFtZSI6IkVsaXphYmV0aCBGcmFzZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzkxWjM5MjRhYTYxOWhaM3hzT0pFeCJ9XSwiZGlzY19udW1iZXIiOjksImR1cmF0aW9uX21zIjozMzEyOTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFBQTk4MDAzMjIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVqR1hNQlJzRGZuUVl5c3RUTlFLWlAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81akdYTUJSc0RmblFZeXN0VE5RS1pQIiwiaWQiOiI1akdYTUJSc0RmblFZeXN0VE5RS1pQIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRlYXJkcm9wIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVqR1hNQlJzRGZuUVl5c3RUTlFLWlAifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RlhNR2dKd29oSkxVU3I1blZsZjlYIiwiaWQiOiI2RlhNR2dKd29oSkxVU3I1blZsZjlYIiwibmFtZSI6Ik1hc3NpdmUgQXR0YWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xWDR6VzdrSVk4YlFITzlnRFRzSVZoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVg0elc3a0lZOGJRSE85Z0RUcw==", + "SVZoIiwiaWQiOiIxWDR6VzdrSVk4YlFITzlnRFRzSVZoIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzdmYjE4MTY0YTk5ODU5MWE5NDY2MmFlZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3ZmIxODE2NGE5OTg1OTFhOTQ2NjJhZWYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTdmYjE4MTY0YTk5ODU5MWE5NDY2MmFlZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDb2xsZWN0ZWQiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTAzLTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVg0elc3a0lZOGJRSE85Z0RUc0lWaCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCIsImlkIjoiNkZYTUdnSndvaEpMVVNyNW5WbGY5WCIsIm5hbWUiOiJNYXNzaXZlIEF0dGFjayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2RlhNR2dKd29oSkxVU3I1blZsZjlYIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc5MVozOTI0YWE2MTloWjN4c09KRXgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzkxWjM5MjRhYTYxOWhaM3hzT0pFeCIsImlkIjoiNzkxWjM5MjRhYTYxOWhaM3hzT0pFeCIsIm5hbWUiOiJFbGl6YWJldGggRnJhc2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc5MVozOTI0YWE2MTloWjN4c09KRXgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI4MDI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBQUEwNjAwMDEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zNW1qNFJTMDBRbFlsWWVIcjg5a1RXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzVtajRSUzAwUWxZbFllSHI4OWtUVyIsImlkIjoiMzVtajRSUzAwUWxZbFllSHI4OWtUVyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOg==", + "dHJ1ZSwibmFtZSI6IlRlYXJkcm9wIC0gUmVtYXN0ZXJlZCAyMDA2IiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjM1bWo0UlMwMFFsWWxZZUhyODlrVFcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RlhNR2dKd29oSkxVU3I1blZsZjlYIiwiaWQiOiI2RlhNR2dKd29oSkxVU3I1blZsZjlYIiwibmFtZSI6Ik1hc3NpdmUgQXR0YWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wTkRaV05ISjV5U3gzWWVGTGJzZE1lIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvME5EWldOSEo1eVN4M1llRkxic2RNZSIsImlkIjoiME5EWldOSEo1eVN4M1llRkxic2RNZSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1YTM0YWY3ZjJiMDZlYjg0YzE3ZDgzM2UifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWEzNGFmN2YyYjA2ZWI4NGMxN2Q4MzNlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1YTM0YWY3ZjJiMDZlYjg0YzE3ZDgzM2UifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWV6emFuaW5lIChEZWx1eGUpIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wOC0yMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBORFpXTkhKNXlTeDNZZUZMYnNkTWUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RlhNR2dKd29oSkxVU3I1blZsZjlYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJpZCI6IjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJuYW1lIjoiTWFzc2l2ZSBBdHRhY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkZYTUdnSndvaEpMVVNyNQ==", + "blZsZjlYIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNoYm5Vd0h2eHlGeGVKOXZlQ3pPRTcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2hiblV3SHZ4eUZ4ZUo5dmVDek9FNyIsImlkIjoiM2hiblV3SHZ4eUZ4ZUo5dmVDek9FNyIsIm5hbWUiOiJNYWQgUHJvZmVzc29yIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNoYm5Vd0h2eHlGeGVKOXZlQ3pPRTcifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MzY0ODk4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JVTTcxODA1MDMyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83M1ZtUnZIQlhWT2VySml3dms3YTlYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNzNWbVJ2SEJYVk9lckppd3ZrN2E5WCIsImlkIjoiNzNWbVJ2SEJYVk9lckppd3ZrN2E5WCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUZWFyZHJvcCAtIE1hemFydW5pIER1YiBPbmUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NzNWbVJ2SEJYVk9lckppd3ZrN2E5WCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RlhNR2dKd29oSkxVU3I1blZsZjlYIiwiaWQiOiI2RlhNR2dKd29oSkxVU3I1blZsZjlYIiwibmFtZSI6Ik1hc3NpdmUgQXR0YWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yUURmanBEWHRKRE5BU3l2amM0WXZ6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMlFEZmpwRFh0SkROQVN5dmpjNFl2eiIsImlkIjoiMlFEZmpwRFh0SkROQVN5dmpjNFl2eiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhYTE0MGU1OWUxNDE3NWJlYTkzODUzODkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZQ==", + "MDJhYTE0MGU1OWUxNDE3NWJlYTkzODUzODkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFhMTQwZTU5ZTE0MTc1YmVhOTM4NTM4OSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUZWFyZHJvcCIsInJlbGVhc2VfZGF0ZSI6IjE5OTgtMDQtMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJRRGZqcERYdEpETkFTeXZqYzRZdnoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RlhNR2dKd29oSkxVU3I1blZsZjlYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJpZCI6IjZGWE1HZ0p3b2hKTFVTcjVuVmxmOVgiLCJuYW1lIjoiTWFzc2l2ZSBBdHRhY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkZYTUdnSndvaEpMVVNyNW5WbGY5WCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83OTFaMzkyNGFhNjE5aFozeHNPSkV4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc5MVozOTI0YWE2MTloWjN4c09KRXgiLCJpZCI6Ijc5MVozOTI0YWE2MTloWjN4c09KRXgiLCJuYW1lIjoiRWxpemFiZXRoIEZyYXNlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3OTFaMzkyNGFhNjE5aFozeHNPSkV4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMzMTA2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUFBOTgwMDMyMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnVHczYwTnlhWnVQVHRSbXV2YTZBQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3Bv", + "dGlmeS5jb20vdjEvdHJhY2tzLzZ1R3M2ME55YVp1UFR0Um11dmE2QUMiLCJpZCI6IjZ1R3M2ME55YVp1UFR0Um11dmE2QUMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGVhcmRyb3AiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NnVHczYwTnlhWnVQVHRSbXV2YTZBQyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xM0Q2RTVhbmV2VFR0Q0Niem1kcG9CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTNENkU1YW5ldlRUdENDYnptZHBvQiIsImlkIjoiMTNENkU1YW5ldlRUdENDYnptZHBvQiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmOWQ1Yzk0NmMwODVjNDZjNzgyM2ZmYjMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjlkNWM5NDZjMDg1YzQ2Yzc4MjNmZmIzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmOWQ1Yzk0NmMwODVjNDZjNzgyM2ZmYjMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmFzY2luYXRpbmcgUmh5dGhtcyAoU291bmQgU3lzdGVtcyAmIERhbmNlZmxvb3IpIiwicmVsZWFzZV9kYXRlIjoiMjAxMy0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjEzRDZFNWFuZXZUVHRDQ2J6bWRwb0IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RlhNR2dKd29oSkxVU3I1blZsZjlYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZGWE1HZ0p3bw==", + "aEpMVVNyNW5WbGY5WCIsImlkIjoiNkZYTUdnSndvaEpMVVNyNW5WbGY5WCIsIm5hbWUiOiJNYXNzaXZlIEF0dGFjayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2RlhNR2dKd29oSkxVU3I1blZsZjlYIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc5MVozOTI0YWE2MTloWjN4c09KRXgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzkxWjM5MjRhYTYxOWhaM3hzT0pFeCIsImlkIjoiNzkxWjM5MjRhYTYxOWhaM3hzT0pFeCIsIm5hbWUiOiJFbGl6YWJldGggRnJhc2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc5MVozOTI0YWE2MTloWjN4c09KRXgifV0sImRpc2NfbnVtYmVyIjozLCJkdXJhdGlvbl9tcyI6MzMwNjkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBQUEwNjAwMDEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8ybE5qVTVSYjMyVlZwR1laZXpsT2h4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMmxOalU1UmIzMlZWcEdZWmV6bE9oeCIsImlkIjoiMmxOalU1UmIzMlZWcEdZWmV6bE9oeCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUZWFyZHJvcCAtIFJlbWFzdGVyZWQgMjAwNiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoybE5qVTVSYjMyVlZwR1laZXpsT2h4In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Teardrop%22+artist%3A%22Massive+Attack%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Strobe%22%20artist%3A%22Deadmau5%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"external_urls":{"spotify":"https://open.spotify.com/album/6EYy8giXumFOmT1fpZTCMB"},"href":"https://api.spotify.com/v1/albums/6EYy8giXumFOmT1fpZTCMB","id":"6EYy8giXumFOmT1fpZTCMB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ac4c76801e5286f371b5f4b1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ac4c76801e5286f371b5f4b1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ac4c76801e5286f371b5f4b1"}],"is_playable":true,"name":"Strobe","release_date":"2010-01-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:6EYy8giXumFOmT1fpZTCMB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"disc_number":1,"duration_ms":634151,"explicit":false,"external_ids":{"isrc":"GBTDG0900141"},"external_urls":{"spotify":"https://open.spotify.com/track/4kJWtxDDNb9oAk3h7sX3N4"},"href":"https://api.spotify.com/v1/tracks/4kJWtxDDNb9oAk3h7sX3N4","id":"4kJWtxDDNb9oAk3h7sX3N4","is_local":false,"is_playable":true,"name":"Strobe","track_number":6,"type":"track","uri":"spotify:track:4kJWtxDDNb9oAk3h7sX3N4"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"external_urls":{"spotify":"https://open.spotify.com/album/6EYy8giXumFOmT1fpZTCMB"},"href":"https://api.spotify.com/v1/albums/6EYy8giXumFOmT1fpZTCMB","id":"6EYy8giXumFOmT1fpZTCMB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ac4c76801e5286f371b5f4b1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ac4c76801e5286f371b5f4b1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ac4c76801e5286f371b5f4b1"}],"is_playable":true,"name":"Strobe","release_date":"2010-01-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:6EYy8giXumFOmT1fpZTCMB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"disc_number":1,"duration_ms":214186,"explicit":false,"external_ids":{"isrc":"GBTDG0900152"},"external_urls":{"spotify":"https://open.spotify.com/track/6c9EGVj5CaOeoKd9ecMW1U"},"href":"https://api.spotify.com/v1/tracks/6c9EGVj5CaOeoKd9ecMW1U","id":"6c9EGVj5CaOeoKd9ecMW1U","is_local":false,"is_playable":true,"name":"Strobe - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:6c9EGVj5CaOeoKd9ecMW1U"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"external_urls":{"spotify":"https://open.spotify.com/album/6WJvrBlL3zgu4mVoKyvMkl"},"href":"https://api.spotify.com/v1/albums/6WJvrBlL3zgu4mVoKyvMkl","id":"6WJvrBlL3zgu4mVoKyvMkl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d49d976721f4dc6b3c6225ad"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d49d976721f4dc6b3c6225ad"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d49d976721f4dc6b3c6225ad"}],"is_playable":true,"name":"For Lack Of A Better Name","release_date":"2009-01-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:6WJvrBlL3zgu4mVoKyvMkl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"disc_number":1,"duration_ms":634466,"explicit":false,"external_ids":{"isrc":"GBTDG0900141"},"external_urls":{"spotify":"https://open.spotify.com/track/1sgyYCbGhkX3auLHCQ825G"},"href":"https://api.spotify.com/v1/tracks/1sgyYCbGhkX3auLHCQ825G","id":"1sgyYCbGhkX3auLHCQ825G","is_local":false,"is_playable":true,"name":"Strobe","track_number":10,"type":"track","uri":"spotify:track:1sgyYCbGhkX3auLHCQ825G"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"external_urls":{"spotify":"https://open.spotify.com/album/6EYy8giXumFOmT1fpZTCMB"},"href":"https://api.spotify.com/v1/albums/6EYy8giXumFOmT1fpZTCMB","id":"6EYy8giXumFOmT1fpZTCMB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ac4c76801e5286f371b5f4b1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ac4c76801e5286f371b5f4b1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ac4c76801e5286f371b5f4b1"}],"is_playable":true,"name":"Strobe","release_date":"2010-01-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:6EYy8giXumFOmT1fpZTCMB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"disc_number":1,"duration_ms":381380,"explicit":false,"external_ids":{"isrc":"GBTDG0900153"},"external_urls":{"spotify":"https://open.spotify.com/track/0eEYax5zHz46XYmD0RJdx6"},"href":"https://api.spotify.com/v1/tracks/0eEYax5zHz46XYmD0RJdx6","id":"0eEYax5zHz46XYmD0RJdx6","is_local":false,"is_playable":true,"name":"Strobe - Club Edit","track_number":2,"type":"track","uri":"spotify:track:0eEYax5zHz46XYmD0RJdx6"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1TXYCtz4NjCcy02l9xYyWg"},"href":"https://api.spotify.com/v1/artists/1TXYCtz4NjCcy02l9xYyWg","id":"1TXYCtz4NjCcy02l9xYyWg","name":"Hospital Records","type":"artist","uri":"spotify:artist:1TXYCtz4NjCcy02l9xYyWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/01T6UksYGB4X6FZIrgVEgM"},"href":"https://api.spotify.com/v1/albums/01T6UksYGB4X6FZIrgVEgM","id":"01T6UksYGB4X6FZIrgVEgM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f042bc0a9f318f277694ad61"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f042bc0a9f318f277694ad61"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f042bc0a9f318f277694ad61"}],"is_playable":true,"name":"Hospital: We Are 21","release_date":"2017-01-27","release_date_precision":"day","total_tracks":70,"type":"album","uri":"spotify:album:01T6UksYGB4X6FZIrgVEgM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2GHSfIlUnKEtHH5GBNhmhb"},"href":"https://api.spotify.com/v1/artists/2GHSfIlUnKEtHH5GBNhmhb","id":"2GHSfIlUnKEtHH5GBNhmhb","name":"Deadmau5","type":"artist","uri":"spotify:artist:2GHSfIlUnKEtHH5GBNhmhb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"disc_number":1,"duration_ms":308965,"explicit":false,"external_ids":{"isrc":"GBTDG1301166"},"external_urls":{"spotify":"https://open.spotify.com/track/71Q2cY1c6ig7t0EC5J2uff"},"href":"https://api.spotify.com/v1/tracks/71Q2cY1c6ig7t0EC5J2uff","id":"71Q2cY1c6ig7t0EC5J2uff","is_local":false,"is_playable":true,"name":"Strobe - Dimension Remix","track_number":10,"type":"track","uri":"spotify:track:71Q2cY1c6ig7t0EC5J2uff"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7mC3RkNNTV6p2j9w4F8Ip4"},"href":"https://api.spotify.com/v1/artists/7mC3RkNNTV6p2j9w4F8Ip4","id":"7mC3RkNNTV6p2j9w4F8Ip4","name":"Layton Giordani","type":"artist","uri":"spotify:artist:7mC3RkNNTV6p2j9w4F8Ip4"}],"external_urls":{"spotify":"https://open.spotify.com/album/2lA6LPtr9O0HwNLDYEzzjm"},"href":"https://api.spotify.com/v1/albums/2lA6LPtr9O0HwNLDYEzzjm","id":"2lA6LPtr9O0HwNLDYEzzjm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d00279e335fc8263e0cb3ef1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d00279e335fc8263e0cb3ef1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d00279e335fc8263e0cb3ef1"}],"is_playable":true,"name":"Strobe (Layton Giordani Remix)","release_date":"2024-09-13","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:2lA6LPtr9O0HwNLDYEzzjm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7mC3RkNNTV6p2j9w4F8Ip4"},"href":"https://api.spotify.com/v1/artists/7mC3RkNNTV6p2j9w4F8Ip4","id":"7mC3RkNNTV6p2j9w4F8Ip4","name":"Layton Giordani","type":"artist","uri":"spotify:artist:7mC3RkNNTV6p2j9w4F8Ip4"}],"disc_number":1,"duration_ms":215156,"explicit":false,"external_ids":{"isrc":"GBTDG1302860"},"external_urls":{"spotify":"https://open.spotify.com/track/2So9vITovkovvxlVerZccz"},"href":"https://api.spotify.com/v1/tracks/2So9vITovkovvxlVerZccz","id":"2So9vITovkovvxlVerZccz","is_local":false,"is_playable":true,"name":"Strobe - Layton Giordani Remix","track_number":1,"type":"track","uri":"spotify:track:2So9vITovkovvxlVerZccz"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/20SdlzwzzIYeCxGI3TnDn7"},"href":"https://api.spotify.com/v1/albums/20SdlzwzzIYeCxGI3TnDn7","id":"20SdlzwzzIYeCxGI3TnDn7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734efd68b60bda339a8992734d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024efd68b60bda339a8992734d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514efd68b60bda339a8992734d"}],"is_playable":true,"name":"mau5trap '16","release_date":"2016-12-30","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:20SdlzwzzIYeCxGI3TnDn7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/27gtK7m9vYwCyJ04zz0kIb"},"href":"https://api.spotify.com/v1/artists/27gtK7m9vYwCyJ04zz0kIb","id":"27gtK7m9vYwCyJ04zz0kIb","name":"Lane 8","type":"artist","uri":"spotify:artist:27gtK7m9vYwCyJ04zz0kIb"}],"disc_number":1,"duration_ms":437419,"explicit":false,"external_ids":{"isrc":"GBTDG1301164"},"external_urls":{"spotify":"https://open.spotify.com/track/2c71M7379coTsZ95GewFgO"},"href":"https://api.spotify.com/v1/tracks/2c71M7379coTsZ95GewFgO","id":"2c71M7379coTsZ95GewFgO","is_local":false,"is_playable":true,"name":"Strobe - Lane 8 Remix","track_number":14,"type":"track","uri":"spotify:track:2c71M7379coTsZ95GewFgO"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0Z7zcsIphrPDnfZj9Ppqw0"},"href":"https://api.spotify.com/v1/artists/0Z7zcsIphrPDnfZj9Ppqw0","id":"0Z7zcsIphrPDnfZj9Ppqw0","name":"&friends","type":"artist","uri":"spotify:artist:0Z7zcsIphrPDnfZj9Ppqw0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1dq8CEUSNTPN81up2lVwnm"},"href":"https://api.spotify.com/v1/artists/1dq8CEUSNTPN81up2lVwnm","id":"1dq8CEUSNTPN81up2lVwnm","name":"Moeaike","type":"artist","uri":"spotify:artist:1dq8CEUSNTPN81up2lVwnm"}],"external_urls":{"spotify":"https://open.spotify.com/album/6G2xdggrJTK7Q0szYE8YAc"},"href":"https://api.spotify.com/v1/albums/6G2xdggrJTK7Q0szYE8YAc","id":"6G2xdggrJTK7Q0szYE8YAc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27326664d99dd2a2ec5f0686a0f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0226664d99dd2a2ec5f0686a0f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485126664d99dd2a2ec5f0686a0f"}],"is_playable":true,"name":"Strobe (&friends, Moeaike Retake)","release_date":"2025-12-05","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6G2xdggrJTK7Q0szYE8YAc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0Z7zcsIphrPDnfZj9Ppqw0"},"href":"https://api.spotify.com/v1/artists/0Z7zcsIphrPDnfZj9Ppqw0","id":"0Z7zcsIphrPDnfZj9Ppqw0","name":"&friends","type":"artist","uri":"spotify:artist:0Z7zcsIphrPDnfZj9Ppqw0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1dq8CEUSNTPN81up2lVwnm"},"href":"https://api.spotify.com/v1/artists/1dq8CEUSNTPN81up2lVwnm","id":"1dq8CEUSNTPN81up2lVwnm","name":"Moeaike","type":"artist","uri":"spotify:artist:1dq8CEUSNTPN81up2lVwnm"}],"disc_number":1,"duration_ms":358000,"explicit":false,"external_ids":{"isrc":"CA5KR2601609"},"external_urls":{"spotify":"https://open.spotify.com/track/5sE0hJx2vDKTIUsPO27qtT"},"href":"https://api.spotify.com/v1/tracks/5sE0hJx2vDKTIUsPO27qtT","id":"5sE0hJx2vDKTIUsPO27qtT","is_local":false,"is_playable":true,"name":"Strobe - &friends, Moeaike Retake","track_number":1,"type":"track","uri":"spotify:track:5sE0hJx2vDKTIUsPO27qtT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7mC3RkNNTV6p2j9w4F8Ip4"},"href":"https://api.spotify.com/v1/artists/7mC3RkNNTV6p2j9w4F8Ip4","id":"7mC3RkNNTV6p2j9w4F8Ip4","name":"Layton Giordani","type":"artist","uri":"spotify:artist:7mC3RkNNTV6p2j9w4F8Ip4"}],"external_urls":{"spotify":"https://open.spotify.com/album/2lA6LPtr9O0HwNLDYEzzjm"},"href":"https://api.spotify.com/v1/albums/2lA6LPtr9O0HwNLDYEzzjm","id":"2lA6LPtr9O0HwNLDYEzzjm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d00279e335fc8263e0cb3ef1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d00279e335fc8263e0cb3ef1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d00279e335fc8263e0cb3ef1"}],"is_playable":true,"name":"Strobe (Layton Giordani Remix)","release_date":"2024-09-13","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:2lA6LPtr9O0HwNLDYEzzjm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"disc_number":1,"duration_ms":634466,"explicit":false,"external_ids":{"isrc":"GBTDG0900141"},"external_urls":{"spotify":"https://open.spotify.com/track/0xGaZxZz53CXAbrZt9v2qb"},"href":"https://api.spotify.com/v1/tracks/0xGaZxZz53CXAbrZt9v2qb","id":"0xGaZxZz53CXAbrZt9v2qb","is_local":false,"is_playable":true,"name":"Strobe","track_number":2,"type":"track","uri":"spotify:track:0xGaZxZz53CXAbrZt9v2qb"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"}],"external_urls":{"spotify":"https://open.spotify.com/album/4uKFNr3KNqr4zeLWJfBC66"},"href":"https://api.spotify.com/v1/albums/4uKFNr3KNqr4zeLWJfBC66","id":"4uKFNr3KNqr4zeLWJfBC66","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27399b3904b412478ee2429d978"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0299b3904b412478ee2429d978"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485199b3904b412478ee2429d978"}],"is_playable":true,"name":"5 years of mau5","release_date":"2014-11-21","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4uKFNr3KNqr4zeLWJfBC66"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2CIMQHirSU0MQqyYHq0eOx"},"href":"https://api.spotify.com/v1/artists/2CIMQHirSU0MQqyYHq0eOx","id":"2CIMQHirSU0MQqyYHq0eOx","name":"deadmau5","type":"artist","uri":"spotify:artist:2CIMQHirSU0MQqyYHq0eOx"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3G1QoWkaZ1CUnTLUb0CqtC"},"href":"https://api.spotify.com/v1/artists/3G1QoWkaZ1CUnTLUb0CqtC","id":"3G1QoWkaZ1CUnTLUb0CqtC","name":"Michael Woods","type":"artist","uri":"spotify:artist:3G1QoWkaZ1CUnTLUb0CqtC"}],"disc_number":2,"duration_ms":432279,"explicit":false,"external_ids":{"isrc":"GBTDG1300726"},"external_urls":{"spotify":"https://open.spotify.com/track/4nPucjNQyWwU9BUtkXO4df"},"href":"https://api.spotify.com/v1/tracks/4nPucjNQyWwU9BUtkXO4df","id":"4nPucjNQyWwU9BUtkXO4df","is_local":false,"is_playable":true,"name":"Strobe - Michael Woods 2014 Remix","track_number":6,"type":"track","uri":"spotify:track:4nPucjNQyWwU9BUtkXO4df"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN0cm9iZSUyMiUyMGFydGlzdCUzQSUyMkRlYWRtYXU1JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQ0lNUUhpclNVME1RcXlZSHEwZU94IiwiaWQiOiIyQ0lNUUhpclNVME1RcXlZSHEwZU94IiwibmFtZSI6ImRlYWRtYXU1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82RVl5OGdpWHVtRk9tVDFmcFpUQ01CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNkVZeThnaVh1bUZPbVQxZnBaVENNQiIsImlkIjoiNkVZeThnaVh1bUZPbVQxZnBaVENNQiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhYzRjNzY4MDFlNTI4NmYzNzFiNWY0YjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWM0Yzc2ODAxZTUyODZmMzcxYjVmNGIxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhYzRjNzY4MDFlNTI4NmYzNzFiNWY0YjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3Ryb2JlIiwicmVsZWFzZV9kYXRlIjoiMjAxMC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkVZeThnaVh1bUZPbVQxZnBaVENNQiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsImlkIjoiMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsIm5hbWUiOiJkZQ==", + "YWRtYXU1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NjM0MTUxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JUREcwOTAwMTQxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80a0pXdHhERE5iOW9BazNoN3NYM040In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGtKV3R4REROYjlvQWszaDdzWDNONCIsImlkIjoiNGtKV3R4REROYjlvQWszaDdzWDNONCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdHJvYmUiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGtKV3R4REROYjlvQWszaDdzWDNONCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQ0lNUUhpclNVME1RcXlZSHEwZU94IiwiaWQiOiIyQ0lNUUhpclNVME1RcXlZSHEwZU94IiwibmFtZSI6ImRlYWRtYXU1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82RVl5OGdpWHVtRk9tVDFmcFpUQ01CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNkVZeThnaVh1bUZPbVQxZnBaVENNQiIsImlkIjoiNkVZeThnaVh1bUZPbVQxZnBaVENNQiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhYzRjNzY4MDFlNTI4NmYzNzFiNWY0YjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWM0Yzc2ODAxZTUyODZmMzcxYjVmNGIxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhYzRjNzY4MDFlNTI4NmYzNzFiNWY0YjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3Ryb2JlIiwicmVsZWFzZV9kYXRlIjoiMjAxMC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFjaw==", + "cyI6NiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2RVl5OGdpWHVtRk9tVDFmcFpUQ01CIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQ0lNUUhpclNVME1RcXlZSHEwZU94IiwiaWQiOiIyQ0lNUUhpclNVME1RcXlZSHEwZU94IiwibmFtZSI6ImRlYWRtYXU1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE0MTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JUREcwOTAwMTUyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82YzlFR1ZqNUNhT2VvS2Q5ZWNNVzFVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmM5RUdWajVDYU9lb0tkOWVjTVcxVSIsImlkIjoiNmM5RUdWajVDYU9lb0tkOWVjTVcxVSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdHJvYmUgLSBSYWRpbyBFZGl0IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZjOUVHVmo1Q2FPZW9LZDllY01XMVUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQ0lNUUhpclNVME1RcXlZSHEwZU94IiwiaWQiOiIyQ0lNUUhpclNVME1RcXlZSHEwZU94IiwibmFtZSI6ImRlYWRtYXU1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82V0p2ckJsTDN6Z3U0bVZvS3l2TWtsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNldKdnJCbEwzemd1NG1Wb0t5dk1rbCIsImlkIjoiNldKdnJCbEwzemd1NG1Wb0t5dk1rbCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkNDlkOTc2NzIxZjRkYzZiM2M2MjI1YWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6Mw==", + "MDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkNDlkOTc2NzIxZjRkYzZiM2M2MjI1YWQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWQ0OWQ5NzY3MjFmNGRjNmIzYzYyMjVhZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGb3IgTGFjayBPZiBBIEJldHRlciBOYW1lIiwicmVsZWFzZV9kYXRlIjoiMjAwOS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZXSnZyQmxMM3pndTRtVm9LeXZNa2wifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQ0lNUUhpclNVME1RcXlZSHEwZU94In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJpZCI6IjJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJuYW1lIjoiZGVhZG1hdTUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo2MzQ0NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlRERzA5MDAxNDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFzZ3lZQ2JHaGtYM2F1TEhDUTgyNUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xc2d5WUNiR2hrWDNhdUxIQ1E4MjVHIiwiaWQiOiIxc2d5WUNiR2hrWDNhdUxIQ1E4MjVHIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0cm9iZSIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXNneVlDYkdoa1gzYXVMSENRODI1RyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQ0lNUUhpclNVME1RcXlZSHEwZU94IiwiaWQiOiIyQ0lNUUhpclNVME1RcXlZSHEwZU94IiwibmFtZSI6ImRlYWRtYXU1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifV0sImV4dGVybmFsX3VybHMiOnsic3BvdA==", + "aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZFWXk4Z2lYdW1GT21UMWZwWlRDTUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82RVl5OGdpWHVtRk9tVDFmcFpUQ01CIiwiaWQiOiI2RVl5OGdpWHVtRk9tVDFmcFpUQ01CIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FjNGM3NjgwMWU1Mjg2ZjM3MWI1ZjRiMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhYzRjNzY4MDFlNTI4NmYzNzFiNWY0YjEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFjNGM3NjgwMWU1Mjg2ZjM3MWI1ZjRiMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdHJvYmUiLCJyZWxlYXNlX2RhdGUiOiIyMDEwLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2RVl5OGdpWHVtRk9tVDFmcFpUQ01CIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQ0lNUUhpclNVME1RcXlZSHEwZU94IiwiaWQiOiIyQ0lNUUhpclNVME1RcXlZSHEwZU94IiwibmFtZSI6ImRlYWRtYXU1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzgxMzgwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JUREcwOTAwMTUzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wZUVZYXg1ekh6NDZYWW1EMFJKZHg2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGVFWWF4NXpIejQ2WFltRDBSSmR4NiIsImlkIjoiMGVFWWF4NXpIejQ2WFltRDBSSmR4NiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdHJvYmUgLSBDbHViIEVkaXQiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGVFWWF4NXpIejQ2WFltRDBSSmR4NiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZQ==", + "cm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFUWFlDdHo0TmpDY3kwMmw5eFl5V2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVRYWUN0ejROakNjeTAybDl4WXlXZyIsImlkIjoiMVRYWUN0ejROakNjeTAybDl4WXlXZyIsIm5hbWUiOiJIb3NwaXRhbCBSZWNvcmRzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFUWFlDdHo0TmpDY3kwMmw5eFl5V2cifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wMVQ2VWtzWUdCNFg2RlpJcmdWRWdNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDFUNlVrc1lHQjRYNkZaSXJnVkVnTSIsImlkIjoiMDFUNlVrc1lHQjRYNkZaSXJnVkVnTSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmMDQyYmMwYTlmMzE4ZjI3NzY5NGFkNjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjA0MmJjMGE5ZjMxOGYyNzc2OTRhZDYxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmMDQyYmMwYTlmMzE4ZjI3NzY5NGFkNjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9zcGl0YWw6IFdlIEFyZSAyMSIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDEtMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3MCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowMVQ2VWtzWUdCNFg2RlpJcmdWRWdNIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkdIU2ZJbFVuS0V0SEg1R0JOaG1oYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yR0hTZklsVW5LRXRISDVHQk5obWhiIiwiaWQiOiIyR0hTZklsVW5LRXRISDVHQk5obWhiIiwibmFtZSI6IkRlYWRtYXU1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJHSFNmSWxVbktFdEhINUdCTmhtaGIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwiaWQiOiIxUQ==", + "TWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJuYW1lIjoiRGltZW5zaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzA4OTY1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JUREcxMzAxMTY2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83MVEyY1kxYzZpZzd0MEVDNUoydWZmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNzFRMmNZMWM2aWc3dDBFQzVKMnVmZiIsImlkIjoiNzFRMmNZMWM2aWc3dDBFQzVKMnVmZiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdHJvYmUgLSBEaW1lbnNpb24gUmVtaXgiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjcxUTJjWTFjNmlnN3QwRUM1SjJ1ZmYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsImlkIjoiMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsIm5hbWUiOiJkZWFkbWF1NSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQ0lNUUhpclNVME1RcXlZSHEwZU94In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdtQzNSa05OVFY2cDJqOXc0RjhJcDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN21DM1JrTk5UVjZwMmo5dzRGOElwNCIsImlkIjoiN21DM1JrTk5UVjZwMmo5dzRGOElwNCIsIm5hbWUiOiJMYXl0b24gR2lvcmRhbmkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N21DM1JrTk5UVjZwMmo5dzRGOElwNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJsQTZMUHRyOU8wSHdOTERZRXp6am0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8ybEE2TFB0cjlPMEh3TkxEWUV6emptIiwiaWQiOiIybEE2TFB0cjlPMEh3TkxEWUV6emptIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2QwMDI3OWUzMw==", + "NWZjODI2M2UwY2IzZWYxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQwMDI3OWUzMzVmYzgyNjNlMGNiM2VmMSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDAwMjc5ZTMzNWZjODI2M2UwY2IzZWYxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0cm9iZSAoTGF5dG9uIEdpb3JkYW5pIFJlbWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDktMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJsQTZMUHRyOU8wSHdOTERZRXp6am0ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQ0lNUUhpclNVME1RcXlZSHEwZU94In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJpZCI6IjJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJuYW1lIjoiZGVhZG1hdTUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83bUMzUmtOTlRWNnAyajl3NEY4SXA0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdtQzNSa05OVFY2cDJqOXc0RjhJcDQiLCJpZCI6IjdtQzNSa05OVFY2cDJqOXc0RjhJcDQiLCJuYW1lIjoiTGF5dG9uIEdpb3JkYW5pIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdtQzNSa05OVFY2cDJqOXc0RjhJcDQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE1MTU2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JUREcxMzAyODYwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yU285dklUb3Zrb3Z2eGxWZXJaY2N6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMlNvOXZJVG92a292dnhsVmVyWmNjeiIsImlkIjoiMlNvOXZJVG92a292dnhsVmVyWmNjeiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdHJvYmUgLSBMYXl0b24gR2lvcmRhbmkgUmVtaXgiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MlNvOXZJVG92a292dnhsVg==", + "ZXJaY2N6In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzIwU2Rsend6eklZZUN4R0kzVG5EbjcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yMFNkbHp3enpJWWVDeEdJM1RuRG43IiwiaWQiOiIyMFNkbHp3enpJWWVDeEdJM1RuRG43IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRlZmQ2OGI2MGJkYTMzOWE4OTkyNzM0ZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0ZWZkNjhiNjBiZGEzMzlhODk5MjczNGQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRlZmQ2OGI2MGJkYTMzOWE4OTkyNzM0ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJtYXU1dHJhcCAnMTYiLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTEyLTMwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MjBTZGx6d3p6SVllQ3hHSTNUbkRuNyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsImlkIjoiMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsIm5hbWUiOiJkZWFkbWF1NSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQ0lNUUhpclNVME1RcXlZSHEwZU94In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI3Z3RLN205dll3Q3lKMDR6ejBrSWIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLg==", + "c3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yN2d0SzdtOXZZd0N5SjA0enowa0liIiwiaWQiOiIyN2d0SzdtOXZZd0N5SjA0enowa0liIiwibmFtZSI6IkxhbmUgOCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyN2d0SzdtOXZZd0N5SjA0enowa0liIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQzNzQxOSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVERHMTMwMTE2NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMmM3MU03Mzc5Y29Uc1o5NUdld0ZnTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJjNzFNNzM3OWNvVHNaOTVHZXdGZ08iLCJpZCI6IjJjNzFNNzM3OWNvVHNaOTVHZXdGZ08iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3Ryb2JlIC0gTGFuZSA4IFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxNCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyYzcxTTczNzljb1RzWjk1R2V3RmdPIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQ0lNUUhpclNVME1RcXlZSHEwZU94In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJpZCI6IjJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJuYW1lIjoiZGVhZG1hdTUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wWjd6Y3NJcGhyUERuZlpqOVBwcXcwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBaN3pjc0lwaHJQRG5mWmo5UHBxdzAiLCJpZCI6IjBaN3pjc0lwaHJQRG5mWmo5UHBxdzAiLCJuYW1lIjoiJmZyaWVuZHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFo3emNzSXBoclBEbmZaajlQcHF3MCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xZHE4Q0VVU05UUE44MXVwMmxWd25tIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFkcThDRVVTTlRQTjgxdXAybFZ3bm0iLCJpZCI6IjFkcThDRVVTTlRQTjgxdXAybFZ3bm0iLCJuYW1lIjoiTW9lYWlrZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5Og==", + "YXJ0aXN0OjFkcThDRVVTTlRQTjgxdXAybFZ3bm0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82RzJ4ZGdnckpUSzdRMHN6WUU4WUFjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNkcyeGRnZ3JKVEs3UTBzellFOFlBYyIsImlkIjoiNkcyeGRnZ3JKVEs3UTBzellFOFlBYyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyNjY2NGQ5OWRkMmEyZWM1ZjA2ODZhMGYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMjY2NjRkOTlkZDJhMmVjNWYwNjg2YTBmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyNjY2NGQ5OWRkMmEyZWM1ZjA2ODZhMGYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3Ryb2JlICgmZnJpZW5kcywgTW9lYWlrZSBSZXRha2UpIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0xMi0wNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkcyeGRnZ3JKVEs3UTBzellFOFlBYyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsImlkIjoiMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsIm5hbWUiOiJkZWFkbWF1NSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQ0lNUUhpclNVME1RcXlZSHEwZU94In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBaN3pjc0lwaHJQRG5mWmo5UHBxdzAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFo3emNzSXBoclBEbmZaajlQcHF3MCIsImlkIjoiMFo3emNzSXBoclBEbmZaajlQcHF3MCIsIm5hbWUiOiImZnJpZW5kcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowWjd6Y3NJcGhyUERuZlpqOVBwcXcwIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFkcThDRVVTTlRQTjgxdXAybFZ3bm0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tLw==", + "djEvYXJ0aXN0cy8xZHE4Q0VVU05UUE44MXVwMmxWd25tIiwiaWQiOiIxZHE4Q0VVU05UUE44MXVwMmxWd25tIiwibmFtZSI6Ik1vZWFpa2UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MWRxOENFVVNOVFBOODF1cDJsVndubSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozNTgwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJDQTVLUjI2MDE2MDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVzRTBoSngydkRLVElVc1BPMjdxdFQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81c0UwaEp4MnZES1RJVXNQTzI3cXRUIiwiaWQiOiI1c0UwaEp4MnZES1RJVXNQTzI3cXRUIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0cm9iZSAtICZmcmllbmRzLCBNb2VhaWtlIFJldGFrZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1c0UwaEp4MnZES1RJVXNQTzI3cXRUIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQ0lNUUhpclNVME1RcXlZSHEwZU94In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJpZCI6IjJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJuYW1lIjoiZGVhZG1hdTUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83bUMzUmtOTlRWNnAyajl3NEY4SXA0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdtQzNSa05OVFY2cDJqOXc0RjhJcDQiLCJpZCI6IjdtQzNSa05OVFY2cDJqOXc0RjhJcDQiLCJuYW1lIjoiTGF5dG9uIEdpb3JkYW5pIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdtQzNSa05OVFY2cDJqOXc0RjhJcDQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5z", + "cG90aWZ5LmNvbS9hbGJ1bS8ybEE2TFB0cjlPMEh3TkxEWUV6emptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMmxBNkxQdHI5TzBId05MRFlFenpqbSIsImlkIjoiMmxBNkxQdHI5TzBId05MRFlFenpqbSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkMDAyNzllMzM1ZmM4MjYzZTBjYjNlZjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZDAwMjc5ZTMzNWZjODI2M2UwY2IzZWYxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkMDAyNzllMzM1ZmM4MjYzZTBjYjNlZjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3Ryb2JlIChMYXl0b24gR2lvcmRhbmkgUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wOS0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MmxBNkxQdHI5TzBId05MRFlFenpqbSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsImlkIjoiMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsIm5hbWUiOiJkZWFkbWF1NSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQ0lNUUhpclNVME1RcXlZSHEwZU94In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjYzNDQ2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVERHMDkwMDE0MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHhHYVp4Wno1M0NYQWJyWnQ5djJxYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzB4R2FaeFp6NTNDWEFiclp0OXYycWIiLCJpZCI6IjB4R2FaeFp6NTNDWEFiclp0OXYycWIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3Ryb2JlIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjB4R2FaeFp6NTNDWEFiclp0OXYycWIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybA==", + "cyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQ0lNUUhpclNVME1RcXlZSHEwZU94In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJpZCI6IjJDSU1RSGlyU1UwTVFxeVlIcTBlT3giLCJuYW1lIjoiZGVhZG1hdTUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkNJTVFIaXJTVTBNUXF5WUhxMGVPeCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzR1S0ZOcjNLTnFyNHplTFdKZkJDNjYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80dUtGTnIzS05xcjR6ZUxXSmZCQzY2IiwiaWQiOiI0dUtGTnIzS05xcjR6ZUxXSmZCQzY2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzk5YjM5MDRiNDEyNDc4ZWUyNDI5ZDk3OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5OWIzOTA0YjQxMjQ3OGVlMjQyOWQ5NzgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTk5YjM5MDRiNDEyNDc4ZWUyNDI5ZDk3OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiI1IHllYXJzIG9mIG1hdTUiLCJyZWxlYXNlX2RhdGUiOiIyMDE0LTExLTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NHVLRk5yM0tOcXI0emVMV0pmQkM2NiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJDSU1RSGlyU1UwTVFxeVlIcTBlT3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsImlkIjoiMkNJTVFIaXJTVTBNUXF5WUhxMGVPeCIsIm5hbWUiOiJkZWFkbWF1NSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQ0lNUUhpclNVME1RcXlZSHEwZU94In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNHMVFvV2thWjFDVW5UTFViMENxdEMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0cxUW9Xa2FaMUNVblRMVWIwQ3F0QyIsImlkIjoiM0cxUW9Xa2FaMUNVblRMVWIwQ3F0Qw==", + "IiwibmFtZSI6Ik1pY2hhZWwgV29vZHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0cxUW9Xa2FaMUNVblRMVWIwQ3F0QyJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjo0MzIyNzksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlRERzEzMDA3MjYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRuUHVjak5ReVd3VTlCVXRrWE80ZGYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80blB1Y2pOUXlXd1U5QlV0a1hPNGRmIiwiaWQiOiI0blB1Y2pOUXlXd1U5QlV0a1hPNGRmIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0cm9iZSAtIE1pY2hhZWwgV29vZHMgMjAxNCBSZW1peCIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0blB1Y2pOUXlXd1U5QlV0a1hPNGRmIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Strobe%22+artist%3A%22Deadmau5%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22To%20Build%20a%20Home%22%20artist%3A%22The%20Cinematic%20Orchestra%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"}],"external_urls":{"spotify":"https://open.spotify.com/album/5cPHT4yMCfETLRYAoBFcOZ"},"href":"https://api.spotify.com/v1/albums/5cPHT4yMCfETLRYAoBFcOZ","id":"5cPHT4yMCfETLRYAoBFcOZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f04457d8ce4be7b714f35cb1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f04457d8ce4be7b714f35cb1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f04457d8ce4be7b714f35cb1"}],"is_playable":true,"name":"Ma Fleur","release_date":"2007-05-07","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5cPHT4yMCfETLRYAoBFcOZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7bPs6jf983f0bjRAt1yxDM"},"href":"https://api.spotify.com/v1/artists/7bPs6jf983f0bjRAt1yxDM","id":"7bPs6jf983f0bjRAt1yxDM","name":"Patrick Watson","type":"artist","uri":"spotify:artist:7bPs6jf983f0bjRAt1yxDM"}],"disc_number":1,"duration_ms":371320,"explicit":false,"external_ids":{"isrc":"GBCFB0700100"},"external_urls":{"spotify":"https://open.spotify.com/track/54KFQB6N4pn926IUUYZGzK"},"href":"https://api.spotify.com/v1/tracks/54KFQB6N4pn926IUUYZGzK","id":"54KFQB6N4pn926IUUYZGzK","is_local":false,"is_playable":true,"name":"To Build A Home","track_number":1,"type":"track","uri":"spotify:track:54KFQB6N4pn926IUUYZGzK"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"}],"external_urls":{"spotify":"https://open.spotify.com/album/52bYfn1wSbaRAQKq0Ox3DW"},"href":"https://api.spotify.com/v1/albums/52bYfn1wSbaRAQKq0Ox3DW","id":"52bYfn1wSbaRAQKq0Ox3DW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730eb232a1b19b8c8139645a82"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020eb232a1b19b8c8139645a82"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510eb232a1b19b8c8139645a82"}],"is_playable":true,"name":"To Build A Home (Versions)","release_date":"2007-10-29","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:52bYfn1wSbaRAQKq0Ox3DW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7bPs6jf983f0bjRAt1yxDM"},"href":"https://api.spotify.com/v1/artists/7bPs6jf983f0bjRAt1yxDM","id":"7bPs6jf983f0bjRAt1yxDM","name":"Patrick Watson","type":"artist","uri":"spotify:artist:7bPs6jf983f0bjRAt1yxDM"}],"disc_number":1,"duration_ms":176733,"explicit":false,"external_ids":{"isrc":"GBCFB0700117"},"external_urls":{"spotify":"https://open.spotify.com/track/3rrqERTe9MIi5wq2qlJg5S"},"href":"https://api.spotify.com/v1/tracks/3rrqERTe9MIi5wq2qlJg5S","id":"3rrqERTe9MIi5wq2qlJg5S","is_local":false,"is_playable":true,"name":"To Build A Home - Album Edit","track_number":3,"type":"track","uri":"spotify:track:3rrqERTe9MIi5wq2qlJg5S"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"}],"external_urls":{"spotify":"https://open.spotify.com/album/52bYfn1wSbaRAQKq0Ox3DW"},"href":"https://api.spotify.com/v1/albums/52bYfn1wSbaRAQKq0Ox3DW","id":"52bYfn1wSbaRAQKq0Ox3DW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730eb232a1b19b8c8139645a82"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020eb232a1b19b8c8139645a82"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510eb232a1b19b8c8139645a82"}],"is_playable":true,"name":"To Build A Home (Versions)","release_date":"2007-10-29","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:52bYfn1wSbaRAQKq0Ox3DW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7bPs6jf983f0bjRAt1yxDM"},"href":"https://api.spotify.com/v1/artists/7bPs6jf983f0bjRAt1yxDM","id":"7bPs6jf983f0bjRAt1yxDM","name":"Patrick Watson","type":"artist","uri":"spotify:artist:7bPs6jf983f0bjRAt1yxDM"}],"disc_number":1,"duration_ms":195840,"explicit":false,"external_ids":{"isrc":"GBCFB0700115"},"external_urls":{"spotify":"https://open.spotify.com/track/7Be9cNPULGS5gzWU9LJo7a"},"href":"https://api.spotify.com/v1/tracks/7Be9cNPULGS5gzWU9LJo7a","id":"7Be9cNPULGS5gzWU9LJo7a","is_local":false,"is_playable":true,"name":"To Build A Home - Radio Version","track_number":1,"type":"track","uri":"spotify:track:7Be9cNPULGS5gzWU9LJo7a"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"}],"external_urls":{"spotify":"https://open.spotify.com/album/52bYfn1wSbaRAQKq0Ox3DW"},"href":"https://api.spotify.com/v1/albums/52bYfn1wSbaRAQKq0Ox3DW","id":"52bYfn1wSbaRAQKq0Ox3DW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730eb232a1b19b8c8139645a82"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020eb232a1b19b8c8139645a82"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510eb232a1b19b8c8139645a82"}],"is_playable":true,"name":"To Build A Home (Versions)","release_date":"2007-10-29","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:52bYfn1wSbaRAQKq0Ox3DW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7bPs6jf983f0bjRAt1yxDM"},"href":"https://api.spotify.com/v1/artists/7bPs6jf983f0bjRAt1yxDM","id":"7bPs6jf983f0bjRAt1yxDM","name":"Patrick Watson","type":"artist","uri":"spotify:artist:7bPs6jf983f0bjRAt1yxDM"}],"disc_number":1,"duration_ms":371320,"explicit":false,"external_ids":{"isrc":"GBCFB0700100"},"external_urls":{"spotify":"https://open.spotify.com/track/6LK4QAJzm6wPWITxSftVhG"},"href":"https://api.spotify.com/v1/tracks/6LK4QAJzm6wPWITxSftVhG","id":"6LK4QAJzm6wPWITxSftVhG","is_local":false,"is_playable":true,"name":"To Build A Home","track_number":4,"type":"track","uri":"spotify:track:6LK4QAJzm6wPWITxSftVhG"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"}],"external_urls":{"spotify":"https://open.spotify.com/album/52bYfn1wSbaRAQKq0Ox3DW"},"href":"https://api.spotify.com/v1/albums/52bYfn1wSbaRAQKq0Ox3DW","id":"52bYfn1wSbaRAQKq0Ox3DW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730eb232a1b19b8c8139645a82"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020eb232a1b19b8c8139645a82"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510eb232a1b19b8c8139645a82"}],"is_playable":true,"name":"To Build A Home (Versions)","release_date":"2007-10-29","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:52bYfn1wSbaRAQKq0Ox3DW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"}],"disc_number":1,"duration_ms":220413,"explicit":false,"external_ids":{"isrc":"GBCFB0700116"},"external_urls":{"spotify":"https://open.spotify.com/track/5uI1SBs75p33rmgQAD6TaJ"},"href":"https://api.spotify.com/v1/tracks/5uI1SBs75p33rmgQAD6TaJ","id":"5uI1SBs75p33rmgQAD6TaJ","is_local":false,"is_playable":true,"name":"To Build A Home - Grey Reverend Version","track_number":2,"type":"track","uri":"spotify:track:5uI1SBs75p33rmgQAD6TaJ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3md9g6iigJX0oMNa2Ox4zb"},"href":"https://api.spotify.com/v1/albums/3md9g6iigJX0oMNa2Ox4zb","id":"3md9g6iigJX0oMNa2Ox4zb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c38640807989171ba9516e54"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c38640807989171ba9516e54"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c38640807989171ba9516e54"}],"is_playable":true,"name":"You Don't Know - Ninja Cuts","release_date":"2008-03-03","release_date_precision":"day","total_tracks":47,"type":"album","uri":"spotify:album:3md9g6iigJX0oMNa2Ox4zb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"}],"disc_number":1,"duration_ms":195840,"explicit":false,"external_ids":{"isrc":"GBCFB0700115"},"external_urls":{"spotify":"https://open.spotify.com/track/1cv0rcdgyrdY1CqFBdXXKo"},"href":"https://api.spotify.com/v1/tracks/1cv0rcdgyrdY1CqFBdXXKo","id":"1cv0rcdgyrdY1CqFBdXXKo","is_local":false,"is_playable":true,"name":"To Build A Home - Radio Version","track_number":11,"type":"track","uri":"spotify:track:1cv0rcdgyrdY1CqFBdXXKo"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Sb1VSWBTyV7L4AWXZz28b"},"href":"https://api.spotify.com/v1/albums/4Sb1VSWBTyV7L4AWXZz28b","id":"4Sb1VSWBTyV7L4AWXZz28b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f12b72c3af2f368f29e74b34"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f12b72c3af2f368f29e74b34"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f12b72c3af2f368f29e74b34"}],"is_playable":true,"name":"LIVE at The Royal Albert Hall","release_date":"2008","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:4Sb1VSWBTyV7L4AWXZz28b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/32ogthv0BdaSMPml02X9YB"},"href":"https://api.spotify.com/v1/artists/32ogthv0BdaSMPml02X9YB","id":"32ogthv0BdaSMPml02X9YB","name":"The Cinematic Orchestra","type":"artist","uri":"spotify:artist:32ogthv0BdaSMPml02X9YB"}],"disc_number":1,"duration_ms":465986,"explicit":false,"external_ids":{"isrc":"GBCFB0801004"},"external_urls":{"spotify":"https://open.spotify.com/track/46nH6n6CYIsz3qqam9qn4q"},"href":"https://api.spotify.com/v1/tracks/46nH6n6CYIsz3qqam9qn4q","id":"46nH6n6CYIsz3qqam9qn4q","is_local":false,"is_playable":true,"name":"To Build A Home","track_number":5,"type":"track","uri":"spotify:track:46nH6n6CYIsz3qqam9qn4q"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRvJTIwQnVpbGQlMjBhJTIwSG9tZSUyMiUyMGFydGlzdCUzQSUyMlRoZSUyMENpbmVtYXRpYyUyME9yY2hlc3RyYSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwiaWQiOiIzMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwibmFtZSI6IlRoZSBDaW5lbWF0aWMgT3JjaGVzdHJhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjMyb2d0aHYwQmRhU01QbWwwMlg5WUIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81Y1BIVDR5TUNmRVRMUllBb0JGY09aIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWNQSFQ0eU1DZkVUTFJZQW9CRmNPWiIsImlkIjoiNWNQSFQ0eU1DZkVUTFJZQW9CRmNPWiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAs", + "IndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmMDQ0NTdkOGNlNGJlN2I3MTRmMzVjYjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjA0NDU3ZDhjZTRiZTdiNzE0ZjM1Y2IxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmMDQ0NTdkOGNlNGJlN2I3MTRmMzVjYjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWEgRmxldXIiLCJyZWxlYXNlX2RhdGUiOiIyMDA3LTA1LTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWNQSFQ0eU1DZkVUTFJZQW9CRmNPWiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzMyb2d0aHYwQmRhU01QbWwwMlg5WUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiIsImlkIjoiMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiIsIm5hbWUiOiJUaGUgQ2luZW1hdGljIE9yY2hlc3RyYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozMm9ndGh2MEJkYVNNUG1sMDJYOVlCIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdiUHM2amY5ODNmMGJqUkF0MXl4RE0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2JQczZqZjk4M2YwYmpSQXQxeXhETSIsImlkIjoiN2JQczZqZjk4M2YwYmpSQXQxeXhETSIsIm5hbWUiOiJQYXRyaWNrIFdhdHNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3YlBzNmpmOTgzZjBialJBdDF5eERNIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjM3MTMyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQ0ZCMDcwMDEwMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNTRLRlFCNk40cG45MjZJVVVZWkd6SyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzU0S0ZRQjZONHBuOTI2SVVVWVpHeksiLCJpZCI6IjU0S0ZRQjZONHBuOTI2SVVVWVpHeksiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVG8gQnVpbGQgQSBIb21lIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIg==", + "OiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NTRLRlFCNk40cG45MjZJVVVZWkd6SyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwiaWQiOiIzMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwibmFtZSI6IlRoZSBDaW5lbWF0aWMgT3JjaGVzdHJhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjMyb2d0aHYwQmRhU01QbWwwMlg5WUIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81MmJZZm4xd1NiYVJBUUtxME94M0RXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNTJiWWZuMXdTYmFSQVFLcTBPeDNEVyIsImlkIjoiNTJiWWZuMXdTYmFSQVFLcTBPeDNEVyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZWIyMzJhMWIxOWI4YzgxMzk2NDVhODIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGViMjMyYTFiMTliOGM4MTM5NjQ1YTgyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwZWIyMzJhMWIxOWI4YzgxMzk2NDVhODIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVG8gQnVpbGQgQSBIb21lIChWZXJzaW9ucykiLCJyZWxlYXNlX2RhdGUiOiIyMDA3LTEwLTI5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1MmJZZm4xd1NiYVJBUUtxME94M0RXIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwiaWQiOiIzMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwibmFtZSI6IlRoZSBDaW5lbWF0aWMgT3JjaGVzdHJhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjMyb2d0aHYwQmRhU01QbWwwMlg5WUIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Ig==", + "aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83YlBzNmpmOTgzZjBialJBdDF5eERNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdiUHM2amY5ODNmMGJqUkF0MXl4RE0iLCJpZCI6IjdiUHM2amY5ODNmMGJqUkF0MXl4RE0iLCJuYW1lIjoiUGF0cmljayBXYXRzb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N2JQczZqZjk4M2YwYmpSQXQxeXhETSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzY3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkNGQjA3MDAxMTcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNycnFFUlRlOU1JaTV3cTJxbEpnNVMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zcnJxRVJUZTlNSWk1d3EycWxKZzVTIiwiaWQiOiIzcnJxRVJUZTlNSWk1d3EycWxKZzVTIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvIEJ1aWxkIEEgSG9tZSAtIEFsYnVtIEVkaXQiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M3JycUVSVGU5TUlpNXdxMnFsSmc1UyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwiaWQiOiIzMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwibmFtZSI6IlRoZSBDaW5lbWF0aWMgT3JjaGVzdHJhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjMyb2d0aHYwQmRhU01QbWwwMlg5WUIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81MmJZZm4xd1NiYVJBUUtxME94M0RXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNTJiWWZuMXdTYmFSQVFLcTBPeDNEVyIsImlkIjoiNTJiWWZuMXdTYmFSQVFLcTBPeDNEVyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZWIyMzJhMWIxOWI4YzgxMzk2NDVhODIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGViMjMyYTFiMTliOGM4MTM5NjQ1YTgyIg==", + "fSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTBlYjIzMmExYjE5YjhjODEzOTY0NWE4MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUbyBCdWlsZCBBIEhvbWUgKFZlcnNpb25zKSIsInJlbGVhc2VfZGF0ZSI6IjIwMDctMTAtMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjUyYllmbjF3U2JhUkFRS3EwT3gzRFcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzMyb2d0aHYwQmRhU01QbWwwMlg5WUIiLCJpZCI6IjMyb2d0aHYwQmRhU01QbWwwMlg5WUIiLCJuYW1lIjoiVGhlIENpbmVtYXRpYyBPcmNoZXN0cmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MzJvZ3RodjBCZGFTTVBtbDAyWDlZQiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83YlBzNmpmOTgzZjBialJBdDF5eERNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdiUHM2amY5ODNmMGJqUkF0MXl4RE0iLCJpZCI6IjdiUHM2amY5ODNmMGJqUkF0MXl4RE0iLCJuYW1lIjoiUGF0cmljayBXYXRzb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N2JQczZqZjk4M2YwYmpSQXQxeXhETSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTU4NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkNGQjA3MDAxMTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdCZTljTlBVTEdTNWd6V1U5TEpvN2EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83QmU5Y05QVUxHUzVneldVOUxKbzdhIiwiaWQiOiI3QmU5Y05QVUxHUzVneldVOUxKbzdhIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvIEJ1aWxkIEEgSG9tZSAtIFJhZGlvIFZlcnNpb24iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N0JlOWNOUFVMR1M1Z3pXVTlMSm83YSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbQ==", + "L2FydGlzdC8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzMyb2d0aHYwQmRhU01QbWwwMlg5WUIiLCJpZCI6IjMyb2d0aHYwQmRhU01QbWwwMlg5WUIiLCJuYW1lIjoiVGhlIENpbmVtYXRpYyBPcmNoZXN0cmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MzJvZ3RodjBCZGFTTVBtbDAyWDlZQiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzUyYllmbjF3U2JhUkFRS3EwT3gzRFcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81MmJZZm4xd1NiYVJBUUtxME94M0RXIiwiaWQiOiI1MmJZZm4xd1NiYVJBUUtxME94M0RXIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzBlYjIzMmExYjE5YjhjODEzOTY0NWE4MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwZWIyMzJhMWIxOWI4YzgxMzk2NDVhODIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTBlYjIzMmExYjE5YjhjODEzOTY0NWE4MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUbyBCdWlsZCBBIEhvbWUgKFZlcnNpb25zKSIsInJlbGVhc2VfZGF0ZSI6IjIwMDctMTAtMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjUyYllmbjF3U2JhUkFRS3EwT3gzRFcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzMyb2d0aHYwQmRhU01QbWwwMlg5WUIiLCJpZCI6IjMyb2d0aHYwQmRhU01QbWwwMlg5WUIiLCJuYW1lIjoiVGhlIENpbmVtYXRpYyBPcmNoZXN0cmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MzJvZ3RodjBCZGFTTVBtbDAyWDlZQiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83YlBzNmpmOTgzZjBialJBdDF5eERNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdiUHM2amY5ODNmMGJqUkF0MXl4RE0iLCJpZCI6IjdiUHM2amY5ODNmMGJqUkF0MXl4RA==", + "TSIsIm5hbWUiOiJQYXRyaWNrIFdhdHNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3YlBzNmpmOTgzZjBialJBdDF5eERNIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjM3MTMyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQ0ZCMDcwMDEwMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNkxLNFFBSnptNndQV0lUeFNmdFZoRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZMSzRRQUp6bTZ3UFdJVHhTZnRWaEciLCJpZCI6IjZMSzRRQUp6bTZ3UFdJVHhTZnRWaEciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVG8gQnVpbGQgQSBIb21lIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZMSzRRQUp6bTZ3UFdJVHhTZnRWaEcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzMyb2d0aHYwQmRhU01QbWwwMlg5WUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiIsImlkIjoiMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiIsIm5hbWUiOiJUaGUgQ2luZW1hdGljIE9yY2hlc3RyYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozMm9ndGh2MEJkYVNNUG1sMDJYOVlCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNTJiWWZuMXdTYmFSQVFLcTBPeDNEVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzUyYllmbjF3U2JhUkFRS3EwT3gzRFciLCJpZCI6IjUyYllmbjF3U2JhUkFRS3EwT3gzRFciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMGViMjMyYTFiMTliOGM4MTM5NjQ1YTgyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjBlYjIzMmExYjE5YjhjODEzOTY0NWE4MiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMGViMjMyYTFiMTliOGM4MTM5NjQ1YTgyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvIEJ1aWxkIEEgSG9tZSAoVmVyc2lvbnMpIiwicmVsZWFzZQ==", + "X2RhdGUiOiIyMDA3LTEwLTI5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1MmJZZm4xd1NiYVJBUUtxME94M0RXIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwiaWQiOiIzMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwibmFtZSI6IlRoZSBDaW5lbWF0aWMgT3JjaGVzdHJhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjMyb2d0aHYwQmRhU01QbWwwMlg5WUIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjIwNDEzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JDRkIwNzAwMTE2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81dUkxU0JzNzVwMzNybWdRQUQ2VGFKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNXVJMVNCczc1cDMzcm1nUUFENlRhSiIsImlkIjoiNXVJMVNCczc1cDMzcm1nUUFENlRhSiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUbyBCdWlsZCBBIEhvbWUgLSBHcmV5IFJldmVyZW5kIFZlcnNpb24iLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXVJMVNCczc1cDMzcm1nUUFENlRhSiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zbWQ5ZzZpaWdKWDBvTU5hMk94NHpiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM21kOWc2aWlnSlgwb01OYTJPeDR6YiIsImlkIjoiM21kOWc2aWlnSlgwb01OYTJPeDR6YiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NA==", + "MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2MzODY0MDgwNzk4OTE3MWJhOTUxNmU1NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjMzg2NDA4MDc5ODkxNzFiYTk1MTZlNTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWMzODY0MDgwNzk4OTE3MWJhOTUxNmU1NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJZb3UgRG9uJ3QgS25vdyAtIE5pbmphIEN1dHMiLCJyZWxlYXNlX2RhdGUiOiIyMDA4LTAzLTAzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M21kOWc2aWlnSlgwb01OYTJPeDR6YiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzMyb2d0aHYwQmRhU01QbWwwMlg5WUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiIsImlkIjoiMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiIsIm5hbWUiOiJUaGUgQ2luZW1hdGljIE9yY2hlc3RyYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozMm9ndGh2MEJkYVNNUG1sMDJYOVlCIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NTg0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQ0ZCMDcwMDExNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMWN2MHJjZGd5cmRZMUNxRkJkWFhLbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFjdjByY2RneXJkWTFDcUZCZFhYS28iLCJpZCI6IjFjdjByY2RneXJkWTFDcUZCZFhYS28iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVG8gQnVpbGQgQSBIb21lIC0gUmFkaW8gVmVyc2lvbiIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MWN2MHJjZGd5cmRZMUNxRkJkWFhLbyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzMyb2d0aA==", + "djBCZGFTTVBtbDAyWDlZQiIsImlkIjoiMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiIsIm5hbWUiOiJUaGUgQ2luZW1hdGljIE9yY2hlc3RyYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozMm9ndGh2MEJkYVNNUG1sMDJYOVlCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFNiMVZTV0JUeVY3TDRBV1haejI4YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRTYjFWU1dCVHlWN0w0QVdYWnoyOGIiLCJpZCI6IjRTYjFWU1dCVHlWN0w0QVdYWnoyOGIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjEyYjcyYzNhZjJmMzY4ZjI5ZTc0YjM0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmYxMmI3MmMzYWYyZjM2OGYyOWU3NGIzNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjEyYjcyYzNhZjJmMzY4ZjI5ZTc0YjM0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxJVkUgYXQgVGhlIFJveWFsIEFsYmVydCBIYWxsIiwicmVsZWFzZV9kYXRlIjoiMjAwOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0U2IxVlNXQlR5VjdMNEFXWFp6MjhiIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzJvZ3RodjBCZGFTTVBtbDAyWDlZQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwiaWQiOiIzMm9ndGh2MEJkYVNNUG1sMDJYOVlCIiwibmFtZSI6IlRoZSBDaW5lbWF0aWMgT3JjaGVzdHJhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjMyb2d0aHYwQmRhU01QbWwwMlg5WUIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDY1OTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JDRkIwODAxMDA0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80Nm5INm42Q1lJc3ozcXFhbTlxbjRxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDZuSDZuNkNZSXN6M3FxYW05cW40cSIsImlkIjoiNDZuSDZuNkNZSXN6Mw==", + "cXFhbTlxbjRxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvIEJ1aWxkIEEgSG9tZSIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0Nm5INm42Q1lJc3ozcXFhbTlxbjRxIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22To+Build+a+Home%22+artist%3A%22The+Cinematic+Orchestra%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZlZWwlMjBUaGUlMjBXYXklMjBJJTIwRG8lMjIlMjBhcnRpc3QlM0ElMjJKdW5nbGUlMjBieSUyME5pZ2h0JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZlZWwlMjBUaGUlMjBXYXklMjBJJTIwRG8lMjIlMjBhcnRpc3QlM0ElMjJKdW5nbGUlMjBieSUyME5pZ2h0JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Feel+The+Way+I+Do%22+artist%3A%22Jungle+by+Night%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Svefn-g-englar%22%20artist%3A%22Sigur%20R%C3%B3s%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/1DMMv1Kmoli3Y9fVEZDUVC"},"href":"https://api.spotify.com/v1/albums/1DMMv1Kmoli3Y9fVEZDUVC","id":"1DMMv1Kmoli3Y9fVEZDUVC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737d5c9fa537845b71c4eb3b5e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027d5c9fa537845b71c4eb3b5e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517d5c9fa537845b71c4eb3b5e"}],"is_playable":true,"name":"\u00c1g\u00e6tis byrjun","release_date":"1999-06-12","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:1DMMv1Kmoli3Y9fVEZDUVC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/07eGxuz8bL6QMsRqEe1Adu"},"href":"https://api.spotify.com/v1/tracks/07eGxuz8bL6QMsRqEe1Adu","id":"07eGxuz8bL6QMsRqEe1Adu","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":2,"type":"track","uri":"spotify:track:07eGxuz8bL6QMsRqEe1Adu"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4rbWJkt4gXZI2UYvpNR0mD"},"href":"https://api.spotify.com/v1/albums/4rbWJkt4gXZI2UYvpNR0mD","id":"4rbWJkt4gXZI2UYvpNR0mD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731545458048822881d324fede"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021545458048822881d324fede"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511545458048822881d324fede"}],"is_playable":true,"name":"Beautiful Boy (Original Motion Picture Soundtrack)","release_date":"2018-10-12","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4rbWJkt4gXZI2UYvpNR0mD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/2GJ5oIaBXeChOaj7Hf6WbQ"},"href":"https://api.spotify.com/v1/tracks/2GJ5oIaBXeChOaj7Hf6WbQ","id":"2GJ5oIaBXeChOaj7Hf6WbQ","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":7,"type":"track","uri":"spotify:track:2GJ5oIaBXeChOaj7Hf6WbQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/6BXoPmD0Kz44HDYSLtRI9q"},"href":"https://api.spotify.com/v1/albums/6BXoPmD0Kz44HDYSLtRI9q","id":"6BXoPmD0Kz44HDYSLtRI9q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734b34a331e9474c59ae26c222"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024b34a331e9474c59ae26c222"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514b34a331e9474c59ae26c222"}],"is_playable":true,"name":"Inni (Live)","release_date":"2011-11-04","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6BXoPmD0Kz44HDYSLtRI9q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":612906,"explicit":false,"external_ids":{"isrc":"GBKEE1100203"},"external_urls":{"spotify":"https://open.spotify.com/track/6IGanUxtt3CGFiJLFglGxr"},"href":"https://api.spotify.com/v1/tracks/6IGanUxtt3CGFiJLFglGxr","id":"6IGanUxtt3CGFiJLFglGxr","is_local":false,"is_playable":true,"name":"Svefn-g-englar - Live","track_number":1,"type":"track","uri":"spotify:track:6IGanUxtt3CGFiJLFglGxr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/1hsdmKm56vQXN8PBrvUSLr"},"href":"https://api.spotify.com/v1/albums/1hsdmKm56vQXN8PBrvUSLr","id":"1hsdmKm56vQXN8PBrvUSLr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376903e04946d513195eb47d3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276903e04946d513195eb47d3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176903e04946d513195eb47d3"}],"is_playable":true,"name":"\u00c1g\u00e6tis byrjun (A Good Beginning) [20th Anniversary Deluxe Edition]","release_date":"2019-07-05","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:1hsdmKm56vQXN8PBrvUSLr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/2zbH24Ds7VXzluXHSRcbLh"},"href":"https://api.spotify.com/v1/tracks/2zbH24Ds7VXzluXHSRcbLh","id":"2zbH24Ds7VXzluXHSRcbLh","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":2,"type":"track","uri":"spotify:track:2zbH24Ds7VXzluXHSRcbLh"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/01y5Yew2Pnd5NauKIz6lrw"},"href":"https://api.spotify.com/v1/albums/01y5Yew2Pnd5NauKIz6lrw","id":"01y5Yew2Pnd5NauKIz6lrw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27309526c8563b4f8888ff6e951"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0209526c8563b4f8888ff6e951"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485109526c8563b4f8888ff6e951"}],"is_playable":true,"name":"Svefn-g-englar","release_date":"1999-09-27","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:01y5Yew2Pnd5NauKIz6lrw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/30weME5lL9GkV7rf9kiQK7"},"href":"https://api.spotify.com/v1/tracks/30weME5lL9GkV7rf9kiQK7","id":"30weME5lL9GkV7rf9kiQK7","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":1,"type":"track","uri":"spotify:track:30weME5lL9GkV7rf9kiQK7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/3zz26ANSE8SJPX69CG9lP2"},"href":"https://api.spotify.com/v1/albums/3zz26ANSE8SJPX69CG9lP2","id":"3zz26ANSE8SJPX69CG9lP2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27390f415617a6f7f94a2e219e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0290f415617a6f7f94a2e219e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485190f415617a6f7f94a2e219e8"}],"is_playable":true,"name":"Svefn-g-englar","release_date":"1999-09-27","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:3zz26ANSE8SJPX69CG9lP2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/6LJTOcwvjU1NB5ttQ5elsL"},"href":"https://api.spotify.com/v1/tracks/6LJTOcwvjU1NB5ttQ5elsL","id":"6LJTOcwvjU1NB5ttQ5elsL","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":1,"type":"track","uri":"spotify:track:6LJTOcwvjU1NB5ttQ5elsL"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/0cb2WwdOVXluXMrlK2bw4c"},"href":"https://api.spotify.com/v1/albums/0cb2WwdOVXluXMrlK2bw4c","id":"0cb2WwdOVXluXMrlK2bw4c","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273992034eb7c533585038ab3f3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02992034eb7c533585038ab3f3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851992034eb7c533585038ab3f3"}],"is_playable":true,"name":"Svefn-g-englar (Live at \u00cdslenska \u00d3peran, 1999)","release_date":"2019-05-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0cb2WwdOVXluXMrlK2bw4c"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":566232,"explicit":false,"external_ids":{"isrc":"GBKEE1400344"},"external_urls":{"spotify":"https://open.spotify.com/track/3Q9kOnOmITjdTqRC4csQ96"},"href":"https://api.spotify.com/v1/tracks/3Q9kOnOmITjdTqRC4csQ96","id":"3Q9kOnOmITjdTqRC4csQ96","is_local":false,"is_playable":true,"name":"Svefn-g-englar - Live at \u00cdslenska \u00d3peran, 1999","track_number":1,"type":"track","uri":"spotify:track:3Q9kOnOmITjdTqRC4csQ96"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/1hsdmKm56vQXN8PBrvUSLr"},"href":"https://api.spotify.com/v1/albums/1hsdmKm56vQXN8PBrvUSLr","id":"1hsdmKm56vQXN8PBrvUSLr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376903e04946d513195eb47d3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276903e04946d513195eb47d3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176903e04946d513195eb47d3"}],"is_playable":true,"name":"\u00c1g\u00e6tis byrjun (A Good Beginning) [20th Anniversary Deluxe Edition]","release_date":"2019-07-05","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:1hsdmKm56vQXN8PBrvUSLr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":3,"duration_ms":710058,"explicit":false,"external_ids":{"isrc":"GBKEE1400348"},"external_urls":{"spotify":"https://open.spotify.com/track/1XmDy7zm9HVU5zMjwLK3Qv"},"href":"https://api.spotify.com/v1/tracks/1XmDy7zm9HVU5zMjwLK3Qv","id":"1XmDy7zm9HVU5zMjwLK3Qv","is_local":false,"is_playable":true,"name":"Svefn-g-englar - Live at Popp \u00ed Reykjav\u00edk, 1998","track_number":1,"type":"track","uri":"spotify:track:1XmDy7zm9HVU5zMjwLK3Qv"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/1hsdmKm56vQXN8PBrvUSLr"},"href":"https://api.spotify.com/v1/albums/1hsdmKm56vQXN8PBrvUSLr","id":"1hsdmKm56vQXN8PBrvUSLr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376903e04946d513195eb47d3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276903e04946d513195eb47d3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176903e04946d513195eb47d3"}],"is_playable":true,"name":"\u00c1g\u00e6tis byrjun (A Good Beginning) [20th Anniversary Deluxe Edition]","release_date":"2019-07-05","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:1hsdmKm56vQXN8PBrvUSLr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":2,"duration_ms":566232,"explicit":false,"external_ids":{"isrc":"GBKEE1400344"},"external_urls":{"spotify":"https://open.spotify.com/track/7mlRHOydTfhWYbKlGlqLXi"},"href":"https://api.spotify.com/v1/tracks/7mlRHOydTfhWYbKlGlqLXi","id":"7mlRHOydTfhWYbKlGlqLXi","is_local":false,"is_playable":true,"name":"Svefn-g-englar - Live at \u00cdslenska \u00d3peran, 1999","track_number":8,"type":"track","uri":"spotify:track:7mlRHOydTfhWYbKlGlqLXi"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Svefn-g-englar%22%20artist%3A%22Sigur%20R%C3%B3s%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/1DMMv1Kmoli3Y9fVEZDUVC"},"href":"https://api.spotify.com/v1/albums/1DMMv1Kmoli3Y9fVEZDUVC","id":"1DMMv1Kmoli3Y9fVEZDUVC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737d5c9fa537845b71c4eb3b5e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027d5c9fa537845b71c4eb3b5e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517d5c9fa537845b71c4eb3b5e"}],"is_playable":true,"name":"\u00c1g\u00e6tis byrjun","release_date":"1999-06-12","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:1DMMv1Kmoli3Y9fVEZDUVC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/07eGxuz8bL6QMsRqEe1Adu"},"href":"https://api.spotify.com/v1/tracks/07eGxuz8bL6QMsRqEe1Adu","id":"07eGxuz8bL6QMsRqEe1Adu","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":2,"type":"track","uri":"spotify:track:07eGxuz8bL6QMsRqEe1Adu"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4rbWJkt4gXZI2UYvpNR0mD"},"href":"https://api.spotify.com/v1/albums/4rbWJkt4gXZI2UYvpNR0mD","id":"4rbWJkt4gXZI2UYvpNR0mD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731545458048822881d324fede"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021545458048822881d324fede"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511545458048822881d324fede"}],"is_playable":true,"name":"Beautiful Boy (Original Motion Picture Soundtrack)","release_date":"2018-10-12","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:4rbWJkt4gXZI2UYvpNR0mD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/2GJ5oIaBXeChOaj7Hf6WbQ"},"href":"https://api.spotify.com/v1/tracks/2GJ5oIaBXeChOaj7Hf6WbQ","id":"2GJ5oIaBXeChOaj7Hf6WbQ","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":7,"type":"track","uri":"spotify:track:2GJ5oIaBXeChOaj7Hf6WbQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/6BXoPmD0Kz44HDYSLtRI9q"},"href":"https://api.spotify.com/v1/albums/6BXoPmD0Kz44HDYSLtRI9q","id":"6BXoPmD0Kz44HDYSLtRI9q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734b34a331e9474c59ae26c222"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024b34a331e9474c59ae26c222"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514b34a331e9474c59ae26c222"}],"is_playable":true,"name":"Inni (Live)","release_date":"2011-11-04","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6BXoPmD0Kz44HDYSLtRI9q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":612906,"explicit":false,"external_ids":{"isrc":"GBKEE1100203"},"external_urls":{"spotify":"https://open.spotify.com/track/6IGanUxtt3CGFiJLFglGxr"},"href":"https://api.spotify.com/v1/tracks/6IGanUxtt3CGFiJLFglGxr","id":"6IGanUxtt3CGFiJLFglGxr","is_local":false,"is_playable":true,"name":"Svefn-g-englar - Live","track_number":1,"type":"track","uri":"spotify:track:6IGanUxtt3CGFiJLFglGxr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/1hsdmKm56vQXN8PBrvUSLr"},"href":"https://api.spotify.com/v1/albums/1hsdmKm56vQXN8PBrvUSLr","id":"1hsdmKm56vQXN8PBrvUSLr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376903e04946d513195eb47d3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276903e04946d513195eb47d3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176903e04946d513195eb47d3"}],"is_playable":true,"name":"\u00c1g\u00e6tis byrjun (A Good Beginning) [20th Anniversary Deluxe Edition]","release_date":"2019-07-05","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:1hsdmKm56vQXN8PBrvUSLr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/2zbH24Ds7VXzluXHSRcbLh"},"href":"https://api.spotify.com/v1/tracks/2zbH24Ds7VXzluXHSRcbLh","id":"2zbH24Ds7VXzluXHSRcbLh","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":2,"type":"track","uri":"spotify:track:2zbH24Ds7VXzluXHSRcbLh"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/01y5Yew2Pnd5NauKIz6lrw"},"href":"https://api.spotify.com/v1/albums/01y5Yew2Pnd5NauKIz6lrw","id":"01y5Yew2Pnd5NauKIz6lrw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27309526c8563b4f8888ff6e951"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0209526c8563b4f8888ff6e951"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485109526c8563b4f8888ff6e951"}],"is_playable":true,"name":"Svefn-g-englar","release_date":"1999-09-27","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:01y5Yew2Pnd5NauKIz6lrw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/30weME5lL9GkV7rf9kiQK7"},"href":"https://api.spotify.com/v1/tracks/30weME5lL9GkV7rf9kiQK7","id":"30weME5lL9GkV7rf9kiQK7","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":1,"type":"track","uri":"spotify:track:30weME5lL9GkV7rf9kiQK7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/3zz26ANSE8SJPX69CG9lP2"},"href":"https://api.spotify.com/v1/albums/3zz26ANSE8SJPX69CG9lP2","id":"3zz26ANSE8SJPX69CG9lP2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27390f415617a6f7f94a2e219e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0290f415617a6f7f94a2e219e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485190f415617a6f7f94a2e219e8"}],"is_playable":true,"name":"Svefn-g-englar","release_date":"1999-09-27","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:3zz26ANSE8SJPX69CG9lP2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":606850,"explicit":false,"external_ids":{"isrc":"GBDCA9900067"},"external_urls":{"spotify":"https://open.spotify.com/track/6LJTOcwvjU1NB5ttQ5elsL"},"href":"https://api.spotify.com/v1/tracks/6LJTOcwvjU1NB5ttQ5elsL","id":"6LJTOcwvjU1NB5ttQ5elsL","is_local":false,"is_playable":true,"name":"Svefn-g-englar","track_number":1,"type":"track","uri":"spotify:track:6LJTOcwvjU1NB5ttQ5elsL"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/0cb2WwdOVXluXMrlK2bw4c"},"href":"https://api.spotify.com/v1/albums/0cb2WwdOVXluXMrlK2bw4c","id":"0cb2WwdOVXluXMrlK2bw4c","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273992034eb7c533585038ab3f3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02992034eb7c533585038ab3f3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851992034eb7c533585038ab3f3"}],"is_playable":true,"name":"Svefn-g-englar (Live at \u00cdslenska \u00d3peran, 1999)","release_date":"2019-05-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0cb2WwdOVXluXMrlK2bw4c"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":1,"duration_ms":566232,"explicit":false,"external_ids":{"isrc":"GBKEE1400344"},"external_urls":{"spotify":"https://open.spotify.com/track/3Q9kOnOmITjdTqRC4csQ96"},"href":"https://api.spotify.com/v1/tracks/3Q9kOnOmITjdTqRC4csQ96","id":"3Q9kOnOmITjdTqRC4csQ96","is_local":false,"is_playable":true,"name":"Svefn-g-englar - Live at \u00cdslenska \u00d3peran, 1999","track_number":1,"type":"track","uri":"spotify:track:3Q9kOnOmITjdTqRC4csQ96"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/1hsdmKm56vQXN8PBrvUSLr"},"href":"https://api.spotify.com/v1/albums/1hsdmKm56vQXN8PBrvUSLr","id":"1hsdmKm56vQXN8PBrvUSLr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376903e04946d513195eb47d3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276903e04946d513195eb47d3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176903e04946d513195eb47d3"}],"is_playable":true,"name":"\u00c1g\u00e6tis byrjun (A Good Beginning) [20th Anniversary Deluxe Edition]","release_date":"2019-07-05","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:1hsdmKm56vQXN8PBrvUSLr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":3,"duration_ms":710058,"explicit":false,"external_ids":{"isrc":"GBKEE1400348"},"external_urls":{"spotify":"https://open.spotify.com/track/1XmDy7zm9HVU5zMjwLK3Qv"},"href":"https://api.spotify.com/v1/tracks/1XmDy7zm9HVU5zMjwLK3Qv","id":"1XmDy7zm9HVU5zMjwLK3Qv","is_local":false,"is_playable":true,"name":"Svefn-g-englar - Live at Popp \u00ed Reykjav\u00edk, 1998","track_number":1,"type":"track","uri":"spotify:track:1XmDy7zm9HVU5zMjwLK3Qv"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"external_urls":{"spotify":"https://open.spotify.com/album/1hsdmKm56vQXN8PBrvUSLr"},"href":"https://api.spotify.com/v1/albums/1hsdmKm56vQXN8PBrvUSLr","id":"1hsdmKm56vQXN8PBrvUSLr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376903e04946d513195eb47d3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276903e04946d513195eb47d3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176903e04946d513195eb47d3"}],"is_playable":true,"name":"\u00c1g\u00e6tis byrjun (A Good Beginning) [20th Anniversary Deluxe Edition]","release_date":"2019-07-05","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:1hsdmKm56vQXN8PBrvUSLr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6UUrUCIZtQeOf8tC0WuzRy"},"href":"https://api.spotify.com/v1/artists/6UUrUCIZtQeOf8tC0WuzRy","id":"6UUrUCIZtQeOf8tC0WuzRy","name":"Sigur R\u00f3s","type":"artist","uri":"spotify:artist:6UUrUCIZtQeOf8tC0WuzRy"}],"disc_number":2,"duration_ms":566232,"explicit":false,"external_ids":{"isrc":"GBKEE1400344"},"external_urls":{"spotify":"https://open.spotify.com/track/7mlRHOydTfhWYbKlGlqLXi"},"href":"https://api.spotify.com/v1/tracks/7mlRHOydTfhWYbKlGlqLXi","id":"7mlRHOydTfhWYbKlGlqLXi","is_local":false,"is_playable":true,"name":"Svefn-g-englar - Live at \u00cdslenska \u00d3peran, 1999","track_number":8,"type":"track","uri":"spotify:track:7mlRHOydTfhWYbKlGlqLXi"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Svefn-g-englar%22+artist%3A%22Sigur+R%C3%B3s%22&type=track&limit=10" + } +] diff --git a/eval/fixtures/focus-coding/anthropic.json b/eval/fixtures/focus-coding/anthropic.json new file mode 100644 index 0000000..b2e06d7 --- /dev/null +++ b/eval/fixtures/focus-coding/anthropic.json @@ -0,0 +1,65 @@ +[ + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"query\":\"something calm for while I am programming, but not boring\",\"history\":[],\"prior_recommendations\":[],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"required_candidate_count\":35}"}],"model":"claude-sonnet-5","output_config":{"effort":"low","format":{"schema":{"$defs":{"CandidateOutput":{"type":"object","description":"One bounded candidate in the intent response.","title":"CandidateOutput","properties":{"title":{"type":"string","title":"Title","description":"{maxLength: 200, minLength: 1}"},"artist":{"type":"string","title":"Artist","description":"{maxLength: 200, minLength: 1}"}},"additionalProperties":false,"required":["title","artist"]},"Familiarity":{"type":"string","enum":["familiar","mix","new"],"description":"How strongly a request should favor known or unknown music.","title":"Familiarity"}},"type":"object","description":"Bounded structured output for the intent call.","title":"IntentOutput","properties":{"mood":{"type":"array","title":"Mood","items":{"type":"string"},"description":"{maxItems: 6}"},"activity":{"anyOf":[{"type":"string","description":"{maxLength: 100}"},{"type":"null"}],"title":"Activity","description":"{default: None}"},"era":{"type":"array","title":"Era","items":{"type":"string"},"description":"{maxItems: 5}"},"languages":{"type":"array","title":"Languages","items":{"type":"string"},"description":"{maxItems: 8}"},"genres":{"type":"array","title":"Genres","items":{"type":"string"},"description":"{maxItems: 8}"},"familiarity":{"$ref":"#/$defs/Familiarity"},"is_refinement":{"type":"boolean","title":"Is Refinement"},"intent_summary":{"type":"string","title":"Intent Summary","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"},"candidates":{"type":"array","title":"Candidates","items":{"$ref":"#/$defs/CandidateOutput"},"description":"{maxItems: 50, minItems: 10}"}},"additionalProperties":false,"required":["familiarity","is_refinement","intent_summary","candidates"]},"type":"json_schema"}},"system":[{"type":"text","text":"You are the intent interpreter and candidate generator for a music discovery system. Your job is to understand one listener request, use the supplied taste evidence carefully, and propose real recordings that another service can resolve against Spotify. Return only data that conforms to the provided output schema. Do not add prose before or after the structured response.\n\nInterpret the request in context. The variable input can contain a current query, a bounded conversation history, recommendations from an earlier response, and a compact taste profile. Treat the current query as authoritative. Use history only to resolve references, continuity, or explicit changes such as \"more like the third one\" or \"less energetic.\" Prior recommendations are evidence about what the listener has just seen, not proof that the listener likes every item. The Spotify taste profile is evidence of listening behavior, not a complete identity and not permission to stereotype the listener.\n\nPopulate every schema field honestly. Mood is a short bounded list of useful musical or emotional qualities. Activity is a concise listening context when one is stated or strongly implied, otherwise null. Era contains only time periods that matter to the request. Languages contains requested or strongly implied vocal languages; use an empty list when language is irrelevant or the music can be instrumental. Genres should be specific enough to guide selection without inventing a false precision. Familiarity must be familiar, mix, or new. Use familiar when the listener asks for comfort, favorites, known songs, or reliable crowd recognition. Use new when the listener asks for discovery, obscurity, unfamiliar music, or a departure from their habits. Use mix for a balanced bridge or when the request does not justify either extreme.\n\nSet is_refinement to true only when the listener is revising, narrowing, extending, or referring to an earlier recommendation result in the supplied conversation. A standalone request is not a refinement merely because history exists. The intent summary must be one plain-English sentence that tells the listener how the request was understood. It must not mention internal models, candidate generation, schemas, retrieval, or Spotify search behavior.\n\nGenerate the exact candidate count requested in the variable input. Each candidate contains only a track title and the credited artist name most likely to identify the recording. Choose recordings that plausibly exist in Spotify's catalog. Use canonical spellings. Do not fabricate tracks, mash up titles and artists, translate titles, or use descriptive placeholders. Avoid remixes, live versions, remasters, edits, sped-up versions, slowed versions, karaoke versions, covers, and tribute recordings unless the user explicitly asks for them. When several recordings share a title, choose the artist credit that makes the intended recording unambiguous.\n\nCandidate quality matters more than superficial variety. Every candidate should fit the interpreted mood, activity, era, language, genre, and familiarity. Still, spread the set across artists. Do not let one artist dominate the candidate list, even when that artist appears prominently in the taste profile. Avoid duplicate titles by the same artist and avoid multiple editions of the same recording. Use a range of strong fits so a later ranking step has meaningful choices rather than thirty near-identical songs.\n\nWhen familiarity leans new, propose music the listener plausibly does not know. Move beyond the named top artists and tracks while retaining understandable bridges through genre, scene, production style, instrumentation, energy, era, or songwriting. Do not simply select deep cuts from every familiar artist. Prefer adjacent artists, overlooked catalogs, regional scenes, and credible cross-genre connections. The profile is not exhaustive, so never claim that a candidate is definitely unknown. When familiarity is familiar, candidates may include supplied top or saved tracks, but remain responsive to the current request. When familiarity is mix, combine recognizable anchors with adjacent discoveries rather than splitting into unrelated halves.\n\nUse musical knowledge conservatively. Base selection on durable, commonly knowable attributes of recordings. Do not invent listening statistics, personal memories, release stories, chart facts, cultural identities, lyrical meanings, or audio features. Do not infer sensitive traits from taste. Explicit safety or content constraints in the request are binding. If a request is broad, create a coherent interpretation instead of asking a question. If constraints conflict, prioritize explicit exclusions, then the current query, then history, then taste evidence.\n\nThe downstream resolver first tries an exact field-filtered search and then a fuzzy bare-text search. Help it succeed with correct title and artist spelling. It will reject weak title or artist matches, so substituting a vaguely related track wastes a candidate. Prefer a confidently identifiable recording over an obscure item whose title or credit you cannot state accurately. Do not include Spotify identifiers, album names, explanations, scores, or justifications in candidate objects.\n\nBefore returning, silently check that the response matches the schema, the candidate list has exactly the requested size, familiarity uses the allowed value, is_refinement reflects conversation continuity, the intent summary is one line, spellings are credible, artist distribution is broad, and no candidate violates an explicit exclusion. Return strictly the structured response and nothing else.\n","cache_control":{"type":"ephemeral"}}]}", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJtb2RlbCI6ImNsYXVkZS1zb25uZXQtNSIsImlkIjoibXNnXzAxMUNkdHVIdFdVZkFwWnhSWEpGTG14YiIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsIg==", + "Y29udGVudCI6W3sidHlwZSI6InRleHQiLCJ0ZXh0Ijoie1wibW9vZFwiOltcImNhbG1cIixcImZvY3VzZWRcIixcInNtb290aFwiLFwidW5vYnRydXNpdmVcIixcInN0ZWFkeVwiXSxcImFjdGl2aXR5XCI6XCJwcm9ncmFtbWluZ1wiLFwiZXJhXCI6W10sXCJsYW5ndWFnZXNcIjpbXSxcImdlbnJlc1wiOltcImNoaWxsaG9wXCIsXCJsb2ZpXCIsXCJsaXF1aWQgZHJ1bSBhbmQgYmFzc1wiLFwiZG93bnRlbXBvXCIsXCJpbnN0cnVtZW50YWwgc291bFwiXSxcImZhbWlsaWFyaXR5XCI6XCJtaXhcIixcImlzX3JlZmluZW1lbnRcIjpmYWxzZSxcImludGVudF9zdW1tYXJ5XCI6XCJZb3Ugd2FudCBjYWxtIGJ1dCBzdGlsbCBpbnRlcmVzdGluZyBiYWNrZ3JvdW5kIG11c2ljIGZvciBjb2RpbmcsIHNvIEknbSBibGVuZGluZyBzbW9vdGggbGlxdWlkIGRydW0gYW5kIGJhc3MgYW5kIGRvd250ZW1wbyBncm9vdmVzIHdpdGggc29tZSBsb3cta2V5IHNvdWxmdWwgYW5kIGluc3RydW1lbnRhbCBwaWNrcy5cIixcImNhbmRpZGF0ZXNcIjpbe1widGl0bGVcIjpcIlN0YXlcIixcImFydGlzdFwiOlwiSHlicmlkIE1pbmRzXCJ9LHtcInRpdGxlXCI6XCJGZWVsIFlvdXIgV2F5XCIsXCJhcnRpc3RcIjpcIkFsaXggUGVyZXpcIn0se1widGl0bGVcIjpcIkxvc2luZyBNeXNlbGZcIixcImFydGlzdFwiOlwiTFNCXCJ9LHtcInRpdGxlXCI6XCJGaXJlZmxpZXNcIixcImFydGlzdFwiOlwiTmV0c2t5XCJ9LHtcInRpdGxlXCI6XCJXYXRlclwiLFwiYXJ0aXN0XCI6XCJFdGhlcndvb2RcIn0se1widGl0bGVcIjpcIkZhbGxpbmcgU2tpZXNcIixcImFydGlzdFwiOlwiS2Vlbm9cIn0se1widGl0bGVcIjpcIkJyZWF0aGVcIixcImFydGlzdFwiOlwiUy5QLllcIn0se1widGl0bGVcIjpcIlNpbHZlclwiLFwiYXJ0aXN0XCI6XCJNaW5kIHZzIE1hY2hpbmVcIn0se1widGl0bGVcIjpcIkNvbG91cnNcIixcImFydGlzdFwiOlwiS2FzcmFcIn0se1widGl0bGVcIjpcIkF3YWtlXCIsXCJhcnRpc3RcIjpcIk51OkxvZ2ljXCJ9LHtcInRpdGxlXCI6XCJNaXNzaW5nXCIsXCJhcnRpc3RcIjpcIkZsb3dpZHVzXCJ9LHtcInRpdGxlXCI6XCJIb21lXCIsXCJhcnRpc3RcIjpcIkxlbnNcIn0se1widGl0bGVcIjpcIlNsb3cgRG93blwiLFwiYXJ0aXN0XCI6XCJTYWJyZVwifSx7XCJ0aXRsZVwiOlwiQ2FzaW9cIixcImFydGlzdFwiOlwiSnVuZ2xlXCJ9LHtcInRpdGxlXCI6XCJSZWRib25lXCIsXCJhcnRpc3RcIjpcIkNoaWxkaXNoIEdhbWJpbm9cIn0se1widGl0bGVcIjpcIk1vb24gU29uZ1wiLFwiYXJ0aXN0XCI6XCJQaG9lYmUgQnJpZGdlcnNcIn0se1widGl0bGVcIjpcIkthaWp1XCIsXCJhcnRpc3RcIjpcIlNha2FuYWN0aW9uXCJ9LHtcInRpdGxlXCI6XA==", + "IldoZW4gSSBHZXQgVGhlcmVcIixcImFydGlzdFwiOlwiQmlnIFdpbGRcIn0se1widGl0bGVcIjpcIlN1cmUgVGhpbmdcIixcImFydGlzdFwiOlwiTWlndWVsXCJ9LHtcInRpdGxlXCI6XCJMZXQncyBTdGF5IFRvZ2V0aGVyXCIsXCJhcnRpc3RcIjpcIkFsIEdyZWVuXCJ9LHtcInRpdGxlXCI6XCJTdXBlcmZseVwiLFwiYXJ0aXN0XCI6XCJDdXJ0aXMgTWF5ZmllbGRcIn0se1widGl0bGVcIjpcIk5hdHVyYWwgSGlnaFwiLFwiYXJ0aXN0XCI6XCJCbG9vZHN0b25lXCJ9LHtcInRpdGxlXCI6XCJTb24gb2YgYSBQcmVhY2hlciBNYW5cIixcImFydGlzdFwiOlwiRHVzdHkgU3ByaW5nZmllbGRcIn0se1widGl0bGVcIjpcIkRpZG4ndCBJIEJsb3cgWW91ciBNaW5kIFRoaXMgVGltZVwiLFwiYXJ0aXN0XCI6XCJUaGUgRGVsZm9uaWNzXCJ9LHtcInRpdGxlXCI6XCJHeXBzeVwiLFwiYXJ0aXN0XCI6XCJGbGVldHdvb2QgTWFjXCJ9LHtcInRpdGxlXCI6XCJFdmVyeXdoZXJlXCIsXCJhcnRpc3RcIjpcIkZsZWV0d29vZCBNYWNcIn0se1widGl0bGVcIjpcIlNvdXRoZXJuIE5pZ2h0c1wiLFwiYXJ0aXN0XCI6XCJHbGVuIENhbXBiZWxsXCJ9LHtcInRpdGxlXCI6XCJZb3VyIFNvbmdcIixcImFydGlzdFwiOlwiRWx0b24gSm9oblwifSx7XCJ0aXRsZVwiOlwiUmljaCBHaXJsXCIsXCJhcnRpc3RcIjpcIkRhcnlsIEhhbGwgJiBKb2huIE9hdGVzXCJ9LHtcInRpdGxlXCI6XCJXYWxraW5nIE9uIEEgRHJlYW1cIixcImFydGlzdFwiOlwiRW1waXJlIE9mIFRoZSBTdW5cIn0se1widGl0bGVcIjpcIkRlcHRoIENvZWZmaWNpZW50IEFjaWRcIixcImFydGlzdFwiOlwiQ0hSU1wifSx7XCJ0aXRsZVwiOlwiRmFuZ3NcIixcImFydGlzdFwiOlwiTmF0aGFuIE1pY2F5XCJ9LHtcInRpdGxlXCI6XCJUd2lsaWdodFwiLFwiYXJ0aXN0XCI6XCJHcmF5XCJ9LHtcInRpdGxlXCI6XCJEb3dudG93blwiLFwiYXJ0aXN0XCI6XCJHb2Rmb3JkXCJ9LHtcInRpdGxlXCI6XCJJIFJlbWVtYmVyXCIsXCJhcnRpc3RcIjpcIlRpYW5cIn1dfSJ9XSwic3RvcF9yZWFzb24iOiJlbmRfdHVybiIsInN0b3Bfc2VxdWVuY2UiOm51bGwsInN0b3BfZGV0YWlscyI6bnVsbCwidXNhZ2UiOnsiaW5wdXRfdG9rZW5zIjo0OTg5LCJjYWNoZV9jcmVhdGlvbl9pbnB1dF90b2tlbnMiOjI3ODMsImNhY2hlX3JlYWRfaW5wdXRfdG9rZW5zIjowLCJjYWNoZV9jcmVhdGlvbiI6eyJlcGhlbWVyYWxfNW1faW5wdXRfdG9rZW5zIjoyNzgzLCJlcGhlbWVyYWxfMWhfaW5wdXRfdG9rZW5zIjowfSwib3V0cHV0X3Rva2VucyI6OTgyLCJvdXRwdXRfdG9rZW5zX2RldGFpbHMiOnsidGhpbmtpbmdfdG9rZW5zIjowfSwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJpbmZlcmVuY2VfZ2VvIg==", + "OiJnbG9iYWwifX0=" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"intent\":{\"mood\":[\"calm\",\"focused\",\"smooth\",\"unobtrusive\",\"steady\"],\"activity\":\"programming\",\"era\":[],\"languages\":[],\"genres\":[\"chillhop\",\"lofi\",\"liquid drum and bass\",\"downtempo\",\"instrumental soul\"],\"familiarity\":\"mix\",\"intent_summary\":\"You want calm but still interesting background music for coding, so I'm blending smooth liquid drum and bass and downtempo grooves with some low-key soulful and instrumental picks.\"},\"grounded_pool\":[{\"track_id\":\"2nIixNuuV5eHCJydG5aYIB\",\"title\":\"Stay\",\"artists\":[\"Hybrid Minds\",\"Lily Denning\"]},{\"track_id\":\"44ZKnfWEkp7wPs035j4Tua\",\"title\":\"Casio\",\"artists\":[\"Jungle\"]},{\"track_id\":\"3vQ4T78TTMOjQXGfXVKQJo\",\"title\":\"Redbone\",\"artists\":[\"Childish Gambino\"]},{\"track_id\":\"46RNrAkGsqWTDrv2ZPOAbx\",\"title\":\"Moon Song\",\"artists\":[\"Phoebe Bridgers\"]},{\"track_id\":\"7sMRDjjwsB7wQEBOkdfg0i\",\"title\":\"Kaiju\",\"artists\":[\"sakanaction\"]},{\"track_id\":\"7nYClzzNY6f3EcfeDFNqhS\",\"title\":\"When I Get There\",\"artists\":[\"Big Wild\"]},{\"track_id\":\"0JXXNGljqupsJaZsgSbMZV\",\"title\":\"Sure Thing\",\"artists\":[\"Miguel\"]},{\"track_id\":\"63xdwScd1Ai1GigAwQxE8y\",\"title\":\"Let's Stay Together\",\"artists\":[\"Al Green\"]},{\"track_id\":\"4XsH9zBWPOCdXoH9ZDdS8r\",\"title\":\"Superfly\",\"artists\":[\"Curtis Mayfield\"]},{\"track_id\":\"7aKrysuyZvDnU3JwnlO3dd\",\"title\":\"Natural High\",\"artists\":[\"Bloodstone\"]},{\"track_id\":\"6ek9SiEj5a65WIs2EV7qiM\",\"title\":\"Son Of A Preacher Man\",\"artists\":[\"Dusty Springfield\"]},{\"track_id\":\"19Ym5Sg0YyOCa6ao21bdoG\",\"title\":\"Gypsy\",\"artists\":[\"Fleetwood Mac\"]},{\"track_id\":\"1prZ0pr6XoRCxcrC3MCL0M\",\"title\":\"Everywhere\",\"artists\":[\"Fleetwood Mac\"]},{\"track_id\":\"7kv7zBjMtVf0eIJle2VZxn\",\"title\":\"Southern Nights\",\"artists\":[\"Glen Campbell\"]},{\"track_id\":\"38zsOOcu31XbbYj9BIPUF1\",\"title\":\"Your Song\",\"artists\":[\"Elton John\"]},{\"track_id\":\"0qRR9d89hIS0MHRkQ0ejxX\",\"title\":\"Rich Girl\",\"artists\":[\"Daryl Hall & John Oates\"]},{\"track_id\":\"5r5cp9IpziiIsR6b93vcnQ\",\"title\":\"Walking On A Dream\",\"artists\":[\"Empire Of The Sun\"]},{\"track_id\":\"4nnaCAi4IjyXke39EgSu09\",\"title\":\"Depth Coefficient Acid\",\"artists\":[\"CHRS\"]},{\"track_id\":\"2ezzmll94GbaXehnUx6j2h\",\"title\":\"Twilight\",\"artists\":[\"Gray\",\"A Little Sound\"]},{\"track_id\":\"6WKu0pl1jHSuVo4PbSn2yk\",\"title\":\"Downtown\",\"artists\":[\"Godford\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"history\":[],\"requested_selection_count\":15,\"correction\":null}"}],"model":"claude-sonnet-5","output_config":{"effort":"medium","format":{"type":"json_schema","schema":{"$defs":{"RerankSelectionOutput":{"type":"object","description":"One validated object extracted from the rerank stream.","title":"RerankSelectionOutput","properties":{"track_id":{"type":"string","title":"Track Id","description":"{maxLength: 200, minLength: 1}"},"justification":{"type":"string","title":"Justification","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"}},"additionalProperties":false,"required":["track_id","justification"]}},"type":"object","description":"Complete bounded rerank output used for final validation.","title":"RerankOutput","properties":{"recommendations":{"type":"array","title":"Recommendations","items":{"$ref":"#/$defs/RerankSelectionOutput"},"minItems":1,"description":"{maxItems: 50}"}},"additionalProperties":false,"required":["recommendations"]}}},"system":[{"type":"text","text":"You are the final ranking component of a music discovery system. Select and order tracks only from the grounded Spotify pool supplied in the variable input. Return only data that conforms to the provided JSON schema. Output strictly the JSON object required by that schema, with no markdown, no code fence, no introductory sentence, and no trailing commentary.\n\nThe variable input contains the interpreted intent, a compact listener taste summary, bounded conversation history, and a grounded pool. Every pool entry includes a Spotify track id, title, and artist names. The pool is the complete set of allowed choices. Copy track_id values exactly. Never create, alter, guess, shorten, or normalize an id. Never select a title that is absent from the pool, even if it would be a better recommendation. Never return the same track id twice.\n\nChoose up to the requested selection count, ordered from strongest to weakest recommendation. Prefer a shorter set of honest strong fits over padding with clearly unsuitable material, but normally fill the requested count when the pool contains enough relevant choices. Ranking should respond to the current intent first. Use the taste summary to personalize among plausible fits, not to override an explicit request. Use history to understand refinements and references. Treat prior assistant statements as conversation context rather than verified facts about a recording.\n\nRespect the interpreted mood, activity, era, languages, genres, and familiarity together. A track need not satisfy every soft descriptor equally, but the ordering should form a coherent listening path. Put the clearest overall matches early. Consider transitions in energy, texture, and familiarity when that creates a more useful sequence, while avoiding a mechanical pattern. Spread selections across artists where the grounded pool permits it. Do not rank several editions of the same recording merely to fill space.\n\nFamiliarity affects ordering, but it does not grant access to information outside the input. For familiar requests, favor grounded tracks that visibly connect to the supplied taste evidence or prior recommendations. For new requests, favor credible adjacent discoveries and avoid leaning entirely on artists named in the taste summary. For mix requests, use recognizable anchors and exploratory choices in a coherent balance. The application may already have filtered known tracks, so do not claim that any selection is definitely new or previously unheard.\n\nWrite one concise, plain-English justification for each selection. It should connect the track to the stated intent and, only when supported, to an explicit item or pattern in the supplied taste summary. Keep it to one line. Make the reason useful to the listener rather than describing internal ranking operations. Good reasons identify a grounded connection such as pacing for the activity, a genre bridge, a requested era, a compatible vocal language, a mood transition, or continuity with a named preference.\n\nBe exact and modest. Do not invent audio measurements, tempo values, key signatures, instrumentation, lyrical subjects, release dates, artist biographies, chart history, cultural significance, collaborations, popularity, or claims about what the listener has heard. A title and artist name alone do not prove detailed sonic or lyrical facts. You may use stable general musical knowledge when confident, but phrase the justification around the supplied intent and visible evidence. If the inputs do not support a specific fact, use a restrained reason such as \"A focused fit for the requested late-night electronic mood\" rather than manufacturing detail.\n\nDo not mention Spotify search, grounding, the candidate generator, language models, schemas, hidden scores, safety filters, cache state, or missing data in a justification. Do not tell the listener that a track was selected because it was available in the pool. Do not compare a selection with tracks that are not in the pool. Do not repeat the same generic sentence for every item. Avoid promotional language and absolute claims such as \"perfect,\" \"guaranteed,\" or \"the best.\"\n\nWhen the variable input says this is a correction attempt, treat the stated validation failure as a strict constraint. Return a fresh complete JSON object, not a patch or explanation. Correct invalid ids, duplicates, malformed fields, count problems, and formatting errors using only the supplied pool. The correction instruction never allows an out-of-pool id.\n\nThe response must be one JSON object with the exact top-level field required by the schema. Each array item must contain exactly a track_id and justification in the required types. Preserve the requested ranking order in the array. Use valid JSON quoting and escaping. Do not emit comments, dangling commas, alternate keys, null justifications, numeric ids, or additional properties.\n\nBefore returning, silently verify every track_id against the supplied pool, ensure all ids are unique, ensure the number of items does not exceed the requested count, confirm each justification is honest and one line, confirm the ranking follows the current intent, and confirm the entire response is valid against the provided JSON schema. Return only the JSON object.\n","cache_control":{"type":"ephemeral"}}],"stream":true}", + "response_body_base64": "event: message_start
data: {"type":"message_start","message":{"model":"claude-sonnet-5","id":"msg_011CdtuJxEz83hfkiZpvRoeW","type":"message","role":"assistant","content":[],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":6190,"cache_creation_input_tokens":2113,"cache_read_input_tokens":0,"cache_creation":{"ephemeral_5m_input_tokens":2113,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"global"}}           }

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}         }

event: ping
data: {"type": "ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"{"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"recommendations\":[{\"track_id\":\"2nIixNuuV5eHC"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"JydG5aYIB\",\"justification\":\"A smooth liquid drum and bass track"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" that matches your listening history with Hybrid Minds and keeps energy steady without being distracting.\"},{\"track_id\":\"7"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"nYClzzNY6f3Ec"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"feDFNqhS\",\"justification\":\"A mellow downtempo groove that eases into a"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" focused coding session.\"},{\"track_id\":\"2ezzmll94Gba"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"XehnUx6j2h\",\"justification\":\"Soft, textured production that fits the calm inst"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"rumental soul lane you're drawn to.\"},{\"track_id\":\"4nnaCA"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"i4IjyXke39EgSu"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"09\",\"justification\":\"An understated electronic piece that adds gentle motion without pulling attention from work.\"},{\"track_id\":"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"6WKu0pl1jHSuV"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"o4PbSn2yk\",\"justification\":\"A low-key downtempo cut that ke"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"eps the pace unobtrusive and steady.\"},{\"track_id\":\"44ZKnfWEk"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"p7wPs035j4Tua\",\"justification\":\"Jungle's sm"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ooth groove connects to your saved tracks and offers a soulful, laid-back backdrop.\"},{\"track_id\":\"0JXXNGlj"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"qupsJaZsgSbMZ"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"V\",\"justification\":\"A smooth instrumental-soul-leaning R&B track that keeps the mood relaxed and focused.\"},{\"track_id\":\"7aK"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"rysuyZvDnU3Jw"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"nlO3dd\",\"justification\":\"Warm instrumental soul that matches your saved-track history and supports calm conc"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"entration.\"},{\"track_id\":\"4XsH9zBWPOCd"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"XoH9ZDdS8r\",\"justification\":\"Classic soul groove with a ste"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ady pulse, echoing your saved Curtis Mayfield pick for background listening.\"},{\"track_id\":\"63xd"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"wScd1Ai1GigAwQxE"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"8y\",\"justification\":\"A smooth soul classic that keeps the energy calm and consistent for coding.\"},{\"track_id\":\"6ek9S"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"iEj5a65WIs2EV"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"7qiM\",\"justification\":\"A gentle, soulful vocal track that offers a low-key texture shift while"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" staying unobtrusive.\"},{\"track_id\":\"7kv7zBjMtVf"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"0eIJle2VZxn\",\"justification\":\"A relaxed,"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" warm track from your saved list that fits the smooth downtempo mood.\"},{\"track_id\":\"19Ym5S"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"g0YyOCa6ao21bdoG"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"A familiar Fleetwood Mac pick from your top artists, offering steady, easy-going pacing.\"},{\"track_id\":\"1prZ"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"0pr6XoRCxcrC"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"3MCL0M\",\"justification\":\"Another Fleetwood Mac favorite that continues the smooth, focused list"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ening path.\"},{\"track_id\":\"3vQ4T78TTMOj"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"QXGfXVKQJo\",\"justification\":\"A famil"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"iar Childish Gambino track from your top artists that adds a soulful anchor to the mix.\"}]}"}              }

event: content_block_stop
data: {"type":"content_block_stop","index":0 }

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null,"stop_details":null},"usage":{"input_tokens":6190,"cache_creation_input_tokens":2113,"cache_read_input_tokens":0,"output_tokens":978,"output_tokens_details":{"thinking_tokens":0}}       }

event: message_stop
data: {"type":"message_stop"        }

", + "response_chunks_base64": [ + "ZXZlbnQ6IG1lc3NhZ2Vfc3RhcnQKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9zdGFydCIsIm1lc3NhZ2U=", + "Ijp7Im1vZGVsIjoiY2xhdWRlLXNvbm5ldC01IiwiaWQiOiJtc2dfMDExQ2R0dUp4RXo4M2hma2lacHZSb2VXIiwidHlwZSI6Im1lc3NhZ2UiLCJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6W10sInN0b3BfcmVhc29uIjpudWxsLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NjE5MCwiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjoyMTEzLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MjExMywiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjEsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Imdsb2JhbCJ9fSAgICAgICAgICAgfQoKZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RhcnQKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19zdGFydCIsImluZGV4IjowLCJjb250ZW50X2Jsb2NrIjp7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IiJ9ICAgICAgICAgfQoK", + "ZXZlbnQ6IHBpbmcKZGF0YTogeyJ0eXBlIjogInBpbmcifQoKZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ7In0gICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInJlY29tbWVuZGF0aW9uc1wiOlt7XCJ0cmFja19pZFwiOlwiMm5JaXhOdXVWNWVIQyJ9IH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJKeWRHNWFZSUJcIixcImp1c3RpZmljYXRpb25cIjpcIkEgc21vb3RoIGxpcXVpZCBkcnVtIGFuZCBiYXNzIHRyYWNrIn0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgdGhhdCBtYXRjaGVzIHlvdXIgbGlzdGVuaW5nIGhpc3Rvcnkgd2l0aCBIeWJyaWQgTWluZHMgYW5kIGtlZXBzIGVuZXJneSBzdGVhZHkgd2l0aG91dCBiZWluZyBkaXN0cmFjdGluZy5cIn0se1widHJhY2tfaWRcIjpcIjcifSB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJuWUNsenpOWTZmM0VjIn0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJmZURGTnFoU1wiLFwianVzdGlmaWNhdGlvblwiOlwiQSBtZWxsb3cgZG93bnRlbXBvIGdyb292ZSB0aGF0IGVhc2VzIGludG8gYSJ9ICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgZm9jdXNlZCBjb2Rpbmcgc2Vzc2lvbi5cIn0se1widHJhY2tfaWRcIjpcIjJlenptbGw5NEdiYSJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJYZWhuVXg2ajJoXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJTb2Z0LCB0ZXh0dXJlZCBwcm9kdWN0aW9uIHRoYXQgZml0cyB0aGUgY2FsbSBpbnN0In0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJydW1lbnRhbCBzb3VsIGxhbmUgeW91J3JlIGRyYXduIHRvLlwifSx7XCJ0cmFja19pZFwiOlwiNG5uYUNBIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpNElqeVhrZTM5RWdTdSJ9ICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIwOVwiLFwianVzdGlmaWNhdGlvblwiOlwiQW4gdW5kZXJzdGF0ZWQgZWxlY3Ryb25pYyBwaWVjZSB0aGF0IGFkZHMgZ2VudGxlIG1vdGlvbiB3aXRob3V0IHB1bGxpbmcgYXR0ZW50aW9uIGZyb20gd29yay5cIn0se1widHJhY2tfaWRcIjoifSAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIjZXS3UwcGwxakhTdVYifSAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvNFBiU24yeWtcIixcImp1c3RpZmljYXRpb25cIjpcIkEgbG93LWtleSBkb3dudGVtcG8gY3V0IHRoYXQga2UifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlcHMgdGhlIHBhY2UgdW5vYnRydXNpdmUgYW5kIHN0ZWFkeS5cIn0se1widHJhY2tfaWRcIjpcIjQ0WktuZldFayJ9fQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJwN3dQczAzNWo0VHVhXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJKdW5nbGUncyBzbSJ9IH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvb3RoIGdyb292ZSBjb25uZWN0cyB0byB5b3VyIHNhdmVkIHRyYWNrcyBhbmQgb2ZmZXJzIGEgc291bGZ1bCwgbGFpZC1iYWNrIGJhY2tkcm9wLlwifSx7XCJ0cmFja19pZFwiOlwiMEpYWE5HbGoifSAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJxdXBzSmFac2dTYk1aIn0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJWXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIHNtb290aCBpbnN0cnVtZW50YWwtc291bC1sZWFuaW5nIFImQiB0cmFjayB0aGF0IGtlZXBzIHRoZSBtb29kIHJlbGF4ZWQgYW5kIGZvY3VzZWQuXCJ9LHtcInRyYWNrX2lkXCI6XCI3YUsifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJyeXN1eVp2RG5VM0p3In0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJubE8zZGRcIixcImp1c3RpZmljYXRpb25cIjpcIldhcm0gaW5zdHJ1bWVudGFsIHNvdWwgdGhhdCBtYXRjaGVzIHlvdXIgc2F2ZWQtdHJhY2sgaGlzdG9yeSBhbmQgc3VwcG9ydHMgY2FsbSBjb25jIn0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlbnRyYXRpb24uXCJ9LHtcInRyYWNrX2lkXCI6XCI0WHNIOXpCV1BPQ2QifSAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJYb0g5WkRkUzhyXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJDbGFzc2ljIHNvdWwgZ3Jvb3ZlIHdpdGggYSBzdGUifSB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJhZHkgcHVsc2UsIGVjaG9pbmcgeW91ciBzYXZlZCBDdXJ0aXMgTWF5ZmllbGQgcGljayBmb3IgYmFja2dyb3VuZCBsaXN0ZW5pbmcuXCJ9LHtcInRyYWNrX2lkXCI6XCI2M3hkIn0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ3U2NkMUFpMUdpZ0F3UXhFIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI4eVwiLFwianVzdGlmaWNhdGlvblwiOlwiQSBzbW9vdGggc291bCBjbGFzc2ljIHRoYXQga2VlcHMgdGhlIGVuZXJneSBjYWxtIGFuZCBjb25zaXN0ZW50IGZvciBjb2RpbmcuXCJ9LHtcInRyYWNrX2lkXCI6XCI2ZWs5UyJ9ICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpRWo1YTY1V0lzMkVWIn0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI3cWlNXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIGdlbnRsZSwgc291bGZ1bCB2b2NhbCB0cmFjayB0aGF0IG9mZmVycyBhIGxvdy1rZXkgdGV4dHVyZSBzaGlmdCB3aGlsZSJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgc3RheWluZyB1bm9idHJ1c2l2ZS5cIn0se1widHJhY2tfaWRcIjpcIjdrdjd6QmpNdFZmIn0gICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIwZUlKbGUyVlp4blwiLFwianVzdGlmaWNhdGlvblwiOlwiQSByZWxheGVkLCJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgd2FybSB0cmFjayBmcm9tIHlvdXIgc2F2ZWQgbGlzdCB0aGF0IGZpdHMgdGhlIHNtb290aCBkb3dudGVtcG8gbW9vZC5cIn0se1widHJhY2tfaWRcIjpcIjE5WW01UyJ9ICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJnMFl5T0NhNmFvMjFiZG9HIn0gICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIkEgZmFtaWxpYXIgRmxlZXR3b29kIE1hYyBwaWNrIGZyb20geW91ciB0b3AgYXJ0aXN0cywgb2ZmZXJpbmcgc3RlYWR5LCBlYXN5LWdvaW5nIHBhY2luZy5cIn0se1widHJhY2tfaWRcIjpcIjFwcloifSAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIwcHI2WG9SQ3hjckMifSAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIzTUNMME1cIixcImp1c3RpZmljYXRpb25cIjpcIkFub3RoZXIgRmxlZXR3b29kIE1hYyBmYXZvcml0ZSB0aGF0IGNvbnRpbnVlcyB0aGUgc21vb3RoLCBmb2N1c2VkIGxpc3QifSAgICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlbmluZyBwYXRoLlwifSx7XCJ0cmFja19pZFwiOlwiM3ZRNFQ3OFRUTU9qIn0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJRWEdmWFZLUUpvXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIGZhbWlsIn0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpYXIgQ2hpbGRpc2ggR2FtYmlubyB0cmFjayBmcm9tIHlvdXIgdG9wIGFydGlzdHMgdGhhdCBhZGRzIGEgc291bGZ1bCBhbmNob3IgdG8gdGhlIG1peC5cIn1dfSJ9ICAgICAgICAgICAgICB9CgpldmVudDogY29udGVudF9ibG9ja19zdG9wCmRhdGE6IHsidHlwZSI6ImNvbnRlbnRfYmxvY2tfc3RvcCIsImluZGV4IjowIH0KCg==", + "ZXZlbnQ6IG1lc3NhZ2VfZGVsdGEKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9kZWx0YSIsImRlbHRhIjp7InN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGx9LCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjYxOTAsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MjExMywiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjAsIm91dHB1dF90b2tlbnMiOjk3OCwib3V0cHV0X3Rva2Vuc19kZXRhaWxzIjp7InRoaW5raW5nX3Rva2VucyI6MH19ICAgICAgIH0KCg==", + "ZXZlbnQ6IG1lc3NhZ2Vfc3RvcApkYXRhOiB7InR5cGUiOiJtZXNzYWdlX3N0b3AiICAgICAgICB9Cgo=" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + } +] diff --git a/eval/fixtures/focus-coding/spotify.json b/eval/fixtures/focus-coding/spotify.json new file mode 100644 index 0000000..6ad7f9e --- /dev/null +++ b/eval/fixtures/focus-coding/spotify.json @@ -0,0 +1,795 @@ +[ + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=", + "response_chunks_base64": [ + "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=0" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkxvc2luZyUyME15c2VsZiUyMiUyMGFydGlzdCUzQSUyMkxTQiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkxvc2luZyUyME15c2VsZiUyMiUyMGFydGlzdCUzQSUyMkxTQiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Losing+Myself%22+artist%3A%22LSB%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZhbGxpbmclMjBTa2llcyUyMiUyMGFydGlzdCUzQSUyMktlZW5vJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZhbGxpbmclMjBTa2llcyUyMiUyMGFydGlzdCUzQSUyMktlZW5vJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Falling+Skies%22+artist%3A%22Keeno%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZlZWwlMjBZb3VyJTIwV2F5JTIyJTIwYXJ0aXN0JTNBJTIyQWxpeCUyMFBlcmV6JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZlZWwlMjBZb3VyJTIwV2F5JTIyJTIwYXJ0aXN0JTNBJTIyQWxpeCUyMFBlcmV6JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Feel+Your+Way%22+artist%3A%22Alix+Perez%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZpcmVmbGllcyUyMiUyMGFydGlzdCUzQSUyMk5ldHNreSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZpcmVmbGllcyUyMiUyMGFydGlzdCUzQSUyMk5ldHNreSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Fireflies%22+artist%3A%22Netsky%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Stay%22%20artist%3A%22Hybrid%20Minds%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/05lF0DUkLJqiW5o70SScyR"},"href":"https://api.spotify.com/v1/artists/05lF0DUkLJqiW5o70SScyR","id":"05lF0DUkLJqiW5o70SScyR","name":"Hybrid Minds","type":"artist","uri":"spotify:artist:05lF0DUkLJqiW5o70SScyR"}],"external_urls":{"spotify":"https://open.spotify.com/album/017RaL4pPG79H1ECtctJIw"},"href":"https://api.spotify.com/v1/albums/017RaL4pPG79H1ECtctJIw","id":"017RaL4pPG79H1ECtctJIw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735bd1d3d557c29658569e72c7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025bd1d3d557c29658569e72c7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515bd1d3d557c29658569e72c7"}],"is_playable":true,"name":"Tides","release_date":"2024-03-22","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:017RaL4pPG79H1ECtctJIw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/05lF0DUkLJqiW5o70SScyR"},"href":"https://api.spotify.com/v1/artists/05lF0DUkLJqiW5o70SScyR","id":"05lF0DUkLJqiW5o70SScyR","name":"Hybrid Minds","type":"artist","uri":"spotify:artist:05lF0DUkLJqiW5o70SScyR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3gY5phLoPwEPBcHXck53XX"},"href":"https://api.spotify.com/v1/artists/3gY5phLoPwEPBcHXck53XX","id":"3gY5phLoPwEPBcHXck53XX","name":"Lily Denning","type":"artist","uri":"spotify:artist:3gY5phLoPwEPBcHXck53XX"}],"disc_number":1,"duration_ms":226206,"explicit":false,"external_ids":{"isrc":"US39N2304630"},"external_urls":{"spotify":"https://open.spotify.com/track/2nIixNuuV5eHCJydG5aYIB"},"href":"https://api.spotify.com/v1/tracks/2nIixNuuV5eHCJydG5aYIB","id":"2nIixNuuV5eHCJydG5aYIB","is_local":false,"is_playable":true,"name":"Stay","track_number":5,"type":"track","uri":"spotify:track:2nIixNuuV5eHCJydG5aYIB"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/05lF0DUkLJqiW5o70SScyR"},"href":"https://api.spotify.com/v1/artists/05lF0DUkLJqiW5o70SScyR","id":"05lF0DUkLJqiW5o70SScyR","name":"Hybrid Minds","type":"artist","uri":"spotify:artist:05lF0DUkLJqiW5o70SScyR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3gY5phLoPwEPBcHXck53XX"},"href":"https://api.spotify.com/v1/artists/3gY5phLoPwEPBcHXck53XX","id":"3gY5phLoPwEPBcHXck53XX","name":"Lily Denning","type":"artist","uri":"spotify:artist:3gY5phLoPwEPBcHXck53XX"}],"external_urls":{"spotify":"https://open.spotify.com/album/4YPp6vPOoR4dAXEsThwZGR"},"href":"https://api.spotify.com/v1/albums/4YPp6vPOoR4dAXEsThwZGR","id":"4YPp6vPOoR4dAXEsThwZGR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ec34383d511c3a141e16adbe"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ec34383d511c3a141e16adbe"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ec34383d511c3a141e16adbe"}],"is_playable":true,"name":"Stay","release_date":"2023-11-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4YPp6vPOoR4dAXEsThwZGR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/05lF0DUkLJqiW5o70SScyR"},"href":"https://api.spotify.com/v1/artists/05lF0DUkLJqiW5o70SScyR","id":"05lF0DUkLJqiW5o70SScyR","name":"Hybrid Minds","type":"artist","uri":"spotify:artist:05lF0DUkLJqiW5o70SScyR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3gY5phLoPwEPBcHXck53XX"},"href":"https://api.spotify.com/v1/artists/3gY5phLoPwEPBcHXck53XX","id":"3gY5phLoPwEPBcHXck53XX","name":"Lily Denning","type":"artist","uri":"spotify:artist:3gY5phLoPwEPBcHXck53XX"}],"disc_number":1,"duration_ms":226206,"explicit":false,"external_ids":{"isrc":"US39N2304630"},"external_urls":{"spotify":"https://open.spotify.com/track/5ERSts6dk641ybbWaQbTlt"},"href":"https://api.spotify.com/v1/tracks/5ERSts6dk641ybbWaQbTlt","id":"5ERSts6dk641ybbWaQbTlt","is_local":false,"is_playable":true,"name":"Stay","track_number":1,"type":"track","uri":"spotify:track:5ERSts6dk641ybbWaQbTlt"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/05lF0DUkLJqiW5o70SScyR"},"href":"https://api.spotify.com/v1/artists/05lF0DUkLJqiW5o70SScyR","id":"05lF0DUkLJqiW5o70SScyR","name":"Hybrid Minds","type":"artist","uri":"spotify:artist:05lF0DUkLJqiW5o70SScyR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7aExhNtzjRq6lYj7eL8pb9"},"href":"https://api.spotify.com/v1/artists/7aExhNtzjRq6lYj7eL8pb9","id":"7aExhNtzjRq6lYj7eL8pb9","name":"homesick","type":"artist","uri":"spotify:artist:7aExhNtzjRq6lYj7eL8pb9"}],"external_urls":{"spotify":"https://open.spotify.com/album/6tQleNjbmmM1GxJB9Rka2S"},"href":"https://api.spotify.com/v1/albums/6tQleNjbmmM1GxJB9Rka2S","id":"6tQleNjbmmM1GxJB9Rka2S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a64153c8a72da8c881279b5d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a64153c8a72da8c881279b5d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a64153c8a72da8c881279b5d"}],"is_playable":true,"name":"Kites","release_date":"2024-02-23","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:6tQleNjbmmM1GxJB9Rka2S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/05lF0DUkLJqiW5o70SScyR"},"href":"https://api.spotify.com/v1/artists/05lF0DUkLJqiW5o70SScyR","id":"05lF0DUkLJqiW5o70SScyR","name":"Hybrid Minds","type":"artist","uri":"spotify:artist:05lF0DUkLJqiW5o70SScyR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3gY5phLoPwEPBcHXck53XX"},"href":"https://api.spotify.com/v1/artists/3gY5phLoPwEPBcHXck53XX","id":"3gY5phLoPwEPBcHXck53XX","name":"Lily Denning","type":"artist","uri":"spotify:artist:3gY5phLoPwEPBcHXck53XX"}],"disc_number":1,"duration_ms":226206,"explicit":false,"external_ids":{"isrc":"US39N2304630"},"external_urls":{"spotify":"https://open.spotify.com/track/5rljkgKpN4mcv7s2RLionT"},"href":"https://api.spotify.com/v1/tracks/5rljkgKpN4mcv7s2RLionT","id":"5rljkgKpN4mcv7s2RLionT","is_local":false,"is_playable":true,"name":"Stay","track_number":6,"type":"track","uri":"spotify:track:5rljkgKpN4mcv7s2RLionT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/05lF0DUkLJqiW5o70SScyR"},"href":"https://api.spotify.com/v1/artists/05lF0DUkLJqiW5o70SScyR","id":"05lF0DUkLJqiW5o70SScyR","name":"Hybrid Minds","type":"artist","uri":"spotify:artist:05lF0DUkLJqiW5o70SScyR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7HvAimFUDbhD9XRv1dbJ9t"},"href":"https://api.spotify.com/v1/artists/7HvAimFUDbhD9XRv1dbJ9t","id":"7HvAimFUDbhD9XRv1dbJ9t","name":"Brodie","type":"artist","uri":"spotify:artist:7HvAimFUDbhD9XRv1dbJ9t"}],"external_urls":{"spotify":"https://open.spotify.com/album/7g5GmifykucoqzWJMOeOlO"},"href":"https://api.spotify.com/v1/albums/7g5GmifykucoqzWJMOeOlO","id":"7g5GmifykucoqzWJMOeOlO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730fcb705399897b2c67a79337"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020fcb705399897b2c67a79337"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510fcb705399897b2c67a79337"}],"is_playable":true,"name":"Delete Our Love","release_date":"2024-01-26","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:7g5GmifykucoqzWJMOeOlO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/05lF0DUkLJqiW5o70SScyR"},"href":"https://api.spotify.com/v1/artists/05lF0DUkLJqiW5o70SScyR","id":"05lF0DUkLJqiW5o70SScyR","name":"Hybrid Minds","type":"artist","uri":"spotify:artist:05lF0DUkLJqiW5o70SScyR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3gY5phLoPwEPBcHXck53XX"},"href":"https://api.spotify.com/v1/artists/3gY5phLoPwEPBcHXck53XX","id":"3gY5phLoPwEPBcHXck53XX","name":"Lily Denning","type":"artist","uri":"spotify:artist:3gY5phLoPwEPBcHXck53XX"}],"disc_number":1,"duration_ms":226206,"explicit":false,"external_ids":{"isrc":"US39N2304630"},"external_urls":{"spotify":"https://open.spotify.com/track/497zzWG6eW6boclApkCr9o"},"href":"https://api.spotify.com/v1/tracks/497zzWG6eW6boclApkCr9o","id":"497zzWG6eW6boclApkCr9o","is_local":false,"is_playable":true,"name":"Stay","track_number":5,"type":"track","uri":"spotify:track:497zzWG6eW6boclApkCr9o"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN0YXklMjIlMjBhcnRpc3QlM0ElMjJIeWJyaWQlMjBNaW5kcyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDVsRjBEVWtMSnFpVzVvNzBTU2N5UiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wNWxGMERVa0xKcWlXNW83MFNTY3lSIiwiaWQiOiIwNWxGMERVa0xKcWlXNW83MFNTY3lSIiwibmFtZSI6Ikh5YnJpZCBNaW5kcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNWxGMERVa0xKcWlXNW83MFNTY3lSIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMDE3UmFMNHBQRzc5SDFFQ3RjdEpJdyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzAxN1JhTDRwUEc3OUgxRUN0Y3RKSXciLCJpZCI6IjAxN1JhTDRwUEc3OUgxRUN0Y3RKSXciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZQ==", + "L2FiNjc2MTZkMDAwMGIyNzM1YmQxZDNkNTU3YzI5NjU4NTY5ZTcyYzcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWJkMWQzZDU1N2MyOTY1ODU2OWU3MmM3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1YmQxZDNkNTU3YzI5NjU4NTY5ZTcyYzcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGlkZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTAzLTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MDE3UmFMNHBQRzc5SDFFQ3RjdEpJdyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA1bEYwRFVrTEpxaVc1bzcwU1NjeVIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDVsRjBEVWtMSnFpVzVvNzBTU2N5UiIsImlkIjoiMDVsRjBEVWtMSnFpVzVvNzBTU2N5UiIsIm5hbWUiOiJIeWJyaWQgTWluZHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDVsRjBEVWtMSnFpVzVvNzBTU2N5UiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZ1k1cGhMb1B3RVBCY0hYY2s1M1hYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNnWTVwaExvUHdFUEJjSFhjazUzWFgiLCJpZCI6IjNnWTVwaExvUHdFUEJjSFhjazUzWFgiLCJuYW1lIjoiTGlseSBEZW5uaW5nIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNnWTVwaExvUHdFUEJjSFhjazUzWFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI2MjA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVMzOU4yMzA0NjMwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8ybklpeE51dVY1ZUhDSnlkRzVhWUlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMm5JaXhOdXVWNWVIQ0p5ZEc1YVlJQiIsImlkIjoiMm5JaXhOdXVWNWVIQ0p5ZEc1YVlJQiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdGF5IiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJuSWl4TnV1VjVlSENKeWRHNWFZSUIifSx7ImFsYnVtIjp7ImFsYg==", + "dW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDVsRjBEVWtMSnFpVzVvNzBTU2N5UiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wNWxGMERVa0xKcWlXNW83MFNTY3lSIiwiaWQiOiIwNWxGMERVa0xKcWlXNW83MFNTY3lSIiwibmFtZSI6Ikh5YnJpZCBNaW5kcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNWxGMERVa0xKcWlXNW83MFNTY3lSIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNnWTVwaExvUHdFUEJjSFhjazUzWFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2dZNXBoTG9Qd0VQQmNIWGNrNTNYWCIsImlkIjoiM2dZNXBoTG9Qd0VQQmNIWGNrNTNYWCIsIm5hbWUiOiJMaWx5IERlbm5pbmciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2dZNXBoTG9Qd0VQQmNIWGNrNTNYWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRZUHA2dlBPb1I0ZEFYRXNUaHdaR1IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80WVBwNnZQT29SNGRBWEVzVGh3WkdSIiwiaWQiOiI0WVBwNnZQT29SNGRBWEVzVGh3WkdSIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2VjMzQzODNkNTExYzNhMTQxZTE2YWRiZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlYzM0MzgzZDUxMWMzYTE0MWUxNmFkYmUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVjMzQzODNkNTExYzNhMTQxZTE2YWRiZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdGF5IiwicmVsZWFzZV9kYXRlIjoiMjAyMy0xMS0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFlQcDZ2UE9vUjRkQVhFc1Rod1pHUiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA1bEYwRFVrTEpxaVc1bzcwU1NjeVIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDVsRjBEVWtMSnFpVw==", + "NW83MFNTY3lSIiwiaWQiOiIwNWxGMERVa0xKcWlXNW83MFNTY3lSIiwibmFtZSI6Ikh5YnJpZCBNaW5kcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNWxGMERVa0xKcWlXNW83MFNTY3lSIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNnWTVwaExvUHdFUEJjSFhjazUzWFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2dZNXBoTG9Qd0VQQmNIWGNrNTNYWCIsImlkIjoiM2dZNXBoTG9Qd0VQQmNIWGNrNTNYWCIsIm5hbWUiOiJMaWx5IERlbm5pbmciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2dZNXBoTG9Qd0VQQmNIWGNrNTNYWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjYyMDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVUzM5TjIzMDQ2MzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVFUlN0czZkazY0MXliYldhUWJUbHQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81RVJTdHM2ZGs2NDF5YmJXYVFiVGx0IiwiaWQiOiI1RVJTdHM2ZGs2NDF5YmJXYVFiVGx0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0YXkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUVSU3RzNmRrNjQxeWJiV2FRYlRsdCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDVsRjBEVWtMSnFpVzVvNzBTU2N5UiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wNWxGMERVa0xKcWlXNW83MFNTY3lSIiwiaWQiOiIwNWxGMERVa0xKcWlXNW83MFNTY3lSIiwibmFtZSI6Ikh5YnJpZCBNaW5kcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNWxGMERVa0xKcWlXNW83MFNTY3lSIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdhRXhoTnR6alJxNmxZajdlTDhwYjkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2FFeGhOdHpqUnE2bFlqN2VMOHBiOSIsImlkIjoiN2FFeGhOdHpqUnE2bFlqN2VMOHBiOSIsIm5hbWUiOiJob21lc2ljayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3YUV4aE50empScTZsWWo3ZUw4cGI5In1dLCJleHRlcg==", + "bmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82dFFsZU5qYm1tTTFHeEpCOVJrYTJTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnRRbGVOamJtbU0xR3hKQjlSa2EyUyIsImlkIjoiNnRRbGVOamJtbU0xR3hKQjlSa2EyUyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhNjQxNTNjOGE3MmRhOGM4ODEyNzliNWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTY0MTUzYzhhNzJkYThjODgxMjc5YjVkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhNjQxNTNjOGE3MmRhOGM4ODEyNzliNWQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS2l0ZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTAyLTIzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2dFFsZU5qYm1tTTFHeEpCOVJrYTJTIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDVsRjBEVWtMSnFpVzVvNzBTU2N5UiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wNWxGMERVa0xKcWlXNW83MFNTY3lSIiwiaWQiOiIwNWxGMERVa0xKcWlXNW83MFNTY3lSIiwibmFtZSI6Ikh5YnJpZCBNaW5kcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNWxGMERVa0xKcWlXNW83MFNTY3lSIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNnWTVwaExvUHdFUEJjSFhjazUzWFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2dZNXBoTG9Qd0VQQmNIWGNrNTNYWCIsImlkIjoiM2dZNXBoTG9Qd0VQQmNIWGNrNTNYWCIsIm5hbWUiOiJMaWx5IERlbm5pbmciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2dZNXBoTG9Qd0VQQmNIWGNrNTNYWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjYyMDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVUzM5TjIzMDQ2MzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVybGprZ0twTjRtY3Y3czJSTGlvblQifQ==", + "LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVybGprZ0twTjRtY3Y3czJSTGlvblQiLCJpZCI6IjVybGprZ0twTjRtY3Y3czJSTGlvblQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3RheSIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1cmxqa2dLcE40bWN2N3MyUkxpb25UIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNWxGMERVa0xKcWlXNW83MFNTY3lSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA1bEYwRFVrTEpxaVc1bzcwU1NjeVIiLCJpZCI6IjA1bEYwRFVrTEpxaVc1bzcwU1NjeVIiLCJuYW1lIjoiSHlicmlkIE1pbmRzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA1bEYwRFVrTEpxaVc1bzcwU1NjeVIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0h2QWltRlVEYmhEOVhSdjFkYko5dCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83SHZBaW1GVURiaEQ5WFJ2MWRiSjl0IiwiaWQiOiI3SHZBaW1GVURiaEQ5WFJ2MWRiSjl0IiwibmFtZSI6IkJyb2RpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3SHZBaW1GVURiaEQ5WFJ2MWRiSjl0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN2c1R21pZnlrdWNvcXpXSk1PZU9sTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdnNUdtaWZ5a3Vjb3F6V0pNT2VPbE8iLCJpZCI6IjdnNUdtaWZ5a3Vjb3F6V0pNT2VPbE8iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMGZjYjcwNTM5OTg5N2IyYzY3YTc5MzM3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjBmY2I3MDUzOTk4OTdiMmM2N2E3OTMzNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMGZjYjcwNTM5OTg5N2IyYzY3YTc5MzM3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlbGV0ZSBPdXIgTG92ZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDEtMjYiLCJyZWxlYXNlX2RhdGVfcHJlYw==", + "aXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N2c1R21pZnlrdWNvcXpXSk1PZU9sTyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA1bEYwRFVrTEpxaVc1bzcwU1NjeVIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDVsRjBEVWtMSnFpVzVvNzBTU2N5UiIsImlkIjoiMDVsRjBEVWtMSnFpVzVvNzBTU2N5UiIsIm5hbWUiOiJIeWJyaWQgTWluZHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDVsRjBEVWtMSnFpVzVvNzBTU2N5UiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZ1k1cGhMb1B3RVBCY0hYY2s1M1hYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNnWTVwaExvUHdFUEJjSFhjazUzWFgiLCJpZCI6IjNnWTVwaExvUHdFUEJjSFhjazUzWFgiLCJuYW1lIjoiTGlseSBEZW5uaW5nIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNnWTVwaExvUHdFUEJjSFhjazUzWFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI2MjA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVMzOU4yMzA0NjMwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80OTd6eldHNmVXNmJvY2xBcGtDcjlvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDk3enpXRzZlVzZib2NsQXBrQ3I5byIsImlkIjoiNDk3enpXRzZlVzZib2NsQXBrQ3I5byIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdGF5IiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjQ5N3p6V0c2ZVc2Ym9jbEFwa0NyOW8ifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Stay%22+artist%3A%22Hybrid+Minds%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhdGVyJTIyJTIwYXJ0aXN0JTNBJTIyRXRoZXJ3b29kJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zR0VVSWEzWjBRbGl2eTNFY0ptNVJYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNHRVVJYTNaMFFsaXZ5M0VjSm01UlgiLCJpZCI6IjNHRVVJYTNaMFFsaXZ5M0VjSm01UlgiLCJuYW1lIjoiRXRoZXJ3b29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNHRVVJYTNaMFFsaXZ5M0VjSm01UlgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81NVRCSnhGV05rOHQ4U3FCYWpxZkR0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNTVUQkp4RldOazh0OFNxQmFqcWZEdCIsImlkIjoiNTVUQkp4RldOazh0OFNxQmFqcWZEdCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MQ==", + "NmQwMDAwYjI3MzI1Y2IzOWE0ZmUxMzQxMmU4YTVkZDJjNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyNWNiMzlhNGZlMTM0MTJlOGE1ZGQyYzQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTI1Y2IzOWE0ZmUxMzQxMmU4YTVkZDJjNCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOZW9uIER1c3QiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTA5LTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NTVUQkp4RldOazh0OFNxQmFqcWZEdCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNHRVVJYTNaMFFsaXZ5M0VjSm01UlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0dFVUlhM1owUWxpdnkzRWNKbTVSWCIsImlkIjoiM0dFVUlhM1owUWxpdnkzRWNKbTVSWCIsIm5hbWUiOiJFdGhlcndvb2QiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0dFVUlhM1owUWxpdnkzRWNKbTVSWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDIyNTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkNKWTIxMDAyNjcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNmVXhWOVZQQTBmNzlPZnpZRkNKajQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zZlV4VjlWUEEwZjc5T2Z6WUZDSmo0IiwiaWQiOiIzZlV4VjlWUEEwZjc5T2Z6WUZDSmo0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhdGVyIEluIFlvdXIgVmVpbnMiLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2ZVeFY5VlBBMGY3OU9mellGQ0pqNCJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Water%22+artist%3A%22Etherwood%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Falling%20Skies%20Keeno&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Falling%20Skies%20Keeno&type=track","offset":0,"previous":null,"total":11,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6mkvJ6XHWVtPer8k0B0nTn"},"href":"https://api.spotify.com/v1/artists/6mkvJ6XHWVtPer8k0B0nTn","id":"6mkvJ6XHWVtPer8k0B0nTn","name":"Wiley from Atlanta","type":"artist","uri":"spotify:artist:6mkvJ6XHWVtPer8k0B0nTn"}],"external_urls":{"spotify":"https://open.spotify.com/album/4NsqJDsfxsCMUxQw3O7A0D"},"href":"https://api.spotify.com/v1/albums/4NsqJDsfxsCMUxQw3O7A0D","id":"4NsqJDsfxsCMUxQw3O7A0D","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27343188b6e34ea6a2af137401f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0243188b6e34ea6a2af137401f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485143188b6e34ea6a2af137401f"}],"is_playable":true,"name":"Demo 001","release_date":"2018-10-26","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:4NsqJDsfxsCMUxQw3O7A0D"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6mkvJ6XHWVtPer8k0B0nTn"},"href":"https://api.spotify.com/v1/artists/6mkvJ6XHWVtPer8k0B0nTn","id":"6mkvJ6XHWVtPer8k0B0nTn","name":"Wiley from Atlanta","type":"artist","uri":"spotify:artist:6mkvJ6XHWVtPer8k0B0nTn"}],"disc_number":1,"duration_ms":223101,"explicit":true,"external_ids":{"isrc":"QM24S1840135"},"external_urls":{"spotify":"https://open.spotify.com/track/4NeHCGpTPVCudqVpJiT7O9"},"href":"https://api.spotify.com/v1/tracks/4NeHCGpTPVCudqVpJiT7O9","id":"4NeHCGpTPVCudqVpJiT7O9","is_local":false,"is_playable":true,"name":"Pink Skies (Demo)","track_number":1,"type":"track","uri":"spotify:track:4NeHCGpTPVCudqVpJiT7O9"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0X2BH1fck6amBIoJhDVmmJ"},"href":"https://api.spotify.com/v1/artists/0X2BH1fck6amBIoJhDVmmJ","id":"0X2BH1fck6amBIoJhDVmmJ","name":"Ellie Goulding","type":"artist","uri":"spotify:artist:0X2BH1fck6amBIoJhDVmmJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/6YIaqFvhOWma5gbjcB18Nu"},"href":"https://api.spotify.com/v1/albums/6YIaqFvhOWma5gbjcB18Nu","id":"6YIaqFvhOWma5gbjcB18Nu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dc12b2bd6884bd1de21b6bae"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dc12b2bd6884bd1de21b6bae"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dc12b2bd6884bd1de21b6bae"}],"is_playable":true,"name":"Still Falling For You (From \"Bridget Jones's Baby\" Original Motion Picture Soundtrack)","release_date":"2016-08-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6YIaqFvhOWma5gbjcB18Nu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0X2BH1fck6amBIoJhDVmmJ"},"href":"https://api.spotify.com/v1/artists/0X2BH1fck6amBIoJhDVmmJ","id":"0X2BH1fck6amBIoJhDVmmJ","name":"Ellie Goulding","type":"artist","uri":"spotify:artist:0X2BH1fck6amBIoJhDVmmJ"}],"disc_number":1,"duration_ms":240867,"explicit":false,"external_ids":{"isrc":"GBUM71603863"},"external_urls":{"spotify":"https://open.spotify.com/track/3odrUVQ9tvRpkC9II2oWzx"},"href":"https://api.spotify.com/v1/tracks/3odrUVQ9tvRpkC9II2oWzx","id":"3odrUVQ9tvRpkC9II2oWzx","is_local":false,"is_playable":true,"name":"Still Falling For You - From \"Bridget Jones's Baby\"","track_number":1,"type":"track","uri":"spotify:track:3odrUVQ9tvRpkC9II2oWzx"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LnP8n2mREw2UvRL00TJqt"},"href":"https://api.spotify.com/v1/artists/0LnP8n2mREw2UvRL00TJqt","id":"0LnP8n2mREw2UvRL00TJqt","name":"Thunder","type":"artist","uri":"spotify:artist:0LnP8n2mREw2UvRL00TJqt"}],"external_urls":{"spotify":"https://open.spotify.com/album/6XXhuAZqKzaXyH0yoj0NR6"},"href":"https://api.spotify.com/v1/albums/6XXhuAZqKzaXyH0yoj0NR6","id":"6XXhuAZqKzaXyH0yoj0NR6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c30c17a73641c052992bcdd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c30c17a73641c052992bcdd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c30c17a73641c052992bcdd"}],"is_playable":true,"name":"Falling Skies","release_date":"2026-05-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6XXhuAZqKzaXyH0yoj0NR6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LnP8n2mREw2UvRL00TJqt"},"href":"https://api.spotify.com/v1/artists/0LnP8n2mREw2UvRL00TJqt","id":"0LnP8n2mREw2UvRL00TJqt","name":"Thunder","type":"artist","uri":"spotify:artist:0LnP8n2mREw2UvRL00TJqt"}],"disc_number":1,"duration_ms":129581,"explicit":false,"external_ids":{"isrc":"GXGUF2600190"},"external_urls":{"spotify":"https://open.spotify.com/track/20hrOUl7Li5LBgUH2lH3o2"},"href":"https://api.spotify.com/v1/tracks/20hrOUl7Li5LBgUH2lH3o2","id":"20hrOUl7Li5LBgUH2lH3o2","is_local":false,"is_playable":true,"name":"Falling Skies","track_number":1,"type":"track","uri":"spotify:track:20hrOUl7Li5LBgUH2lH3o2"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6qqNVTkY8uBg9cP3Jd7DAH"},"href":"https://api.spotify.com/v1/artists/6qqNVTkY8uBg9cP3Jd7DAH","id":"6qqNVTkY8uBg9cP3Jd7DAH","name":"Billie Eilish","type":"artist","uri":"spotify:artist:6qqNVTkY8uBg9cP3Jd7DAH"}],"external_urls":{"spotify":"https://open.spotify.com/album/2msN7XBgV3JCjQ7Tq3t7i9"},"href":"https://api.spotify.com/v1/albums/2msN7XBgV3JCjQ7Tq3t7i9","id":"2msN7XBgV3JCjQ7Tq3t7i9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732cafcdd985630d72594ecc49"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022cafcdd985630d72594ecc49"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512cafcdd985630d72594ecc49"}],"is_playable":true,"name":"Ocean Eyes","release_date":"2016-11-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2msN7XBgV3JCjQ7Tq3t7i9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6qqNVTkY8uBg9cP3Jd7DAH"},"href":"https://api.spotify.com/v1/artists/6qqNVTkY8uBg9cP3Jd7DAH","id":"6qqNVTkY8uBg9cP3Jd7DAH","name":"Billie Eilish","type":"artist","uri":"spotify:artist:6qqNVTkY8uBg9cP3Jd7DAH"}],"disc_number":1,"duration_ms":200560,"explicit":false,"external_ids":{"isrc":"US23A1500056"},"external_urls":{"spotify":"https://open.spotify.com/track/2uIX8YMNjGMD7441kqyyNU"},"href":"https://api.spotify.com/v1/tracks/2uIX8YMNjGMD7441kqyyNU","id":"2uIX8YMNjGMD7441kqyyNU","is_local":false,"is_playable":true,"name":"ocean eyes","track_number":1,"type":"track","uri":"spotify:track:2uIX8YMNjGMD7441kqyyNU"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35e9lLLCAkexOFe3m0pK0W"},"href":"https://api.spotify.com/v1/artists/35e9lLLCAkexOFe3m0pK0W","id":"35e9lLLCAkexOFe3m0pK0W","name":"Athena","type":"artist","uri":"spotify:artist:35e9lLLCAkexOFe3m0pK0W"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1JV42BPeocUJ0EyQh8ug6V"},"href":"https://api.spotify.com/v1/artists/1JV42BPeocUJ0EyQh8ug6V","id":"1JV42BPeocUJ0EyQh8ug6V","name":"smle","type":"artist","uri":"spotify:artist:1JV42BPeocUJ0EyQh8ug6V"}],"external_urls":{"spotify":"https://open.spotify.com/album/5LB31xPvUGvNI4EqqjXvtA"},"href":"https://api.spotify.com/v1/albums/5LB31xPvUGvNI4EqqjXvtA","id":"5LB31xPvUGvNI4EqqjXvtA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27340500f6856178be3539410b2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0240500f6856178be3539410b2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485140500f6856178be3539410b2"}],"is_playable":true,"name":"Eternal","release_date":"2021-08-06","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5LB31xPvUGvNI4EqqjXvtA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35e9lLLCAkexOFe3m0pK0W"},"href":"https://api.spotify.com/v1/artists/35e9lLLCAkexOFe3m0pK0W","id":"35e9lLLCAkexOFe3m0pK0W","name":"Athena","type":"artist","uri":"spotify:artist:35e9lLLCAkexOFe3m0pK0W"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1JV42BPeocUJ0EyQh8ug6V"},"href":"https://api.spotify.com/v1/artists/1JV42BPeocUJ0EyQh8ug6V","id":"1JV42BPeocUJ0EyQh8ug6V","name":"smle","type":"artist","uri":"spotify:artist:1JV42BPeocUJ0EyQh8ug6V"}],"disc_number":1,"duration_ms":213677,"explicit":false,"external_ids":{"isrc":"CA6D22100375"},"external_urls":{"spotify":"https://open.spotify.com/track/5IPNnqPAvdVEcYanVKihca"},"href":"https://api.spotify.com/v1/tracks/5IPNnqPAvdVEcYanVKihca","id":"5IPNnqPAvdVEcYanVKihca","is_local":false,"is_playable":true,"name":"Eternal","track_number":1,"type":"track","uri":"spotify:track:5IPNnqPAvdVEcYanVKihca"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4A18NGfdKU0HrkmvVlPO7I"},"href":"https://api.spotify.com/v1/artists/4A18NGfdKU0HrkmvVlPO7I","id":"4A18NGfdKU0HrkmvVlPO7I","name":"Fytch","type":"artist","uri":"spotify:artist:4A18NGfdKU0HrkmvVlPO7I"}],"external_urls":{"spotify":"https://open.spotify.com/album/0YChicHycz2rV5Trkev048"},"href":"https://api.spotify.com/v1/albums/0YChicHycz2rV5Trkev048","id":"0YChicHycz2rV5Trkev048","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733f01edb431b30d6e0966d434"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023f01edb431b30d6e0966d434"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513f01edb431b30d6e0966d434"}],"is_playable":true,"name":"Sirens Over Paris","release_date":"2016-01-14","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0YChicHycz2rV5Trkev048"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4A18NGfdKU0HrkmvVlPO7I"},"href":"https://api.spotify.com/v1/artists/4A18NGfdKU0HrkmvVlPO7I","id":"4A18NGfdKU0HrkmvVlPO7I","name":"Fytch","type":"artist","uri":"spotify:artist:4A18NGfdKU0HrkmvVlPO7I"}],"disc_number":1,"duration_ms":186039,"explicit":false,"external_ids":{"isrc":"GBSMU2505849"},"external_urls":{"spotify":"https://open.spotify.com/track/3UGOOHrBoj18PmthMzZMuk"},"href":"https://api.spotify.com/v1/tracks/3UGOOHrBoj18PmthMzZMuk","id":"3UGOOHrBoj18PmthMzZMuk","is_local":false,"is_playable":true,"name":"Sirens Over Paris","track_number":1,"type":"track","uri":"spotify:track:3UGOOHrBoj18PmthMzZMuk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3vDYGs9p4Y6GpfvxJDDhjx"},"href":"https://api.spotify.com/v1/artists/3vDYGs9p4Y6GpfvxJDDhjx","id":"3vDYGs9p4Y6GpfvxJDDhjx","name":"Ragal Ironbull","type":"artist","uri":"spotify:artist:3vDYGs9p4Y6GpfvxJDDhjx"}],"external_urls":{"spotify":"https://open.spotify.com/album/4k5z9pJyqTx5ia7F9BH1Ss"},"href":"https://api.spotify.com/v1/albums/4k5z9pJyqTx5ia7F9BH1Ss","id":"4k5z9pJyqTx5ia7F9BH1Ss","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273deb2f060ec2224b1e222bb3e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02deb2f060ec2224b1e222bb3e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851deb2f060ec2224b1e222bb3e"}],"is_playable":true,"name":"VALHALLA CALLING","release_date":"2026-04-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4k5z9pJyqTx5ia7F9BH1Ss"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3vDYGs9p4Y6GpfvxJDDhjx"},"href":"https://api.spotify.com/v1/artists/3vDYGs9p4Y6GpfvxJDDhjx","id":"3vDYGs9p4Y6GpfvxJDDhjx","name":"Ragal Ironbull","type":"artist","uri":"spotify:artist:3vDYGs9p4Y6GpfvxJDDhjx"}],"disc_number":1,"duration_ms":195599,"explicit":false,"external_ids":{"isrc":"SE6HN2675632"},"external_urls":{"spotify":"https://open.spotify.com/track/0fMXHtOEGKJvMJiivwNqnx"},"href":"https://api.spotify.com/v1/tracks/0fMXHtOEGKJvMJiivwNqnx","id":"0fMXHtOEGKJvMJiivwNqnx","is_local":false,"is_playable":true,"name":"VALHALLA CALLING","track_number":1,"type":"track","uri":"spotify:track:0fMXHtOEGKJvMJiivwNqnx"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1FhXKPXLyZWFPPB7J0zL3h"},"href":"https://api.spotify.com/v1/artists/1FhXKPXLyZWFPPB7J0zL3h","id":"1FhXKPXLyZWFPPB7J0zL3h","name":"Valkarian","type":"artist","uri":"spotify:artist:1FhXKPXLyZWFPPB7J0zL3h"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1876kriiz6RY8KXgdhfGzY"},"href":"https://api.spotify.com/v1/artists/1876kriiz6RY8KXgdhfGzY","id":"1876kriiz6RY8KXgdhfGzY","name":"Folktale Equinox","type":"artist","uri":"spotify:artist:1876kriiz6RY8KXgdhfGzY"}],"external_urls":{"spotify":"https://open.spotify.com/album/4C0M9vsq633wgXderuSYs8"},"href":"https://api.spotify.com/v1/albums/4C0M9vsq633wgXderuSYs8","id":"4C0M9vsq633wgXderuSYs8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733100efaea0d184a79637ab87"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023100efaea0d184a79637ab87"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513100efaea0d184a79637ab87"}],"is_playable":true,"name":"VALHALLA CALLING","release_date":"2026-04-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4C0M9vsq633wgXderuSYs8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1FhXKPXLyZWFPPB7J0zL3h"},"href":"https://api.spotify.com/v1/artists/1FhXKPXLyZWFPPB7J0zL3h","id":"1FhXKPXLyZWFPPB7J0zL3h","name":"Valkarian","type":"artist","uri":"spotify:artist:1FhXKPXLyZWFPPB7J0zL3h"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1876kriiz6RY8KXgdhfGzY"},"href":"https://api.spotify.com/v1/artists/1876kriiz6RY8KXgdhfGzY","id":"1876kriiz6RY8KXgdhfGzY","name":"Folktale Equinox","type":"artist","uri":"spotify:artist:1876kriiz6RY8KXgdhfGzY"}],"disc_number":1,"duration_ms":195624,"explicit":false,"external_ids":{"isrc":"SE6HN2675632"},"external_urls":{"spotify":"https://open.spotify.com/track/7awgnbg783nFlMuW2BhIuD"},"href":"https://api.spotify.com/v1/tracks/7awgnbg783nFlMuW2BhIuD","id":"7awgnbg783nFlMuW2BhIuD","is_local":false,"is_playable":true,"name":"VALHALLA CALLING","track_number":1,"type":"track","uri":"spotify:track:7awgnbg783nFlMuW2BhIuD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KEHIUSoWCcqrk8AddTE1O"},"href":"https://api.spotify.com/v1/artists/4KEHIUSoWCcqrk8AddTE1O","id":"4KEHIUSoWCcqrk8AddTE1O","name":"Panchiko","type":"artist","uri":"spotify:artist:4KEHIUSoWCcqrk8AddTE1O"}],"external_urls":{"spotify":"https://open.spotify.com/album/2MASm01cgG0a0CgioQpe6Q"},"href":"https://api.spotify.com/v1/albums/2MASm01cgG0a0CgioQpe6Q","id":"2MASm01cgG0a0CgioQpe6Q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e045aa197ada995407bf92fc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e045aa197ada995407bf92fc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e045aa197ada995407bf92fc"}],"is_playable":true,"name":"D>E>A>T>H>M>E>T>A>L","release_date":"2000-12-05","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:2MASm01cgG0a0CgioQpe6Q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KEHIUSoWCcqrk8AddTE1O"},"href":"https://api.spotify.com/v1/artists/4KEHIUSoWCcqrk8AddTE1O","id":"4KEHIUSoWCcqrk8AddTE1O","name":"Panchiko","type":"artist","uri":"spotify:artist:4KEHIUSoWCcqrk8AddTE1O"}],"disc_number":1,"duration_ms":163544,"explicit":false,"external_ids":{"isrc":"GBEF30000003"},"external_urls":{"spotify":"https://open.spotify.com/track/2zYBRyHAy6dv1wb53JXFD7"},"href":"https://api.spotify.com/v1/tracks/2zYBRyHAy6dv1wb53JXFD7","id":"2zYBRyHAy6dv1wb53JXFD7","is_local":false,"is_playable":true,"name":"Laputa","track_number":3,"type":"track","uri":"spotify:track:2zYBRyHAy6dv1wb53JXFD7"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1agQRMfB9CcPB9CtF68Y23"},"href":"https://api.spotify.com/v1/albums/1agQRMfB9CcPB9CtF68Y23","id":"1agQRMfB9CcPB9CtF68Y23","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c36b29184d3e9d104750f1e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c36b29184d3e9d104750f1e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c36b29184d3e9d104750f1e"}],"is_playable":true,"name":"Rainy Days Music","release_date":"2026-07-31","release_date_precision":"day","total_tracks":56,"type":"album","uri":"spotify:album:1agQRMfB9CcPB9CtF68Y23"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0X2BH1fck6amBIoJhDVmmJ"},"href":"https://api.spotify.com/v1/artists/0X2BH1fck6amBIoJhDVmmJ","id":"0X2BH1fck6amBIoJhDVmmJ","name":"Ellie Goulding","type":"artist","uri":"spotify:artist:0X2BH1fck6amBIoJhDVmmJ"}],"disc_number":1,"duration_ms":240867,"explicit":false,"external_ids":{"isrc":"GBUM71603863"},"external_urls":{"spotify":"https://open.spotify.com/track/3ZQFfZLtCmbonE8PfAYshf"},"href":"https://api.spotify.com/v1/tracks/3ZQFfZLtCmbonE8PfAYshf","id":"3ZQFfZLtCmbonE8PfAYshf","is_local":false,"is_playable":true,"name":"Still Falling For You - From \"Bridget Jones's Baby\"","track_number":26,"type":"track","uri":"spotify:track:3ZQFfZLtCmbonE8PfAYshf"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1GYWxsaW5nJTIwU2tpZXMlMjBLZWVubyZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvc2VhcmNoP29mZnNldD0xMCZsaW1pdD0xMCZxdWVyeT1GYWxsaW5nJTIwU2tpZXMlMjBLZWVubyZ0eXBlPXRyYWNrIiwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjExLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm1rdko2WEhXVnRQZXI4azBCMG5UbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bWt2SjZYSFdWdFBlcjhrMEIwblRuIiwiaWQiOiI2bWt2SjZYSFdWdFBlcjhrMEIwblRuIiwibmFtZSI6IldpbGV5IGZyb20gQXRsYW50YSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bWt2SjZYSFdWdFBlcjhrMEIwblRuIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNE5zcUpEc2Z4c0NNVXhRdzNPN0EwRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzROc3FKRHNmeHNDTVV4UXczTzdBMEQiLCJpZCI6IjROc3FKRHNmeHNDTVV4UXcz", + "TzdBMEQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDMxODhiNmUzNGVhNmEyYWYxMzc0MDFmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQzMTg4YjZlMzRlYTZhMmFmMTM3NDAxZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDMxODhiNmUzNGVhNmEyYWYxMzc0MDFmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlbW8gMDAxIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0xMC0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NE5zcUpEc2Z4c0NNVXhRdzNPN0EwRCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZta3ZKNlhIV1Z0UGVyOGswQjBuVG4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm1rdko2WEhXVnRQZXI4azBCMG5UbiIsImlkIjoiNm1rdko2WEhXVnRQZXI4azBCMG5UbiIsIm5hbWUiOiJXaWxleSBmcm9tIEF0bGFudGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm1rdko2WEhXVnRQZXI4azBCMG5UbiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjMxMDEsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFNMjRTMTg0MDEzNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNE5lSENHcFRQVkN1ZHFWcEppVDdPOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzROZUhDR3BUUFZDdWRxVnBKaVQ3TzkiLCJpZCI6IjROZUhDR3BUUFZDdWRxVnBKaVQ3TzkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUGluayBTa2llcyAoRGVtbykiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NE5lSENHcFRQVkN1ZHFWcEppVDdPOSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFgyQkgxZmNrNmFtQklvSmhEVm1tSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wWDJCSDFmY2s2YW1CSW9KaA==", + "RFZtbUoiLCJpZCI6IjBYMkJIMWZjazZhbUJJb0poRFZtbUoiLCJuYW1lIjoiRWxsaWUgR291bGRpbmciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFgyQkgxZmNrNmFtQklvSmhEVm1tSiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZZSWFxRnZoT1dtYTVnYmpjQjE4TnUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82WUlhcUZ2aE9XbWE1Z2JqY0IxOE51IiwiaWQiOiI2WUlhcUZ2aE9XbWE1Z2JqY0IxOE51IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2RjMTJiMmJkNjg4NGJkMWRlMjFiNmJhZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkYzEyYjJiZDY4ODRiZDFkZTIxYjZiYWUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWRjMTJiMmJkNjg4NGJkMWRlMjFiNmJhZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdGlsbCBGYWxsaW5nIEZvciBZb3UgKEZyb20gXCJCcmlkZ2V0IEpvbmVzJ3MgQmFieVwiIE9yaWdpbmFsIE1vdGlvbiBQaWN0dXJlIFNvdW5kdHJhY2spIiwicmVsZWFzZV9kYXRlIjoiMjAxNi0wOC0xOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NllJYXFGdmhPV21hNWdiamNCMThOdSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBYMkJIMWZjazZhbUJJb0poRFZtbUoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFgyQkgxZmNrNmFtQklvSmhEVm1tSiIsImlkIjoiMFgyQkgxZmNrNmFtQklvSmhEVm1tSiIsIm5hbWUiOiJFbGxpZSBHb3VsZGluZyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowWDJCSDFmY2s2YW1CSW9KaERWbW1KIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDg2NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MTYwMzg2MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM29kclVWUTl0dlJwa0M5SUkyb1d6eCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNvZHJVVlE5dA==", + "dlJwa0M5SUkyb1d6eCIsImlkIjoiM29kclVWUTl0dlJwa0M5SUkyb1d6eCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdGlsbCBGYWxsaW5nIEZvciBZb3UgLSBGcm9tIFwiQnJpZGdldCBKb25lcydzIEJhYnlcIiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozb2RyVVZROXR2UnBrQzlJSTJvV3p4In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTG5QOG4ybVJFdzJVdlJMMDBUSnF0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMblA4bjJtUkV3MlV2UkwwMFRKcXQiLCJpZCI6IjBMblA4bjJtUkV3MlV2UkwwMFRKcXQiLCJuYW1lIjoiVGh1bmRlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTG5QOG4ybVJFdzJVdlJMMDBUSnF0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNlhYaHVBWnFLemFYeUgweW9qME5SNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZYWGh1QVpxS3phWHlIMHlvajBOUjYiLCJpZCI6IjZYWGh1QVpxS3phWHlIMHlvajBOUjYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmMzMGMxN2E3MzY0MWMwNTI5OTJiY2RkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZjMzBjMTdhNzM2NDFjMDUyOTkyYmNkZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmMzMGMxN2E3MzY0MWMwNTI5OTJiY2RkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZhbGxpbmcgU2tpZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA1LTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2WFhodUFacUt6YVh5SDB5b2owTlI2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMExuUDhuMm1SRXcyVXZSTDAwVEpxdCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTG5QOG4ybVJFdzJVdlJMMDBUSnF0IiwiaWQiOiIwTG5QOG4ybVJFdw==", + "MlV2UkwwMFRKcXQiLCJuYW1lIjoiVGh1bmRlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTG5QOG4ybVJFdzJVdlJMMDBUSnF0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEyOTU4MSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdYR1VGMjYwMDE5MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMjBock9VbDdMaTVMQmdVSDJsSDNvMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzIwaHJPVWw3TGk1TEJnVUgybEgzbzIiLCJpZCI6IjIwaHJPVWw3TGk1TEJnVUgybEgzbzIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmFsbGluZyBTa2llcyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyMGhyT1VsN0xpNUxCZ1VIMmxIM28yIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82cXFOVlRrWTh1Qmc5Y1AzSmQ3REFIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZxcU5WVGtZOHVCZzljUDNKZDdEQUgiLCJpZCI6IjZxcU5WVGtZOHVCZzljUDNKZDdEQUgiLCJuYW1lIjoiQmlsbGllIEVpbGlzaCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2cXFOVlRrWTh1Qmc5Y1AzSmQ3REFIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMm1zTjdYQmdWM0pDalE3VHEzdDdpOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJtc043WEJnVjNKQ2pRN1RxM3Q3aTkiLCJpZCI6IjJtc043WEJnVjNKQ2pRN1RxM3Q3aTkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMmNhZmNkZDk4NTYzMGQ3MjU5NGVjYzQ5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjJjYWZjZGQ5ODU2MzBkNzI1OTRlY2M0OSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMmNhZmNkZDk4NTYzMGQ3MjU5NGVjYzQ5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik9jZWFuIEV5ZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTExLTE4IiwicmVsZQ==", + "YXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJtc043WEJnVjNKQ2pRN1RxM3Q3aTkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82cXFOVlRrWTh1Qmc5Y1AzSmQ3REFIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZxcU5WVGtZOHVCZzljUDNKZDdEQUgiLCJpZCI6IjZxcU5WVGtZOHVCZzljUDNKZDdEQUgiLCJuYW1lIjoiQmlsbGllIEVpbGlzaCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2cXFOVlRrWTh1Qmc5Y1AzSmQ3REFIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwMDU2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTMjNBMTUwMDA1NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMnVJWDhZTU5qR01ENzQ0MWtxeXlOVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJ1SVg4WU1OakdNRDc0NDFrcXl5TlUiLCJpZCI6IjJ1SVg4WU1OakdNRDc0NDFrcXl5TlUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoib2NlYW4gZXllcyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoydUlYOFlNTmpHTUQ3NDQxa3F5eU5VIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zNWU5bExMQ0FrZXhPRmUzbTBwSzBXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzM1ZTlsTExDQWtleE9GZTNtMHBLMFciLCJpZCI6IjM1ZTlsTExDQWtleE9GZTNtMHBLMFciLCJuYW1lIjoiQXRoZW5hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjM1ZTlsTExDQWtleE9GZTNtMHBLMFcifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMUpWNDJCUGVvY1VKMEV5UWg4dWc2ViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xSlY0MkJQZW9jVUowRXlRaDh1ZzZWIiwiaWQiOiIxSlY0MkJQZW9jVUowRXlRaDh1ZzZWIiwibmFtZSI6InNtbGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUpWNDJCUGVvY1VKMEV5UWg4dWc2ViJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcA==", + "b3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUxCMzF4UHZVR3ZOSTRFcXFqWHZ0QSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVMQjMxeFB2VUd2Tkk0RXFxalh2dEEiLCJpZCI6IjVMQjMxeFB2VUd2Tkk0RXFxalh2dEEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDA1MDBmNjg1NjE3OGJlMzUzOTQxMGIyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQwNTAwZjY4NTYxNzhiZTM1Mzk0MTBiMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDA1MDBmNjg1NjE3OGJlMzUzOTQxMGIyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkV0ZXJuYWwiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTA4LTA2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1TEIzMXhQdlVHdk5JNEVxcWpYdnRBIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzVlOWxMTENBa2V4T0ZlM20wcEswVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zNWU5bExMQ0FrZXhPRmUzbTBwSzBXIiwiaWQiOiIzNWU5bExMQ0FrZXhPRmUzbTBwSzBXIiwibmFtZSI6IkF0aGVuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozNWU5bExMQ0FrZXhPRmUzbTBwSzBXIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFKVjQyQlBlb2NVSjBFeVFoOHVnNlYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUpWNDJCUGVvY1VKMEV5UWg4dWc2ViIsImlkIjoiMUpWNDJCUGVvY1VKMEV5UWg4dWc2ViIsIm5hbWUiOiJzbWxlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFKVjQyQlBlb2NVSjBFeVFoOHVnNlYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjEzNjc3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiQ0E2RDIyMTAwMzc1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81SVBObnFQQXZkVkVjWWFuVktpaGNhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aQ==", + "ZnkuY29tL3YxL3RyYWNrcy81SVBObnFQQXZkVkVjWWFuVktpaGNhIiwiaWQiOiI1SVBObnFQQXZkVkVjWWFuVktpaGNhIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkV0ZXJuYWwiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUlQTm5xUEF2ZFZFY1lhblZLaWhjYSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEExOE5HZmRLVTBIcmttdlZsUE83SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80QTE4TkdmZEtVMEhya212VmxQTzdJIiwiaWQiOiI0QTE4TkdmZEtVMEhya212VmxQTzdJIiwibmFtZSI6IkZ5dGNoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRBMThOR2ZkS1UwSHJrbXZWbFBPN0kifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wWUNoaWNIeWN6MnJWNVRya2V2MDQ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMFlDaGljSHljejJyVjVUcmtldjA0OCIsImlkIjoiMFlDaGljSHljejJyVjVUcmtldjA0OCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzZjAxZWRiNDMxYjMwZDZlMDk2NmQ0MzQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyM2YwMWVkYjQzMWIzMGQ2ZTA5NjZkNDM0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzZjAxZWRiNDMxYjMwZDZlMDk2NmQ0MzQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2lyZW5zIE92ZXIgUGFyaXMiLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTAxLTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowWUNoaWNIeWN6MnJWNVRya2V2MDQ4In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEExOE5HZmRLVTBIcmttdlZsUE83SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80QTE4TkdmZEtVMEhya212VmxQTzdJIiwiaWQiOiI0QTE4TkdmZEtVMEhya212VmxQTzdJIiwibmFtZQ==", + "IjoiRnl0Y2giLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEExOE5HZmRLVTBIcmttdlZsUE83SSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODYwMzksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlNNVTI1MDU4NDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNVR09PSHJCb2oxOFBtdGhNelpNdWsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zVUdPT0hyQm9qMThQbXRoTXpaTXVrIiwiaWQiOiIzVUdPT0hyQm9qMThQbXRoTXpaTXVrIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNpcmVucyBPdmVyIFBhcmlzIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNVR09PSHJCb2oxOFBtdGhNelpNdWsifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN2RFlHczlwNFk2R3BmdnhKRERoangifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3ZEWUdzOXA0WTZHcGZ2eEpERGhqeCIsImlkIjoiM3ZEWUdzOXA0WTZHcGZ2eEpERGhqeCIsIm5hbWUiOiJSYWdhbCBJcm9uYnVsbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdkRZR3M5cDRZNkdwZnZ4SkREaGp4In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNGs1ejlwSnlxVHg1aWE3RjlCSDFTcyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRrNXo5cEp5cVR4NWlhN0Y5QkgxU3MiLCJpZCI6IjRrNXo5cEp5cVR4NWlhN0Y5QkgxU3MiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZGViMmYwNjBlYzIyMjRiMWUyMjJiYjNlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmRlYjJmMDYwZWMyMjI0YjFlMjIyYmIzZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZGViMmYwNjBlYzIyMjRiMWUyMjJiYjNlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZBTEhBTExBIENBTExJTkciLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA0LTAzIiwicmVsZWFzZV9kYXRlXw==", + "cHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRrNXo5cEp5cVR4NWlhN0Y5QkgxU3MifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdkRZR3M5cDRZNkdwZnZ4SkREaGp4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN2RFlHczlwNFk2R3BmdnhKRERoangiLCJpZCI6IjN2RFlHczlwNFk2R3BmdnhKRERoangiLCJuYW1lIjoiUmFnYWwgSXJvbmJ1bGwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3ZEWUdzOXA0WTZHcGZ2eEpERGhqeCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTU1OTksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJTRTZITjI2NzU2MzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBmTVhIdE9FR0tKdk1KaWl2d05xbngifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wZk1YSHRPRUdLSnZNSmlpdndOcW54IiwiaWQiOiIwZk1YSHRPRUdLSnZNSmlpdndOcW54IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlZBTEhBTExBIENBTExJTkciLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGZNWEh0T0VHS0p2TUppaXZ3TnFueCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMUZoWEtQWEx5WldGUFBCN0owekwzaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xRmhYS1BYTHlaV0ZQUEI3SjB6TDNoIiwiaWQiOiIxRmhYS1BYTHlaV0ZQUEI3SjB6TDNoIiwibmFtZSI6IlZhbGthcmlhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxRmhYS1BYTHlaV0ZQUEI3SjB6TDNoIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzE4NzZrcmlpejZSWThLWGdkaGZHelkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTg3NmtyaWl6NlJZOEtYZ2RoZkd6WSIsImlkIjoiMTg3NmtyaWl6NlJZOEtYZ2RoZkd6WSIsIm5hbWUiOiJGb2xrdGFsZSBFcXVpbm94IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE4NzZrcmlpejZSWThLWGdkaGZHelkifV0sImV4dGVybg==", + "YWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRDME05dnNxNjMzd2dYZGVydVNZczgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80QzBNOXZzcTYzM3dnWGRlcnVTWXM4IiwiaWQiOiI0QzBNOXZzcTYzM3dnWGRlcnVTWXM4IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzMxMDBlZmFlYTBkMTg0YTc5NjM3YWI4NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzMTAwZWZhZWEwZDE4NGE3OTYzN2FiODcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTMxMDBlZmFlYTBkMTg0YTc5NjM3YWI4NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWQUxIQUxMQSBDQUxMSU5HIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNC0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEMwTTl2c3E2MzN3Z1hkZXJ1U1lzOCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFGaFhLUFhMeVpXRlBQQjdKMHpMM2gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUZoWEtQWEx5WldGUFBCN0owekwzaCIsImlkIjoiMUZoWEtQWEx5WldGUFBCN0owekwzaCIsIm5hbWUiOiJWYWxrYXJpYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUZoWEtQWEx5WldGUFBCN0owekwzaCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xODc2a3JpaXo2Ulk4S1hnZGhmR3pZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzE4NzZrcmlpejZSWThLWGdkaGZHelkiLCJpZCI6IjE4NzZrcmlpejZSWThLWGdkaGZHelkiLCJuYW1lIjoiRm9sa3RhbGUgRXF1aW5veCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxODc2a3JpaXo2Ulk4S1hnZGhmR3pZIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NTYyNCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlNFNkhOMjY3NTYzMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2F3Z25iZzc4M25GbA==", + "TXVXMkJoSXVEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2F3Z25iZzc4M25GbE11VzJCaEl1RCIsImlkIjoiN2F3Z25iZzc4M25GbE11VzJCaEl1RCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWQUxIQUxMQSBDQUxMSU5HIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdhd2duYmc3ODNuRmxNdVcyQmhJdUQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEtFSElVU29XQ2Nxcms4QWRkVEUxTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80S0VISVVTb1dDY3FyazhBZGRURTFPIiwiaWQiOiI0S0VISVVTb1dDY3FyazhBZGRURTFPIiwibmFtZSI6IlBhbmNoaWtvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRLRUhJVVNvV0NjcXJrOEFkZFRFMU8ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yTUFTbTAxY2dHMGEwQ2dpb1FwZTZRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMk1BU20wMWNnRzBhMENnaW9RcGU2USIsImlkIjoiMk1BU20wMWNnRzBhMENnaW9RcGU2USIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlMDQ1YWExOTdhZGE5OTU0MDdiZjkyZmMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTA0NWFhMTk3YWRhOTk1NDA3YmY5MmZjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlMDQ1YWExOTdhZGE5OTU0MDdiZjkyZmMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRD5FPkE+VD5IPk0+RT5UPkE+TCIsInJlbGVhc2VfZGF0ZSI6IjIwMDAtMTItMDUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyTUFTbTAxY2dHMGEwQ2dpb1FwZTZRIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEtFSElVU29XQ2Nxcms4QWRkVEUxTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80S0VISVVTbw==", + "V0NjcXJrOEFkZFRFMU8iLCJpZCI6IjRLRUhJVVNvV0NjcXJrOEFkZFRFMU8iLCJuYW1lIjoiUGFuY2hpa28iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEtFSElVU29XQ2Nxcms4QWRkVEUxTyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjM1NDQsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkVGMzAwMDAwMDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJ6WUJSeUhBeTZkdjF3YjUzSlhGRDcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yellCUnlIQXk2ZHYxd2I1M0pYRkQ3IiwiaWQiOiIyellCUnlIQXk2ZHYxd2I1M0pYRkQ3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxhcHV0YSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyellCUnlIQXk2ZHYxd2I1M0pYRkQ3In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFhZ1FSTWZCOUNjUEI5Q3RGNjhZMjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xYWdRUk1mQjlDY1BCOUN0RjY4WTIzIiwiaWQiOiIxYWdRUk1mQjlDY1BCOUN0RjY4WTIzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZjMzZiMjkxODRkM2U5ZDEwNDc1MGYxZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2YzM2YjI5MTg0ZDNlOWQxMDQ3NTBmMWUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZjMzZiMjkxODRkM2U5ZDEwNDc1MGYxZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSYWlueSBEYXlzIA==", + "TXVzaWMiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA3LTMxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MWFnUVJNZkI5Q2NQQjlDdEY2OFkyMyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBYMkJIMWZjazZhbUJJb0poRFZtbUoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFgyQkgxZmNrNmFtQklvSmhEVm1tSiIsImlkIjoiMFgyQkgxZmNrNmFtQklvSmhEVm1tSiIsIm5hbWUiOiJFbGxpZSBHb3VsZGluZyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowWDJCSDFmY2s2YW1CSW9KaERWbW1KIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDg2NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MTYwMzg2MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM1pRRmZaTHRDbWJvbkU4UGZBWXNoZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNaUUZmWkx0Q21ib25FOFBmQVlzaGYiLCJpZCI6IjNaUUZmWkx0Q21ib25FOFBmQVlzaGYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3RpbGwgRmFsbGluZyBGb3IgWW91IC0gRnJvbSBcIkJyaWRnZXQgSm9uZXMncyBCYWJ5XCIiLCJ0cmFja19udW1iZXIiOjI2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNaUUZmWkx0Q21ib25FOFBmQVlzaGYifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Falling+Skies+Keeno&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Feel%20Your%20Way%20Alix%20Perez&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":10,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5n47Dui0H3pGpZSOxITmoq"},"href":"https://api.spotify.com/v1/albums/5n47Dui0H3pGpZSOxITmoq","id":"5n47Dui0H3pGpZSOxITmoq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b68df485f3304211904548a8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b68df485f3304211904548a8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b68df485f3304211904548a8"}],"is_playable":true,"name":"Grease (The Original Motion Picture Soundtrack)","release_date":"1978-04-04","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:5n47Dui0H3pGpZSOxITmoq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4hKkEHkaqCsyxNxXEsszVH"},"href":"https://api.spotify.com/v1/artists/4hKkEHkaqCsyxNxXEsszVH","id":"4hKkEHkaqCsyxNxXEsszVH","name":"John Travolta","type":"artist","uri":"spotify:artist:4hKkEHkaqCsyxNxXEsszVH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4BoRxUdrcgbbq1rxJvvhg9"},"href":"https://api.spotify.com/v1/artists/4BoRxUdrcgbbq1rxJvvhg9","id":"4BoRxUdrcgbbq1rxJvvhg9","name":"Olivia Newton-John","type":"artist","uri":"spotify:artist:4BoRxUdrcgbbq1rxJvvhg9"}],"disc_number":1,"duration_ms":169840,"explicit":false,"external_ids":{"isrc":"NLF057890004"},"external_urls":{"spotify":"https://open.spotify.com/track/0B9x2BRHqj3Qer7biM3pU3"},"href":"https://api.spotify.com/v1/tracks/0B9x2BRHqj3Qer7biM3pU3","id":"0B9x2BRHqj3Qer7biM3pU3","is_local":false,"is_playable":true,"name":"You're The One That I Want - From \u201cGrease\u201d","track_number":4,"type":"track","uri":"spotify:track:0B9x2BRHqj3Qer7biM3pU3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ew9JvyyuOGkhahuwdovDq"},"href":"https://api.spotify.com/v1/artists/2ew9JvyyuOGkhahuwdovDq","id":"2ew9JvyyuOGkhahuwdovDq","name":"Secondcity","type":"artist","uri":"spotify:artist:2ew9JvyyuOGkhahuwdovDq"}],"external_urls":{"spotify":"https://open.spotify.com/album/4mcxbqc3YvVJDWsBOawu1u"},"href":"https://api.spotify.com/v1/albums/4mcxbqc3YvVJDWsBOawu1u","id":"4mcxbqc3YvVJDWsBOawu1u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b9e42ee00fe863f73cd3653"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b9e42ee00fe863f73cd3653"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b9e42ee00fe863f73cd3653"}],"is_playable":true,"name":"I Wanna Feel","release_date":"2014-05-25","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:4mcxbqc3YvVJDWsBOawu1u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ew9JvyyuOGkhahuwdovDq"},"href":"https://api.spotify.com/v1/artists/2ew9JvyyuOGkhahuwdovDq","id":"2ew9JvyyuOGkhahuwdovDq","name":"Secondcity","type":"artist","uri":"spotify:artist:2ew9JvyyuOGkhahuwdovDq"}],"disc_number":1,"duration_ms":185543,"explicit":false,"external_ids":{"isrc":"GBD581400001"},"external_urls":{"spotify":"https://open.spotify.com/track/3PgSGAq2cOat72laH7uKFn"},"href":"https://api.spotify.com/v1/tracks/3PgSGAq2cOat72laH7uKFn","id":"3PgSGAq2cOat72laH7uKFn","is_local":false,"is_playable":true,"name":"I Wanna Feel - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:3PgSGAq2cOat72laH7uKFn"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/748dZDqSZy6aPXKcI9H80u"},"href":"https://api.spotify.com/v1/albums/748dZDqSZy6aPXKcI9H80u","id":"748dZDqSZy6aPXKcI9H80u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27378de8b28de36a74afc0348b5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0278de8b28de36a74afc0348b5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485178de8b28de36a74afc0348b5"}],"is_playable":true,"name":"good kid, m.A.A.d city (Deluxe)","release_date":"2012-10-22","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:748dZDqSZy6aPXKcI9H80u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":310720,"explicit":true,"external_ids":{"isrc":"USUM71210774"},"external_urls":{"spotify":"https://open.spotify.com/track/5h5tBFnbcVioFXiOixTn6E"},"href":"https://api.spotify.com/v1/tracks/5h5tBFnbcVioFXiOixTn6E","id":"5h5tBFnbcVioFXiOixTn6E","is_local":false,"is_playable":true,"name":"Bitch, Don\u2019t Kill My Vibe","track_number":2,"type":"track","uri":"spotify:track:5h5tBFnbcVioFXiOixTn6E"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GzWhE2xadJiW8MqRKIVSK"},"href":"https://api.spotify.com/v1/artists/3GzWhE2xadJiW8MqRKIVSK","id":"3GzWhE2xadJiW8MqRKIVSK","name":"Underoath","type":"artist","uri":"spotify:artist:3GzWhE2xadJiW8MqRKIVSK"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GeXnKDk6sD6RnkPVwFi19"},"href":"https://api.spotify.com/v1/albums/5GeXnKDk6sD6RnkPVwFi19","id":"5GeXnKDk6sD6RnkPVwFi19","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c05f1b9f41f21afa225ce2ae"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c05f1b9f41f21afa225ce2ae"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c05f1b9f41f21afa225ce2ae"}],"is_playable":true,"name":"They're Only Chasing Safety","release_date":"2004-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:5GeXnKDk6sD6RnkPVwFi19"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GzWhE2xadJiW8MqRKIVSK"},"href":"https://api.spotify.com/v1/artists/3GzWhE2xadJiW8MqRKIVSK","id":"3GzWhE2xadJiW8MqRKIVSK","name":"Underoath","type":"artist","uri":"spotify:artist:3GzWhE2xadJiW8MqRKIVSK"}],"disc_number":1,"duration_ms":268000,"explicit":false,"external_ids":{"isrc":"USTN10422712"},"external_urls":{"spotify":"https://open.spotify.com/track/47IWLfIKOKhFnz1FUEUIkE"},"href":"https://api.spotify.com/v1/tracks/47IWLfIKOKhFnz1FUEUIkE","id":"47IWLfIKOKhFnz1FUEUIkE","is_local":false,"is_playable":true,"name":"A Boy Brushed Red Living In Black And White","track_number":2,"type":"track","uri":"spotify:track:47IWLfIKOKhFnz1FUEUIkE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/336vr2M3Va0FjyvB55lJEd"},"href":"https://api.spotify.com/v1/artists/336vr2M3Va0FjyvB55lJEd","id":"336vr2M3Va0FjyvB55lJEd","name":"D'Angelo","type":"artist","uri":"spotify:artist:336vr2M3Va0FjyvB55lJEd"}],"external_urls":{"spotify":"https://open.spotify.com/album/2lO9yuuIDgBpSJzxTh3ai8"},"href":"https://api.spotify.com/v1/albums/2lO9yuuIDgBpSJzxTh3ai8","id":"2lO9yuuIDgBpSJzxTh3ai8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732b3dc336a7a69293c25d9ade"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022b3dc336a7a69293c25d9ade"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512b3dc336a7a69293c25d9ade"}],"is_playable":true,"name":"Voodoo","release_date":"2000-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2lO9yuuIDgBpSJzxTh3ai8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/336vr2M3Va0FjyvB55lJEd"},"href":"https://api.spotify.com/v1/artists/336vr2M3Va0FjyvB55lJEd","id":"336vr2M3Va0FjyvB55lJEd","name":"D'Angelo","type":"artist","uri":"spotify:artist:336vr2M3Va0FjyvB55lJEd"}],"disc_number":1,"duration_ms":430800,"explicit":false,"external_ids":{"isrc":"USVI29900212"},"external_urls":{"spotify":"https://open.spotify.com/track/4oPNN7syJYSjzDhRerF966"},"href":"https://api.spotify.com/v1/tracks/4oPNN7syJYSjzDhRerF966","id":"4oPNN7syJYSjzDhRerF966","is_local":false,"is_playable":true,"name":"Untitled (How Does It Feel)","track_number":12,"type":"track","uri":"spotify:track:4oPNN7syJYSjzDhRerF966"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6jJ0s89eD6GaHleKKya26X"},"href":"https://api.spotify.com/v1/artists/6jJ0s89eD6GaHleKKya26X","id":"6jJ0s89eD6GaHleKKya26X","name":"Katy Perry","type":"artist","uri":"spotify:artist:6jJ0s89eD6GaHleKKya26X"}],"external_urls":{"spotify":"https://open.spotify.com/album/5BvgP623rtvlc0HDcpzquz"},"href":"https://api.spotify.com/v1/albums/5BvgP623rtvlc0HDcpzquz","id":"5BvgP623rtvlc0HDcpzquz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273937af329667311f4b2831616"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02937af329667311f4b2831616"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851937af329667311f4b2831616"}],"is_playable":true,"name":"Teenage Dream: The Complete Confection","release_date":"2012-03-12","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:5BvgP623rtvlc0HDcpzquz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6jJ0s89eD6GaHleKKya26X"},"href":"https://api.spotify.com/v1/artists/6jJ0s89eD6GaHleKKya26X","id":"6jJ0s89eD6GaHleKKya26X","name":"Katy Perry","type":"artist","uri":"spotify:artist:6jJ0s89eD6GaHleKKya26X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"disc_number":1,"duration_ms":229573,"explicit":false,"external_ids":{"isrc":"USCA21100386"},"external_urls":{"spotify":"https://open.spotify.com/track/36ux3YuUsGTWPT8fXclS45"},"href":"https://api.spotify.com/v1/tracks/36ux3YuUsGTWPT8fXclS45","id":"36ux3YuUsGTWPT8fXclS45","is_local":false,"is_playable":true,"name":"E.T.","track_number":17,"type":"track","uri":"spotify:track:36ux3YuUsGTWPT8fXclS45"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ROfBX6lJLnCmaw1NrP5K9"},"href":"https://api.spotify.com/v1/albums/3ROfBX6lJLnCmaw1NrP5K9","id":"3ROfBX6lJLnCmaw1NrP5K9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b4c5982e1b92f97a126fc18c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b4c5982e1b92f97a126fc18c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b4c5982e1b92f97a126fc18c"}],"is_playable":true,"name":"I AM...SASHA FIERCE - Platinum Edition","release_date":"2008","release_date_precision":"year","total_tracks":20,"type":"album","uri":"spotify:album:3ROfBX6lJLnCmaw1NrP5K9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"disc_number":1,"duration_ms":261160,"explicit":false,"external_ids":{"isrc":"USSM10804556"},"external_urls":{"spotify":"https://open.spotify.com/track/2CvOqDpQIMw69cCzWqr5yr"},"href":"https://api.spotify.com/v1/tracks/2CvOqDpQIMw69cCzWqr5yr","id":"2CvOqDpQIMw69cCzWqr5yr","is_local":false,"is_playable":true,"name":"Halo","track_number":4,"type":"track","uri":"spotify:track:2CvOqDpQIMw69cCzWqr5yr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0YFqlnAFjvDH5a6CxineVK"},"href":"https://api.spotify.com/v1/artists/0YFqlnAFjvDH5a6CxineVK","id":"0YFqlnAFjvDH5a6CxineVK","name":"Velvet Trip","type":"artist","uri":"spotify:artist:0YFqlnAFjvDH5a6CxineVK"}],"external_urls":{"spotify":"https://open.spotify.com/album/7zZokVmJqbuBVc0drwjtx1"},"href":"https://api.spotify.com/v1/albums/7zZokVmJqbuBVc0drwjtx1","id":"7zZokVmJqbuBVc0drwjtx1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730edf16e689378c9fa92bf9f6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020edf16e689378c9fa92bf9f6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510edf16e689378c9fa92bf9f6"}],"is_playable":true,"name":"Glimmers Continued","release_date":"2026-01-30","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:7zZokVmJqbuBVc0drwjtx1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0YFqlnAFjvDH5a6CxineVK"},"href":"https://api.spotify.com/v1/artists/0YFqlnAFjvDH5a6CxineVK","id":"0YFqlnAFjvDH5a6CxineVK","name":"Velvet Trip","type":"artist","uri":"spotify:artist:0YFqlnAFjvDH5a6CxineVK"}],"disc_number":1,"duration_ms":207254,"explicit":false,"external_ids":{"isrc":"AUMGB2501615"},"external_urls":{"spotify":"https://open.spotify.com/track/3RcDpZSZrdG2rzucuE6TMV"},"href":"https://api.spotify.com/v1/tracks/3RcDpZSZrdG2rzucuE6TMV","id":"3RcDpZSZrdG2rzucuE6TMV","is_local":false,"is_playable":true,"name":"Fr3o","track_number":9,"type":"track","uri":"spotify:track:3RcDpZSZrdG2rzucuE6TMV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1hzfo8twXdOegF3xireCYs"},"href":"https://api.spotify.com/v1/artists/1hzfo8twXdOegF3xireCYs","id":"1hzfo8twXdOegF3xireCYs","name":"Milky Chance","type":"artist","uri":"spotify:artist:1hzfo8twXdOegF3xireCYs"}],"external_urls":{"spotify":"https://open.spotify.com/album/3anT3sq943fma4yCM5FhvG"},"href":"https://api.spotify.com/v1/albums/3anT3sq943fma4yCM5FhvG","id":"3anT3sq943fma4yCM5FhvG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739e8a543b2c7aa388a088c2ca"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029e8a543b2c7aa388a088c2ca"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519e8a543b2c7aa388a088c2ca"}],"is_playable":true,"name":"Trip Tape II","release_date":"2022-10-05","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3anT3sq943fma4yCM5FhvG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1hzfo8twXdOegF3xireCYs"},"href":"https://api.spotify.com/v1/artists/1hzfo8twXdOegF3xireCYs","id":"1hzfo8twXdOegF3xireCYs","name":"Milky Chance","type":"artist","uri":"spotify:artist:1hzfo8twXdOegF3xireCYs"}],"disc_number":1,"duration_ms":164576,"explicit":false,"external_ids":{"isrc":"DEVP22200014"},"external_urls":{"spotify":"https://open.spotify.com/track/3GXgrEjBjonrQrPEEi13yU"},"href":"https://api.spotify.com/v1/tracks/3GXgrEjBjonrQrPEEi13yU","id":"3GXgrEjBjonrQrPEEi13yU","is_local":false,"is_playable":true,"name":"Synchronize","track_number":1,"type":"track","uri":"spotify:track:3GXgrEjBjonrQrPEEi13yU"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0cGUm45nv7Z6M6qdXYQGTX"},"href":"https://api.spotify.com/v1/artists/0cGUm45nv7Z6M6qdXYQGTX","id":"0cGUm45nv7Z6M6qdXYQGTX","name":"Kehlani","type":"artist","uri":"spotify:artist:0cGUm45nv7Z6M6qdXYQGTX"}],"external_urls":{"spotify":"https://open.spotify.com/album/2MRNLEYm9SB0HBrJEU8L32"},"href":"https://api.spotify.com/v1/albums/2MRNLEYm9SB0HBrJEU8L32","id":"2MRNLEYm9SB0HBrJEU8L32","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273133dc7b29a0209a3c12eaa2b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02133dc7b29a0209a3c12eaa2b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851133dc7b29a0209a3c12eaa2b"}],"is_playable":true,"name":"CRASH","release_date":"2024-06-20","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2MRNLEYm9SB0HBrJEU8L32"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0cGUm45nv7Z6M6qdXYQGTX"},"href":"https://api.spotify.com/v1/artists/0cGUm45nv7Z6M6qdXYQGTX","id":"0cGUm45nv7Z6M6qdXYQGTX","name":"Kehlani","type":"artist","uri":"spotify:artist:0cGUm45nv7Z6M6qdXYQGTX"}],"disc_number":1,"duration_ms":202414,"explicit":false,"external_ids":{"isrc":"USAT22401034"},"external_urls":{"spotify":"https://open.spotify.com/track/4ChomJf8z16E6Zw4EoioYY"},"href":"https://api.spotify.com/v1/tracks/4ChomJf8z16E6Zw4EoioYY","id":"4ChomJf8z16E6Zw4EoioYY","is_local":false,"is_playable":true,"name":"After Hours","track_number":3,"type":"track","uri":"spotify:track:4ChomJf8z16E6Zw4EoioYY"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Feel%20Your%20Way%20Alix%20Perez&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":10,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5n47Dui0H3pGpZSOxITmoq"},"href":"https://api.spotify.com/v1/albums/5n47Dui0H3pGpZSOxITmoq","id":"5n47Dui0H3pGpZSOxITmoq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b68df485f3304211904548a8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b68df485f3304211904548a8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b68df485f3304211904548a8"}],"is_playable":true,"name":"Grease (The Original Motion Picture Soundtrack)","release_date":"1978-04-04","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:5n47Dui0H3pGpZSOxITmoq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4hKkEHkaqCsyxNxXEsszVH"},"href":"https://api.spotify.com/v1/artists/4hKkEHkaqCsyxNxXEsszVH","id":"4hKkEHkaqCsyxNxXEsszVH","name":"John Travolta","type":"artist","uri":"spotify:artist:4hKkEHkaqCsyxNxXEsszVH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4BoRxUdrcgbbq1rxJvvhg9"},"href":"https://api.spotify.com/v1/artists/4BoRxUdrcgbbq1rxJvvhg9","id":"4BoRxUdrcgbbq1rxJvvhg9","name":"Olivia Newton-John","type":"artist","uri":"spotify:artist:4BoRxUdrcgbbq1rxJvvhg9"}],"disc_number":1,"duration_ms":169840,"explicit":false,"external_ids":{"isrc":"NLF057890004"},"external_urls":{"spotify":"https://open.spotify.com/track/0B9x2BRHqj3Qer7biM3pU3"},"href":"https://api.spotify.com/v1/tracks/0B9x2BRHqj3Qer7biM3pU3","id":"0B9x2BRHqj3Qer7biM3pU3","is_local":false,"is_playable":true,"name":"You're The One That I Want - From \u201cGrease\u201d","track_number":4,"type":"track","uri":"spotify:track:0B9x2BRHqj3Qer7biM3pU3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ew9JvyyuOGkhahuwdovDq"},"href":"https://api.spotify.com/v1/artists/2ew9JvyyuOGkhahuwdovDq","id":"2ew9JvyyuOGkhahuwdovDq","name":"Secondcity","type":"artist","uri":"spotify:artist:2ew9JvyyuOGkhahuwdovDq"}],"external_urls":{"spotify":"https://open.spotify.com/album/4mcxbqc3YvVJDWsBOawu1u"},"href":"https://api.spotify.com/v1/albums/4mcxbqc3YvVJDWsBOawu1u","id":"4mcxbqc3YvVJDWsBOawu1u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b9e42ee00fe863f73cd3653"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b9e42ee00fe863f73cd3653"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b9e42ee00fe863f73cd3653"}],"is_playable":true,"name":"I Wanna Feel","release_date":"2014-05-25","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:4mcxbqc3YvVJDWsBOawu1u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2ew9JvyyuOGkhahuwdovDq"},"href":"https://api.spotify.com/v1/artists/2ew9JvyyuOGkhahuwdovDq","id":"2ew9JvyyuOGkhahuwdovDq","name":"Secondcity","type":"artist","uri":"spotify:artist:2ew9JvyyuOGkhahuwdovDq"}],"disc_number":1,"duration_ms":185543,"explicit":false,"external_ids":{"isrc":"GBD581400001"},"external_urls":{"spotify":"https://open.spotify.com/track/3PgSGAq2cOat72laH7uKFn"},"href":"https://api.spotify.com/v1/tracks/3PgSGAq2cOat72laH7uKFn","id":"3PgSGAq2cOat72laH7uKFn","is_local":false,"is_playable":true,"name":"I Wanna Feel - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:3PgSGAq2cOat72laH7uKFn"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/748dZDqSZy6aPXKcI9H80u"},"href":"https://api.spotify.com/v1/albums/748dZDqSZy6aPXKcI9H80u","id":"748dZDqSZy6aPXKcI9H80u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27378de8b28de36a74afc0348b5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0278de8b28de36a74afc0348b5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485178de8b28de36a74afc0348b5"}],"is_playable":true,"name":"good kid, m.A.A.d city (Deluxe)","release_date":"2012-10-22","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:748dZDqSZy6aPXKcI9H80u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YZyLoL8N0Wb9xBt1NhZWg"},"href":"https://api.spotify.com/v1/artists/2YZyLoL8N0Wb9xBt1NhZWg","id":"2YZyLoL8N0Wb9xBt1NhZWg","name":"Kendrick Lamar","type":"artist","uri":"spotify:artist:2YZyLoL8N0Wb9xBt1NhZWg"}],"disc_number":1,"duration_ms":310720,"explicit":true,"external_ids":{"isrc":"USUM71210774"},"external_urls":{"spotify":"https://open.spotify.com/track/5h5tBFnbcVioFXiOixTn6E"},"href":"https://api.spotify.com/v1/tracks/5h5tBFnbcVioFXiOixTn6E","id":"5h5tBFnbcVioFXiOixTn6E","is_local":false,"is_playable":true,"name":"Bitch, Don\u2019t Kill My Vibe","track_number":2,"type":"track","uri":"spotify:track:5h5tBFnbcVioFXiOixTn6E"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GzWhE2xadJiW8MqRKIVSK"},"href":"https://api.spotify.com/v1/artists/3GzWhE2xadJiW8MqRKIVSK","id":"3GzWhE2xadJiW8MqRKIVSK","name":"Underoath","type":"artist","uri":"spotify:artist:3GzWhE2xadJiW8MqRKIVSK"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GeXnKDk6sD6RnkPVwFi19"},"href":"https://api.spotify.com/v1/albums/5GeXnKDk6sD6RnkPVwFi19","id":"5GeXnKDk6sD6RnkPVwFi19","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c05f1b9f41f21afa225ce2ae"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c05f1b9f41f21afa225ce2ae"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c05f1b9f41f21afa225ce2ae"}],"is_playable":true,"name":"They're Only Chasing Safety","release_date":"2004-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:5GeXnKDk6sD6RnkPVwFi19"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GzWhE2xadJiW8MqRKIVSK"},"href":"https://api.spotify.com/v1/artists/3GzWhE2xadJiW8MqRKIVSK","id":"3GzWhE2xadJiW8MqRKIVSK","name":"Underoath","type":"artist","uri":"spotify:artist:3GzWhE2xadJiW8MqRKIVSK"}],"disc_number":1,"duration_ms":268000,"explicit":false,"external_ids":{"isrc":"USTN10422712"},"external_urls":{"spotify":"https://open.spotify.com/track/47IWLfIKOKhFnz1FUEUIkE"},"href":"https://api.spotify.com/v1/tracks/47IWLfIKOKhFnz1FUEUIkE","id":"47IWLfIKOKhFnz1FUEUIkE","is_local":false,"is_playable":true,"name":"A Boy Brushed Red Living In Black And White","track_number":2,"type":"track","uri":"spotify:track:47IWLfIKOKhFnz1FUEUIkE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/336vr2M3Va0FjyvB55lJEd"},"href":"https://api.spotify.com/v1/artists/336vr2M3Va0FjyvB55lJEd","id":"336vr2M3Va0FjyvB55lJEd","name":"D'Angelo","type":"artist","uri":"spotify:artist:336vr2M3Va0FjyvB55lJEd"}],"external_urls":{"spotify":"https://open.spotify.com/album/2lO9yuuIDgBpSJzxTh3ai8"},"href":"https://api.spotify.com/v1/albums/2lO9yuuIDgBpSJzxTh3ai8","id":"2lO9yuuIDgBpSJzxTh3ai8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732b3dc336a7a69293c25d9ade"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022b3dc336a7a69293c25d9ade"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512b3dc336a7a69293c25d9ade"}],"is_playable":true,"name":"Voodoo","release_date":"2000-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2lO9yuuIDgBpSJzxTh3ai8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/336vr2M3Va0FjyvB55lJEd"},"href":"https://api.spotify.com/v1/artists/336vr2M3Va0FjyvB55lJEd","id":"336vr2M3Va0FjyvB55lJEd","name":"D'Angelo","type":"artist","uri":"spotify:artist:336vr2M3Va0FjyvB55lJEd"}],"disc_number":1,"duration_ms":430800,"explicit":false,"external_ids":{"isrc":"USVI29900212"},"external_urls":{"spotify":"https://open.spotify.com/track/4oPNN7syJYSjzDhRerF966"},"href":"https://api.spotify.com/v1/tracks/4oPNN7syJYSjzDhRerF966","id":"4oPNN7syJYSjzDhRerF966","is_local":false,"is_playable":true,"name":"Untitled (How Does It Feel)","track_number":12,"type":"track","uri":"spotify:track:4oPNN7syJYSjzDhRerF966"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6jJ0s89eD6GaHleKKya26X"},"href":"https://api.spotify.com/v1/artists/6jJ0s89eD6GaHleKKya26X","id":"6jJ0s89eD6GaHleKKya26X","name":"Katy Perry","type":"artist","uri":"spotify:artist:6jJ0s89eD6GaHleKKya26X"}],"external_urls":{"spotify":"https://open.spotify.com/album/5BvgP623rtvlc0HDcpzquz"},"href":"https://api.spotify.com/v1/albums/5BvgP623rtvlc0HDcpzquz","id":"5BvgP623rtvlc0HDcpzquz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273937af329667311f4b2831616"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02937af329667311f4b2831616"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851937af329667311f4b2831616"}],"is_playable":true,"name":"Teenage Dream: The Complete Confection","release_date":"2012-03-12","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:5BvgP623rtvlc0HDcpzquz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6jJ0s89eD6GaHleKKya26X"},"href":"https://api.spotify.com/v1/artists/6jJ0s89eD6GaHleKKya26X","id":"6jJ0s89eD6GaHleKKya26X","name":"Katy Perry","type":"artist","uri":"spotify:artist:6jJ0s89eD6GaHleKKya26X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"disc_number":1,"duration_ms":229573,"explicit":false,"external_ids":{"isrc":"USCA21100386"},"external_urls":{"spotify":"https://open.spotify.com/track/36ux3YuUsGTWPT8fXclS45"},"href":"https://api.spotify.com/v1/tracks/36ux3YuUsGTWPT8fXclS45","id":"36ux3YuUsGTWPT8fXclS45","is_local":false,"is_playable":true,"name":"E.T.","track_number":17,"type":"track","uri":"spotify:track:36ux3YuUsGTWPT8fXclS45"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ROfBX6lJLnCmaw1NrP5K9"},"href":"https://api.spotify.com/v1/albums/3ROfBX6lJLnCmaw1NrP5K9","id":"3ROfBX6lJLnCmaw1NrP5K9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b4c5982e1b92f97a126fc18c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b4c5982e1b92f97a126fc18c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b4c5982e1b92f97a126fc18c"}],"is_playable":true,"name":"I AM...SASHA FIERCE - Platinum Edition","release_date":"2008","release_date_precision":"year","total_tracks":20,"type":"album","uri":"spotify:album:3ROfBX6lJLnCmaw1NrP5K9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"disc_number":1,"duration_ms":261160,"explicit":false,"external_ids":{"isrc":"USSM10804556"},"external_urls":{"spotify":"https://open.spotify.com/track/2CvOqDpQIMw69cCzWqr5yr"},"href":"https://api.spotify.com/v1/tracks/2CvOqDpQIMw69cCzWqr5yr","id":"2CvOqDpQIMw69cCzWqr5yr","is_local":false,"is_playable":true,"name":"Halo","track_number":4,"type":"track","uri":"spotify:track:2CvOqDpQIMw69cCzWqr5yr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0YFqlnAFjvDH5a6CxineVK"},"href":"https://api.spotify.com/v1/artists/0YFqlnAFjvDH5a6CxineVK","id":"0YFqlnAFjvDH5a6CxineVK","name":"Velvet Trip","type":"artist","uri":"spotify:artist:0YFqlnAFjvDH5a6CxineVK"}],"external_urls":{"spotify":"https://open.spotify.com/album/7zZokVmJqbuBVc0drwjtx1"},"href":"https://api.spotify.com/v1/albums/7zZokVmJqbuBVc0drwjtx1","id":"7zZokVmJqbuBVc0drwjtx1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730edf16e689378c9fa92bf9f6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020edf16e689378c9fa92bf9f6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510edf16e689378c9fa92bf9f6"}],"is_playable":true,"name":"Glimmers Continued","release_date":"2026-01-30","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:7zZokVmJqbuBVc0drwjtx1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0YFqlnAFjvDH5a6CxineVK"},"href":"https://api.spotify.com/v1/artists/0YFqlnAFjvDH5a6CxineVK","id":"0YFqlnAFjvDH5a6CxineVK","name":"Velvet Trip","type":"artist","uri":"spotify:artist:0YFqlnAFjvDH5a6CxineVK"}],"disc_number":1,"duration_ms":207254,"explicit":false,"external_ids":{"isrc":"AUMGB2501615"},"external_urls":{"spotify":"https://open.spotify.com/track/3RcDpZSZrdG2rzucuE6TMV"},"href":"https://api.spotify.com/v1/tracks/3RcDpZSZrdG2rzucuE6TMV","id":"3RcDpZSZrdG2rzucuE6TMV","is_local":false,"is_playable":true,"name":"Fr3o","track_number":9,"type":"track","uri":"spotify:track:3RcDpZSZrdG2rzucuE6TMV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1hzfo8twXdOegF3xireCYs"},"href":"https://api.spotify.com/v1/artists/1hzfo8twXdOegF3xireCYs","id":"1hzfo8twXdOegF3xireCYs","name":"Milky Chance","type":"artist","uri":"spotify:artist:1hzfo8twXdOegF3xireCYs"}],"external_urls":{"spotify":"https://open.spotify.com/album/3anT3sq943fma4yCM5FhvG"},"href":"https://api.spotify.com/v1/albums/3anT3sq943fma4yCM5FhvG","id":"3anT3sq943fma4yCM5FhvG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739e8a543b2c7aa388a088c2ca"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029e8a543b2c7aa388a088c2ca"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519e8a543b2c7aa388a088c2ca"}],"is_playable":true,"name":"Trip Tape II","release_date":"2022-10-05","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3anT3sq943fma4yCM5FhvG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1hzfo8twXdOegF3xireCYs"},"href":"https://api.spotify.com/v1/artists/1hzfo8twXdOegF3xireCYs","id":"1hzfo8twXdOegF3xireCYs","name":"Milky Chance","type":"artist","uri":"spotify:artist:1hzfo8twXdOegF3xireCYs"}],"disc_number":1,"duration_ms":164576,"explicit":false,"external_ids":{"isrc":"DEVP22200014"},"external_urls":{"spotify":"https://open.spotify.com/track/3GXgrEjBjonrQrPEEi13yU"},"href":"https://api.spotify.com/v1/tracks/3GXgrEjBjonrQrPEEi13yU","id":"3GXgrEjBjonrQrPEEi13yU","is_local":false,"is_playable":true,"name":"Synchronize","track_number":1,"type":"track","uri":"spotify:track:3GXgrEjBjonrQrPEEi13yU"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0cGUm45nv7Z6M6qdXYQGTX"},"href":"https://api.spotify.com/v1/artists/0cGUm45nv7Z6M6qdXYQGTX","id":"0cGUm45nv7Z6M6qdXYQGTX","name":"Kehlani","type":"artist","uri":"spotify:artist:0cGUm45nv7Z6M6qdXYQGTX"}],"external_urls":{"spotify":"https://open.spotify.com/album/2MRNLEYm9SB0HBrJEU8L32"},"href":"https://api.spotify.com/v1/albums/2MRNLEYm9SB0HBrJEU8L32","id":"2MRNLEYm9SB0HBrJEU8L32","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273133dc7b29a0209a3c12eaa2b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02133dc7b29a0209a3c12eaa2b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851133dc7b29a0209a3c12eaa2b"}],"is_playable":true,"name":"CRASH","release_date":"2024-06-20","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2MRNLEYm9SB0HBrJEU8L32"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0cGUm45nv7Z6M6qdXYQGTX"},"href":"https://api.spotify.com/v1/artists/0cGUm45nv7Z6M6qdXYQGTX","id":"0cGUm45nv7Z6M6qdXYQGTX","name":"Kehlani","type":"artist","uri":"spotify:artist:0cGUm45nv7Z6M6qdXYQGTX"}],"disc_number":1,"duration_ms":202414,"explicit":false,"external_ids":{"isrc":"USAT22401034"},"external_urls":{"spotify":"https://open.spotify.com/track/4ChomJf8z16E6Zw4EoioYY"},"href":"https://api.spotify.com/v1/tracks/4ChomJf8z16E6Zw4EoioYY","id":"4ChomJf8z16E6Zw4EoioYY","is_local":false,"is_playable":true,"name":"After Hours","track_number":3,"type":"track","uri":"spotify:track:4ChomJf8z16E6Zw4EoioYY"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Feel+Your+Way+Alix+Perez&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Losing%20Myself%20LSB&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Losing%20Myself%20LSB&type=track","offset":0,"previous":null,"total":17,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7FBcuc1gsnv6Y1nwFtNRCb"},"href":"https://api.spotify.com/v1/artists/7FBcuc1gsnv6Y1nwFtNRCb","id":"7FBcuc1gsnv6Y1nwFtNRCb","name":"My Chemical Romance","type":"artist","uri":"spotify:artist:7FBcuc1gsnv6Y1nwFtNRCb"}],"external_urls":{"spotify":"https://open.spotify.com/album/3DuiGV3J09SUhvp8gqNx8h"},"href":"https://api.spotify.com/v1/albums/3DuiGV3J09SUhvp8gqNx8h","id":"3DuiGV3J09SUhvp8gqNx8h","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cab7ae4868e9f9ce6bdfdf43"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cab7ae4868e9f9ce6bdfdf43"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cab7ae4868e9f9ce6bdfdf43"}],"is_playable":true,"name":"Three Cheers for Sweet Revenge","release_date":"2004-06-08","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3DuiGV3J09SUhvp8gqNx8h"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7FBcuc1gsnv6Y1nwFtNRCb"},"href":"https://api.spotify.com/v1/artists/7FBcuc1gsnv6Y1nwFtNRCb","id":"7FBcuc1gsnv6Y1nwFtNRCb","name":"My Chemical Romance","type":"artist","uri":"spotify:artist:7FBcuc1gsnv6Y1nwFtNRCb"}],"disc_number":1,"duration_ms":173733,"explicit":true,"external_ids":{"isrc":"USRE10400659"},"external_urls":{"spotify":"https://open.spotify.com/track/5bTuwAgYUD5MABOIPH8ZMt"},"href":"https://api.spotify.com/v1/tracks/5bTuwAgYUD5MABOIPH8ZMt","id":"5bTuwAgYUD5MABOIPH8ZMt","is_local":false,"is_playable":true,"name":"You Know What They Do to Guys Like Us in Prison","track_number":4,"type":"track","uri":"spotify:track:5bTuwAgYUD5MABOIPH8ZMt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6aaMZ3fcfLv4tEbmY7bjRM"},"href":"https://api.spotify.com/v1/artists/6aaMZ3fcfLv4tEbmY7bjRM","id":"6aaMZ3fcfLv4tEbmY7bjRM","name":"Isaiah Rashad","type":"artist","uri":"spotify:artist:6aaMZ3fcfLv4tEbmY7bjRM"}],"external_urls":{"spotify":"https://open.spotify.com/album/6TQ8nqw43uUOWu7Yqp58ko"},"href":"https://api.spotify.com/v1/albums/6TQ8nqw43uUOWu7Yqp58ko","id":"6TQ8nqw43uUOWu7Yqp58ko","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273457132b244e5459aea1b7160"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02457132b244e5459aea1b7160"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851457132b244e5459aea1b7160"}],"is_playable":true,"name":"The House Is Burning","release_date":"2021-07-30","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:6TQ8nqw43uUOWu7Yqp58ko"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6aaMZ3fcfLv4tEbmY7bjRM"},"href":"https://api.spotify.com/v1/artists/6aaMZ3fcfLv4tEbmY7bjRM","id":"6aaMZ3fcfLv4tEbmY7bjRM","name":"Isaiah Rashad","type":"artist","uri":"spotify:artist:6aaMZ3fcfLv4tEbmY7bjRM"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1ybINI1qPiFbwDXamRtwxD"},"href":"https://api.spotify.com/v1/artists/1ybINI1qPiFbwDXamRtwxD","id":"1ybINI1qPiFbwDXamRtwxD","name":"Smino","type":"artist","uri":"spotify:artist:1ybINI1qPiFbwDXamRtwxD"}],"disc_number":1,"duration_ms":186152,"explicit":true,"external_ids":{"isrc":"USWB12102064"},"external_urls":{"spotify":"https://open.spotify.com/track/051zam2WDIKOLdu4XYpCaA"},"href":"https://api.spotify.com/v1/tracks/051zam2WDIKOLdu4XYpCaA","id":"051zam2WDIKOLdu4XYpCaA","is_local":false,"is_playable":true,"name":"Claymore (feat. Smino)","track_number":5,"type":"track","uri":"spotify:track:051zam2WDIKOLdu4XYpCaA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ad91Jof8Niiw0lGLLi3NW"},"href":"https://api.spotify.com/v1/artists/6Ad91Jof8Niiw0lGLLi3NW","id":"6Ad91Jof8Niiw0lGLLi3NW","name":"YUNGBLUD","type":"artist","uri":"spotify:artist:6Ad91Jof8Niiw0lGLLi3NW"}],"external_urls":{"spotify":"https://open.spotify.com/album/1KsMhtT6PWdFuMCiNLvWmP"},"href":"https://api.spotify.com/v1/albums/1KsMhtT6PWdFuMCiNLvWmP","id":"1KsMhtT6PWdFuMCiNLvWmP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b5dd9044681a2e8e0d072e27"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b5dd9044681a2e8e0d072e27"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b5dd9044681a2e8e0d072e27"}],"is_playable":true,"name":"weird!","release_date":"2020-12-04","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1KsMhtT6PWdFuMCiNLvWmP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Ad91Jof8Niiw0lGLLi3NW"},"href":"https://api.spotify.com/v1/artists/6Ad91Jof8Niiw0lGLLi3NW","id":"6Ad91Jof8Niiw0lGLLi3NW","name":"YUNGBLUD","type":"artist","uri":"spotify:artist:6Ad91Jof8Niiw0lGLLi3NW"}],"disc_number":1,"duration_ms":167365,"explicit":false,"external_ids":{"isrc":"USUG12003336"},"external_urls":{"spotify":"https://open.spotify.com/track/5lVZiDONIcGowIOetTZ4ps"},"href":"https://api.spotify.com/v1/tracks/5lVZiDONIcGowIOetTZ4ps","id":"5lVZiDONIcGowIOetTZ4ps","is_local":false,"is_playable":true,"name":"cotton candy","track_number":3,"type":"track","uri":"spotify:track:5lVZiDONIcGowIOetTZ4ps"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ieMZZbCTZ3mQi489W5pXo"},"href":"https://api.spotify.com/v1/albums/5ieMZZbCTZ3mQi489W5pXo","id":"5ieMZZbCTZ3mQi489W5pXo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734f887df05e75d13daf914dd7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024f887df05e75d13daf914dd7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514f887df05e75d13daf914dd7"}],"is_playable":true,"name":"Shoganai","release_date":"2024-10-24","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:5ieMZZbCTZ3mQi489W5pXo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"disc_number":1,"duration_ms":219933,"explicit":false,"external_ids":{"isrc":"QM7282344450"},"external_urls":{"spotify":"https://open.spotify.com/track/153MUZnFRQF5sNbfu4xRsB"},"href":"https://api.spotify.com/v1/tracks/153MUZnFRQF5sNbfu4xRsB","id":"153MUZnFRQF5sNbfu4xRsB","is_local":false,"is_playable":true,"name":"Darkbeat","track_number":2,"type":"track","uri":"spotify:track:153MUZnFRQF5sNbfu4xRsB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3bO19AOone0ubCsfDXDtYt"},"href":"https://api.spotify.com/v1/artists/3bO19AOone0ubCsfDXDtYt","id":"3bO19AOone0ubCsfDXDtYt","name":"Myles Smith","type":"artist","uri":"spotify:artist:3bO19AOone0ubCsfDXDtYt"}],"external_urls":{"spotify":"https://open.spotify.com/album/08u2urMBBJIz9kMwAl08yI"},"href":"https://api.spotify.com/v1/albums/08u2urMBBJIz9kMwAl08yI","id":"08u2urMBBJIz9kMwAl08yI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739f308abc74180f2e0e66508a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029f308abc74180f2e0e66508a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519f308abc74180f2e0e66508a"}],"is_playable":true,"name":"My Mess, My Heart, My Life.","release_date":"2026-06-19","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:08u2urMBBJIz9kMwAl08yI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3bO19AOone0ubCsfDXDtYt"},"href":"https://api.spotify.com/v1/artists/3bO19AOone0ubCsfDXDtYt","id":"3bO19AOone0ubCsfDXDtYt","name":"Myles Smith","type":"artist","uri":"spotify:artist:3bO19AOone0ubCsfDXDtYt"}],"disc_number":1,"duration_ms":197400,"explicit":false,"external_ids":{"isrc":"GBARL2600380"},"external_urls":{"spotify":"https://open.spotify.com/track/4MIUsWHETbAqzbnTaBaOEb"},"href":"https://api.spotify.com/v1/tracks/4MIUsWHETbAqzbnTaBaOEb","id":"4MIUsWHETbAqzbnTaBaOEb","is_local":false,"is_playable":true,"name":"Hold Me In The Dark","track_number":2,"type":"track","uri":"spotify:track:4MIUsWHETbAqzbnTaBaOEb"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6MwPCCR936cYfM1dLsGVnl"},"href":"https://api.spotify.com/v1/artists/6MwPCCR936cYfM1dLsGVnl","id":"6MwPCCR936cYfM1dLsGVnl","name":"Motionless In White","type":"artist","uri":"spotify:artist:6MwPCCR936cYfM1dLsGVnl"}],"external_urls":{"spotify":"https://open.spotify.com/album/4JECM4NZhtpjDX4JbYkh00"},"href":"https://api.spotify.com/v1/albums/4JECM4NZhtpjDX4JbYkh00","id":"4JECM4NZhtpjDX4JbYkh00","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273944e11093f0e01c60be5be8f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02944e11093f0e01c60be5be8f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851944e11093f0e01c60be5be8f"}],"is_playable":true,"name":"Disguise","release_date":"2019-06-07","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4JECM4NZhtpjDX4JbYkh00"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6MwPCCR936cYfM1dLsGVnl"},"href":"https://api.spotify.com/v1/artists/6MwPCCR936cYfM1dLsGVnl","id":"6MwPCCR936cYfM1dLsGVnl","name":"Motionless In White","type":"artist","uri":"spotify:artist:6MwPCCR936cYfM1dLsGVnl"}],"disc_number":1,"duration_ms":237500,"explicit":true,"external_ids":{"isrc":"NLA321900078"},"external_urls":{"spotify":"https://open.spotify.com/track/6LNKeK9iJ66iwe16VxG43H"},"href":"https://api.spotify.com/v1/tracks/6LNKeK9iJ66iwe16VxG43H","id":"6LNKeK9iJ66iwe16VxG43H","is_local":false,"is_playable":true,"name":"Disguise","track_number":1,"type":"track","uri":"spotify:track:6LNKeK9iJ66iwe16VxG43H"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"external_urls":{"spotify":"https://open.spotify.com/album/10EdY3DvrTd5ncIqc5cqY3"},"href":"https://api.spotify.com/v1/albums/10EdY3DvrTd5ncIqc5cqY3","id":"10EdY3DvrTd5ncIqc5cqY3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad669e01d1c670e09d78213e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad669e01d1c670e09d78213e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad669e01d1c670e09d78213e"}],"is_playable":true,"name":"Darkbeat","release_date":"2023-07-06","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:10EdY3DvrTd5ncIqc5cqY3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"disc_number":1,"duration_ms":219933,"explicit":false,"external_ids":{"isrc":"QM7282344450"},"external_urls":{"spotify":"https://open.spotify.com/track/12U3kqXlH7PHopbqgCxz5P"},"href":"https://api.spotify.com/v1/tracks/12U3kqXlH7PHopbqgCxz5P","id":"12U3kqXlH7PHopbqgCxz5P","is_local":false,"is_playable":true,"name":"Darkbeat","track_number":1,"type":"track","uri":"spotify:track:12U3kqXlH7PHopbqgCxz5P"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"external_urls":{"spotify":"https://open.spotify.com/album/7jMF8X89jLZMftQhj4scJV"},"href":"https://api.spotify.com/v1/albums/7jMF8X89jLZMftQhj4scJV","id":"7jMF8X89jLZMftQhj4scJV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27351531e11e1a318729e033f5c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0251531e11e1a318729e033f5c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485151531e11e1a318729e033f5c"}],"is_playable":true,"name":"PRISONER + DARKBEAT (REDUX)","release_date":"2025-03-14","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:7jMF8X89jLZMftQhj4scJV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"disc_number":1,"duration_ms":219933,"explicit":false,"external_ids":{"isrc":"QM7282344450"},"external_urls":{"spotify":"https://open.spotify.com/track/6dUJP62raX7sCxWD0Kf3u0"},"href":"https://api.spotify.com/v1/tracks/6dUJP62raX7sCxWD0Kf3u0","id":"6dUJP62raX7sCxWD0Kf3u0","is_local":false,"is_playable":true,"name":"Darkbeat","track_number":4,"type":"track","uri":"spotify:track:6dUJP62raX7sCxWD0Kf3u0"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ZXVMlISjfSMCaBxuRWb5c"},"href":"https://api.spotify.com/v1/albums/3ZXVMlISjfSMCaBxuRWb5c","id":"3ZXVMlISjfSMCaBxuRWb5c","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735308c784b8b8ddfa9e63532c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025308c784b8b8ddfa9e63532c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515308c784b8b8ddfa9e63532c"}],"is_playable":true,"name":"Embers","release_date":"2024-06-07","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:3ZXVMlISjfSMCaBxuRWb5c"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"disc_number":1,"duration_ms":219933,"explicit":false,"external_ids":{"isrc":"QM7282344450"},"external_urls":{"spotify":"https://open.spotify.com/track/2XS0txBdim5dIlAAejGlMo"},"href":"https://api.spotify.com/v1/tracks/2XS0txBdim5dIlAAejGlMo","id":"2XS0txBdim5dIlAAejGlMo","is_local":false,"is_playable":true,"name":"Darkbeat","track_number":3,"type":"track","uri":"spotify:track:2XS0txBdim5dIlAAejGlMo"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"external_urls":{"spotify":"https://open.spotify.com/album/7qExbX4iZc4EsEB3dqkZHn"},"href":"https://api.spotify.com/v1/albums/7qExbX4iZc4EsEB3dqkZHn","id":"7qExbX4iZc4EsEB3dqkZHn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e5829738cc032a36ae2c6eac"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e5829738cc032a36ae2c6eac"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e5829738cc032a36ae2c6eac"}],"is_playable":true,"name":"Venom","release_date":"2024-03-01","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:7qExbX4iZc4EsEB3dqkZHn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6wADzvUWqgYWXigndo6Mmj"},"href":"https://api.spotify.com/v1/artists/6wADzvUWqgYWXigndo6Mmj","id":"6wADzvUWqgYWXigndo6Mmj","name":"Ankor","type":"artist","uri":"spotify:artist:6wADzvUWqgYWXigndo6Mmj"}],"disc_number":1,"duration_ms":219933,"explicit":false,"external_ids":{"isrc":"QM7282344450"},"external_urls":{"spotify":"https://open.spotify.com/track/4JvuiMYF6BwxsEg9Mb8v5w"},"href":"https://api.spotify.com/v1/tracks/4JvuiMYF6BwxsEg9Mb8v5w","id":"4JvuiMYF6BwxsEg9Mb8v5w","is_local":false,"is_playable":true,"name":"Darkbeat","track_number":2,"type":"track","uri":"spotify:track:4JvuiMYF6BwxsEg9Mb8v5w"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1Mb3NpbmclMjBNeXNlbGYlMjBMU0ImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MTAmbGltaXQ9MTAmcXVlcnk9TG9zaW5nJTIwTXlzZWxmJTIwTFNCJnR5cGU9dHJhY2siLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MTcsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdGQmN1YzFnc252NlkxbndGdE5SQ2IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0ZCY3VjMWdzbnY2WTFud0Z0TlJDYiIsImlkIjoiN0ZCY3VjMWdzbnY2WTFud0Z0TlJDYiIsIm5hbWUiOiJNeSBDaGVtaWNhbCBSb21hbmNlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdGQmN1YzFnc252NlkxbndGdE5SQ2IifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zRHVpR1YzSjA5U1VodnA4Z3FOeDhoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0R1aUdWM0owOVNVaHZwOGdxTng4aCIsImlkIjoiM0R1aUdWM0owOVNVaHZwOGdxTng4", + "aCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjYWI3YWU0ODY4ZTlmOWNlNmJkZmRmNDMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyY2FiN2FlNDg2OGU5ZjljZTZiZGZkZjQzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjYWI3YWU0ODY4ZTlmOWNlNmJkZmRmNDMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhyZWUgQ2hlZXJzIGZvciBTd2VldCBSZXZlbmdlIiwicmVsZWFzZV9kYXRlIjoiMjAwNC0wNi0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNEdWlHVjNKMDlTVWh2cDhncU54OGgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83RkJjdWMxZ3NudjZZMW53RnROUkNiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdGQmN1YzFnc252NlkxbndGdE5SQ2IiLCJpZCI6IjdGQmN1YzFnc252NlkxbndGdE5SQ2IiLCJuYW1lIjoiTXkgQ2hlbWljYWwgUm9tYW5jZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3RkJjdWMxZ3NudjZZMW53RnROUkNiIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3MzczMywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSRTEwNDAwNjU5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81YlR1d0FnWVVENU1BQk9JUEg4Wk10In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNWJUdXdBZ1lVRDVNQUJPSVBIOFpNdCIsImlkIjoiNWJUdXdBZ1lVRDVNQUJPSVBIOFpNdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJZb3UgS25vdyBXaGF0IFRoZXkgRG8gdG8gR3V5cyBMaWtlIFVzIGluIFByaXNvbiIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1YlR1d0FnWVVENU1BQk9JUEg4Wk10In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZhYU1aM2ZjZkx2NHRFYm1ZN2JqUk0ifSwiaHJlZiI6Imh0dA==", + "cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82YWFNWjNmY2ZMdjR0RWJtWTdialJNIiwiaWQiOiI2YWFNWjNmY2ZMdjR0RWJtWTdialJNIiwibmFtZSI6IklzYWlhaCBSYXNoYWQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NmFhTVozZmNmTHY0dEVibVk3YmpSTSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZUUThucXc0M3VVT1d1N1lxcDU4a28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82VFE4bnF3NDN1VU9XdTdZcXA1OGtvIiwiaWQiOiI2VFE4bnF3NDN1VU9XdTdZcXA1OGtvIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQ1NzEzMmIyNDRlNTQ1OWFlYTFiNzE2MCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0NTcxMzJiMjQ0ZTU0NTlhZWExYjcxNjAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQ1NzEzMmIyNDRlNTQ1OWFlYTFiNzE2MCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgSG91c2UgSXMgQnVybmluZyIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDctMzAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2VFE4bnF3NDN1VU9XdTdZcXA1OGtvIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmFhTVozZmNmTHY0dEVibVk3YmpSTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82YWFNWjNmY2ZMdjR0RWJtWTdialJNIiwiaWQiOiI2YWFNWjNmY2ZMdjR0RWJtWTdialJNIiwibmFtZSI6IklzYWlhaCBSYXNoYWQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NmFhTVozZmNmTHY0dEVibVk3YmpSTSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xeWJJTkkxcVBpRmJ3RFhhbVJ0d3hEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF5YklOSTFxUGlGYndEWGFtUnR3eEQiLCJpZCI6IjF5YklOSTFxUGlGYndEWGFtUnR3eEQiLCJuYW1lIjoiU21pbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXliSU5JMXFQaUZidw==", + "RFhhbVJ0d3hEIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4NjE1MiwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNXQjEyMTAyMDY0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wNTF6YW0yV0RJS09MZHU0WFlwQ2FBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDUxemFtMldESUtPTGR1NFhZcENhQSIsImlkIjoiMDUxemFtMldESUtPTGR1NFhZcENhQSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDbGF5bW9yZSAoZmVhdC4gU21pbm8pIiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjA1MXphbTJXRElLT0xkdTRYWXBDYUEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkFkOTFKb2Y4TmlpdzBsR0xMaTNOVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82QWQ5MUpvZjhOaWl3MGxHTExpM05XIiwiaWQiOiI2QWQ5MUpvZjhOaWl3MGxHTExpM05XIiwibmFtZSI6IllVTkdCTFVEIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZBZDkxSm9mOE5paXcwbEdMTGkzTlcifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xS3NNaHRUNlBXZEZ1TUNpTkx2V21QIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUtzTWh0VDZQV2RGdU1DaU5MdldtUCIsImlkIjoiMUtzTWh0VDZQV2RGdU1DaU5MdldtUCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiNWRkOTA0NDY4MWEyZThlMGQwNzJlMjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjVkZDkwNDQ2ODFhMmU4ZTBkMDcyZTI3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiNWRkOTA0NDY4MWEyZThlMGQwNzJlMjcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoid2VpcmQhIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0xMi0wNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFLcw==", + "TWh0VDZQV2RGdU1DaU5MdldtUCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZBZDkxSm9mOE5paXcwbEdMTGkzTlcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkFkOTFKb2Y4TmlpdzBsR0xMaTNOVyIsImlkIjoiNkFkOTFKb2Y4TmlpdzBsR0xMaTNOVyIsIm5hbWUiOiJZVU5HQkxVRCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2QWQ5MUpvZjhOaWl3MGxHTExpM05XIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2NzM2NSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVUcxMjAwMzMzNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWxWWmlET05JY0dvd0lPZXRUWjRwcyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVsVlppRE9OSWNHb3dJT2V0VFo0cHMiLCJpZCI6IjVsVlppRE9OSWNHb3dJT2V0VFo0cHMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiY290dG9uIGNhbmR5IiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVsVlppRE9OSWNHb3dJT2V0VFo0cHMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNndBRHp2VVdxZ1lXWGlnbmRvNk1taiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82d0FEenZVV3FnWVdYaWduZG82TW1qIiwiaWQiOiI2d0FEenZVV3FnWVdYaWduZG82TW1qIiwibmFtZSI6IkFua29yIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81aWVNWlpiQ1RaM21RaTQ4OVc1cFhvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWllTVpaYkNUWjNtUWk0ODlXNXBYbyIsImlkIjoiNWllTVpaYkNUWjNtUWk0ODlXNXBYbyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0Zjg4N2RmMDVlNzVkMTNkYWY5MTRkZDcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNGY4OA==", + "N2RmMDVlNzVkMTNkYWY5MTRkZDcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRmODg3ZGYwNWU3NWQxM2RhZjkxNGRkNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTaG9nYW5haSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMTAtMjQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVpZU1aWmJDVFozbVFpNDg5VzVwWG8ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82d0FEenZVV3FnWVdYaWduZG82TW1qIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJpZCI6IjZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJuYW1lIjoiQW5rb3IiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NndBRHp2VVdxZ1lXWGlnbmRvNk1taiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTk5MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRTTcyODIzNDQ0NTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzE1M01VWm5GUlFGNXNOYmZ1NHhSc0IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xNTNNVVpuRlJRRjVzTmJmdTR4UnNCIiwiaWQiOiIxNTNNVVpuRlJRRjVzTmJmdTR4UnNCIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRhcmtiZWF0IiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjE1M01VWm5GUlFGNXNOYmZ1NHhSc0IifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2JPMTlBT29uZTB1YkNzZkRYRHRZdCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zYk8xOUFPb25lMHViQ3NmRFhEdFl0IiwiaWQiOiIzYk8xOUFPb25lMHViQ3NmRFhEdFl0IiwibmFtZSI6Ik15bGVzIFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNiTzE5QU9vbmUwdWJDc2ZEWER0WXQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wOHUydXJNQkJKSXo5a013QWwwOHlJIn0sImhyZWYiOiJodA==", + "dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wOHUydXJNQkJKSXo5a013QWwwOHlJIiwiaWQiOiIwOHUydXJNQkJKSXo5a013QWwwOHlJIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzlmMzA4YWJjNzQxODBmMmUwZTY2NTA4YSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5ZjMwOGFiYzc0MTgwZjJlMGU2NjUwOGEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTlmMzA4YWJjNzQxODBmMmUwZTY2NTA4YSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNeSBNZXNzLCBNeSBIZWFydCwgTXkgTGlmZS4iLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA2LTE5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MDh1MnVyTUJCSkl6OWtNd0FsMDh5SSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNiTzE5QU9vbmUwdWJDc2ZEWER0WXQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2JPMTlBT29uZTB1YkNzZkRYRHRZdCIsImlkIjoiM2JPMTlBT29uZTB1YkNzZkRYRHRZdCIsIm5hbWUiOiJNeWxlcyBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozYk8xOUFPb25lMHViQ3NmRFhEdFl0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NzQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQVJMMjYwMDM4MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNE1JVXNXSEVUYkFxemJuVGFCYU9FYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRNSVVzV0hFVGJBcXpiblRhQmFPRWIiLCJpZCI6IjRNSVVzV0hFVGJBcXpiblRhQmFPRWIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9sZCBNZSBJbiBUaGUgRGFyayIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0TUlVc1dIRVRiQXF6Ym5UYUJhT0ViIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jbw==", + "bS9hcnRpc3QvNk13UENDUjkzNmNZZk0xZExzR1ZubCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82TXdQQ0NSOTM2Y1lmTTFkTHNHVm5sIiwiaWQiOiI2TXdQQ0NSOTM2Y1lmTTFkTHNHVm5sIiwibmFtZSI6Ik1vdGlvbmxlc3MgSW4gV2hpdGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nk13UENDUjkzNmNZZk0xZExzR1ZubCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRKRUNNNE5aaHRwakRYNEpiWWtoMDAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80SkVDTTROWmh0cGpEWDRKYllraDAwIiwiaWQiOiI0SkVDTTROWmh0cGpEWDRKYllraDAwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzk0NGUxMTA5M2YwZTAxYzYwYmU1YmU4ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5NDRlMTEwOTNmMGUwMWM2MGJlNWJlOGYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTk0NGUxMTA5M2YwZTAxYzYwYmU1YmU4ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaXNndWlzZSIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDYtMDciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0SkVDTTROWmh0cGpEWDRKYllraDAwIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNk13UENDUjkzNmNZZk0xZExzR1ZubCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82TXdQQ0NSOTM2Y1lmTTFkTHNHVm5sIiwiaWQiOiI2TXdQQ0NSOTM2Y1lmTTFkTHNHVm5sIiwibmFtZSI6Ik1vdGlvbmxlc3MgSW4gV2hpdGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nk13UENDUjkzNmNZZk0xZExzR1ZubCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzc1MDAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MQTMyMTkwMDA3OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNkxOS2VLOWlKNjZpd2UxNlZ4RzQzSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeQ==", + "LmNvbS92MS90cmFja3MvNkxOS2VLOWlKNjZpd2UxNlZ4RzQzSCIsImlkIjoiNkxOS2VLOWlKNjZpd2UxNlZ4RzQzSCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaXNndWlzZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2TE5LZUs5aUo2Nml3ZTE2VnhHNDNIIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82d0FEenZVV3FnWVdYaWduZG82TW1qIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJpZCI6IjZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJuYW1lIjoiQW5rb3IiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NndBRHp2VVdxZ1lXWGlnbmRvNk1taiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzEwRWRZM0R2clRkNW5jSXFjNWNxWTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xMEVkWTNEdnJUZDVuY0lxYzVjcVkzIiwiaWQiOiIxMEVkWTNEdnJUZDVuY0lxYzVjcVkzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FkNjY5ZTAxZDFjNjcwZTA5ZDc4MjEzZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhZDY2OWUwMWQxYzY3MGUwOWQ3ODIxM2UifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFkNjY5ZTAxZDFjNjcwZTA5ZDc4MjEzZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEYXJrYmVhdCIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDctMDYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjEwRWRZM0R2clRkNW5jSXFjNWNxWTMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82d0FEenZVV3FnWVdYaWduZG82TW1qIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJpZCI6IjZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJuYW1lIjoiQW5rb3IiLA==", + "InR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2d0FEenZVV3FnWVdYaWduZG82TW1qIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxOTkzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFNNzI4MjM0NDQ1MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMTJVM2txWGxIN1BIb3BicWdDeHo1UCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzEyVTNrcVhsSDdQSG9wYnFnQ3h6NVAiLCJpZCI6IjEyVTNrcVhsSDdQSG9wYnFnQ3h6NVAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGFya2JlYXQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MTJVM2txWGxIN1BIb3BicWdDeHo1UCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNndBRHp2VVdxZ1lXWGlnbmRvNk1taiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82d0FEenZVV3FnWVdYaWduZG82TW1qIiwiaWQiOiI2d0FEenZVV3FnWVdYaWduZG82TW1qIiwibmFtZSI6IkFua29yIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83ak1GOFg4OWpMWk1mdFFoajRzY0pWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN2pNRjhYODlqTFpNZnRRaGo0c2NKViIsImlkIjoiN2pNRjhYODlqTFpNZnRRaGo0c2NKViIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1MTUzMWUxMWUxYTMxODcyOWUwMzNmNWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTE1MzFlMTFlMWEzMTg3MjllMDMzZjVjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1MTUzMWUxMWUxYTMxODcyOWUwMzNmNWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUFJJU09ORVIgKyBEQVJLQkVBVCAoUkVEVVgpIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMy0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLA==", + "InRvdGFsX3RyYWNrcyI6NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3ak1GOFg4OWpMWk1mdFFoajRzY0pWIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNndBRHp2VVdxZ1lXWGlnbmRvNk1taiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82d0FEenZVV3FnWVdYaWduZG82TW1qIiwiaWQiOiI2d0FEenZVV3FnWVdYaWduZG82TW1qIiwibmFtZSI6IkFua29yIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE5OTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU03MjgyMzQ0NDUwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82ZFVKUDYycmFYN3NDeFdEMEtmM3UwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmRVSlA2MnJhWDdzQ3hXRDBLZjN1MCIsImlkIjoiNmRVSlA2MnJhWDdzQ3hXRDBLZjN1MCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEYXJrYmVhdCIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2ZFVKUDYycmFYN3NDeFdEMEtmM3UwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82d0FEenZVV3FnWVdYaWduZG82TW1qIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJpZCI6IjZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJuYW1lIjoiQW5rb3IiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NndBRHp2VVdxZ1lXWGlnbmRvNk1taiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNaWFZNbElTamZTTUNhQnh1UldiNWMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zWlhWTWxJU2pmU01DYUJ4dVJXYjVjIiwiaWQiOiIzWlhWTWxJU2pmU01DYUJ4dVJXYjVjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzUzMDhjNzg0YjhiOGRkZmE5ZTYzNTMyYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsIg==", + "dXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUzMDhjNzg0YjhiOGRkZmE5ZTYzNTMyYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTMwOGM3ODRiOGI4ZGRmYTllNjM1MzJjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVtYmVycyIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDYtMDciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNaWFZNbElTamZTTUNhQnh1UldiNWMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82d0FEenZVV3FnWVdYaWduZG82TW1qIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJpZCI6IjZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoiLCJuYW1lIjoiQW5rb3IiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NndBRHp2VVdxZ1lXWGlnbmRvNk1taiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTk5MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRTTcyODIzNDQ0NTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJYUzB0eEJkaW01ZElsQUFlakdsTW8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yWFMwdHhCZGltNWRJbEFBZWpHbE1vIiwiaWQiOiIyWFMwdHhCZGltNWRJbEFBZWpHbE1vIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRhcmtiZWF0IiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJYUzB0eEJkaW01ZElsQUFlakdsTW8ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNndBRHp2VVdxZ1lXWGlnbmRvNk1taiIsImlkIjoiNndBRHp2VVdxZ1lXWGlnbmRvNk1taiIsIm5hbWUiOiJBbmtvciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2d0FEenZVV3FnWVdYaWduZG82TW1qIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jbw==", + "bS9hbGJ1bS83cUV4Ylg0aVpjNEVzRUIzZHFrWkhuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3FFeGJYNGlaYzRFc0VCM2Rxa1pIbiIsImlkIjoiN3FFeGJYNGlaYzRFc0VCM2Rxa1pIbiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlNTgyOTczOGNjMDMyYTM2YWUyYzZlYWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTU4Mjk3MzhjYzAzMmEzNmFlMmM2ZWFjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlNTgyOTczOGNjMDMyYTM2YWUyYzZlYWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVmVub20iLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTAzLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3cUV4Ylg0aVpjNEVzRUIzZHFrWkhuIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNndBRHp2VVdxZ1lXWGlnbmRvNk1taiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82d0FEenZVV3FnWVdYaWduZG82TW1qIiwiaWQiOiI2d0FEenZVV3FnWVdYaWduZG82TW1qIiwibmFtZSI6IkFua29yIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ3QUR6dlVXcWdZV1hpZ25kbzZNbWoifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE5OTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU03MjgyMzQ0NDUwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80SnZ1aU1ZRjZCd3hzRWc5TWI4djV3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNEp2dWlNWUY2Qnd4c0VnOU1iOHY1dyIsImlkIjoiNEp2dWlNWUY2Qnd4c0VnOU1iOHY1dyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEYXJrYmVhdCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0SnZ1aU1ZRjZCd3hzRWc5TWI4djV3In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Losing+Myself+LSB&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNpbHZlciUyMiUyMGFydGlzdCUzQSUyMk1pbmQlMjB2cyUyME1hY2hpbmUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNpbHZlciUyMiUyMGFydGlzdCUzQSUyMk1pbmQlMjB2cyUyME1hY2hpbmUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Silver%22+artist%3A%22Mind+vs+Machine%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Breathe%22%20artist%3A%22S.P.Y%22&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=track%3A%22Breathe%22%20artist%3A%22S.P.Y%22&type=track","offset":0,"previous":null,"total":36,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3YR01kdOztg2p9nvD6MRg7"},"href":"https://api.spotify.com/v1/artists/3YR01kdOztg2p9nvD6MRg7","id":"3YR01kdOztg2p9nvD6MRg7","name":"Polly Scattergood","type":"artist","uri":"spotify:artist:3YR01kdOztg2p9nvD6MRg7"}],"external_urls":{"spotify":"https://open.spotify.com/album/6zUTRooG1eaBkjG83bmoCY"},"href":"https://api.spotify.com/v1/albums/6zUTRooG1eaBkjG83bmoCY","id":"6zUTRooG1eaBkjG83bmoCY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bafec11f4046ff55d7a3bd3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bafec11f4046ff55d7a3bd3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bafec11f4046ff55d7a3bd3c"}],"is_playable":true,"name":"Polly Scattergood","release_date":"2009-03-09","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:6zUTRooG1eaBkjG83bmoCY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3YR01kdOztg2p9nvD6MRg7"},"href":"https://api.spotify.com/v1/artists/3YR01kdOztg2p9nvD6MRg7","id":"3YR01kdOztg2p9nvD6MRg7","name":"Polly Scattergood","type":"artist","uri":"spotify:artist:3YR01kdOztg2p9nvD6MRg7"}],"disc_number":1,"duration_ms":274720,"explicit":false,"external_ids":{"isrc":"GBAJH0900094"},"external_urls":{"spotify":"https://open.spotify.com/track/3QX8PkHZ9lGuZ4lraqPCYC"},"href":"https://api.spotify.com/v1/tracks/3QX8PkHZ9lGuZ4lraqPCYC","id":"3QX8PkHZ9lGuZ4lraqPCYC","is_local":false,"is_playable":true,"name":"Breathe in Breathe Out","track_number":10,"type":"track","uri":"spotify:track:3QX8PkHZ9lGuZ4lraqPCYC"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/26dSoYclwsYLMAKD3tpOr4"},"href":"https://api.spotify.com/v1/artists/26dSoYclwsYLMAKD3tpOr4","id":"26dSoYclwsYLMAKD3tpOr4","name":"Britney Spears","type":"artist","uri":"spotify:artist:26dSoYclwsYLMAKD3tpOr4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4wdZcqDssUkQNQzNZD2FPN"},"href":"https://api.spotify.com/v1/albums/4wdZcqDssUkQNQzNZD2FPN","id":"4wdZcqDssUkQNQzNZD2FPN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731b804d44c444225e8cccb806"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021b804d44c444225e8cccb806"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511b804d44c444225e8cccb806"}],"is_playable":true,"name":"Britney Spears Remix Sampler","release_date":"2005-12-31","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:4wdZcqDssUkQNQzNZD2FPN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/26dSoYclwsYLMAKD3tpOr4"},"href":"https://api.spotify.com/v1/artists/26dSoYclwsYLMAKD3tpOr4","id":"26dSoYclwsYLMAKD3tpOr4","name":"Britney Spears","type":"artist","uri":"spotify:artist:26dSoYclwsYLMAKD3tpOr4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/44PA0rCQXikgOWbfY7Fq7m"},"href":"https://api.spotify.com/v1/artists/44PA0rCQXikgOWbfY7Fq7m","id":"44PA0rCQXikgOWbfY7Fq7m","name":"Ying Yang Twins","type":"artist","uri":"spotify:artist:44PA0rCQXikgOWbfY7Fq7m"}],"disc_number":1,"duration_ms":240053,"explicit":false,"external_ids":{"isrc":"USJI10500610"},"external_urls":{"spotify":"https://open.spotify.com/track/5gV0LFXwEIffnWwupwiYse"},"href":"https://api.spotify.com/v1/tracks/5gV0LFXwEIffnWwupwiYse","id":"5gV0LFXwEIffnWwupwiYse","is_local":false,"is_playable":true,"name":"Breathe On Me (feat. Ying Yang Twins) - Jaques LuCont's Thin White Duke Mix","track_number":5,"type":"track","uri":"spotify:track:5gV0LFXwEIffnWwupwiYse"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/26dSoYclwsYLMAKD3tpOr4"},"href":"https://api.spotify.com/v1/artists/26dSoYclwsYLMAKD3tpOr4","id":"26dSoYclwsYLMAKD3tpOr4","name":"Britney Spears","type":"artist","uri":"spotify:artist:26dSoYclwsYLMAKD3tpOr4"}],"external_urls":{"spotify":"https://open.spotify.com/album/5uCYnhysfYN0hk1Dq1Ka30"},"href":"https://api.spotify.com/v1/albums/5uCYnhysfYN0hk1Dq1Ka30","id":"5uCYnhysfYN0hk1Dq1Ka30","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273edd59eaa99d50c2c5f678862"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02edd59eaa99d50c2c5f678862"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851edd59eaa99d50c2c5f678862"}],"is_playable":true,"name":"B in the Mix, The Remixes [Deluxe Version]","release_date":"2005-11-22","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:5uCYnhysfYN0hk1Dq1Ka30"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/26dSoYclwsYLMAKD3tpOr4"},"href":"https://api.spotify.com/v1/artists/26dSoYclwsYLMAKD3tpOr4","id":"26dSoYclwsYLMAKD3tpOr4","name":"Britney Spears","type":"artist","uri":"spotify:artist:26dSoYclwsYLMAKD3tpOr4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/44PA0rCQXikgOWbfY7Fq7m"},"href":"https://api.spotify.com/v1/artists/44PA0rCQXikgOWbfY7Fq7m","id":"44PA0rCQXikgOWbfY7Fq7m","name":"Ying Yang Twins","type":"artist","uri":"spotify:artist:44PA0rCQXikgOWbfY7Fq7m"}],"disc_number":1,"duration_ms":235813,"explicit":false,"external_ids":{"isrc":"USJI10500610"},"external_urls":{"spotify":"https://open.spotify.com/track/3fjPYgojh9yLxzszDrW0zC"},"href":"https://api.spotify.com/v1/tracks/3fjPYgojh9yLxzszDrW0zC","id":"3fjPYgojh9yLxzszDrW0zC","is_local":false,"is_playable":true,"name":"Breathe On Me (feat. Ying Yang Twins) - Jaques LuCont's Thin White Duke Mix","track_number":4,"type":"track","uri":"spotify:track:3fjPYgojh9yLxzszDrW0zC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nVMMEywS5Y4tsHPKx1nIo"},"href":"https://api.spotify.com/v1/artists/6nVMMEywS5Y4tsHPKx1nIo","id":"6nVMMEywS5Y4tsHPKx1nIo","name":"TVXQ!","type":"artist","uri":"spotify:artist:6nVMMEywS5Y4tsHPKx1nIo"}],"external_urls":{"spotify":"https://open.spotify.com/album/4I6px53lYqErgJcsJkUNlu"},"href":"https://api.spotify.com/v1/albums/4I6px53lYqErgJcsJkUNlu","id":"4I6px53lYqErgJcsJkUNlu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27393f60760427ff9cb94a5ba96"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0293f60760427ff9cb94a5ba96"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485193f60760427ff9cb94a5ba96"}],"is_playable":true,"name":"20&2 - The 9th Album","release_date":"2023-12-26","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4I6px53lYqErgJcsJkUNlu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nVMMEywS5Y4tsHPKx1nIo"},"href":"https://api.spotify.com/v1/artists/6nVMMEywS5Y4tsHPKx1nIo","id":"6nVMMEywS5Y4tsHPKx1nIo","name":"TVXQ!","type":"artist","uri":"spotify:artist:6nVMMEywS5Y4tsHPKx1nIo"}],"disc_number":1,"duration_ms":191800,"explicit":false,"external_ids":{"isrc":"KRA302300511"},"external_urls":{"spotify":"https://open.spotify.com/track/2zTirIUMNStSIdhHdlYNiq"},"href":"https://api.spotify.com/v1/tracks/2zTirIUMNStSIdhHdlYNiq","id":"2zTirIUMNStSIdhHdlYNiq","is_local":false,"is_playable":true,"name":"Take My Breath Away (Sung by MAX CHANGMIN)","track_number":7,"type":"track","uri":"spotify:track:2zTirIUMNStSIdhHdlYNiq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Ep2E35FvFksayzQOHD62a"},"href":"https://api.spotify.com/v1/artists/2Ep2E35FvFksayzQOHD62a","id":"2Ep2E35FvFksayzQOHD62a","name":"S l e e p y","type":"artist","uri":"spotify:artist:2Ep2E35FvFksayzQOHD62a"}],"external_urls":{"spotify":"https://open.spotify.com/album/00IisDUkBoGGp1r76xuThV"},"href":"https://api.spotify.com/v1/albums/00IisDUkBoGGp1r76xuThV","id":"00IisDUkBoGGp1r76xuThV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731138424acb18513560ab9ad5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021138424acb18513560ab9ad5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511138424acb18513560ab9ad5"}],"is_playable":true,"name":"Bliss Retreat","release_date":"2025-09-22","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:00IisDUkBoGGp1r76xuThV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Ep2E35FvFksayzQOHD62a"},"href":"https://api.spotify.com/v1/artists/2Ep2E35FvFksayzQOHD62a","id":"2Ep2E35FvFksayzQOHD62a","name":"S l e e p y","type":"artist","uri":"spotify:artist:2Ep2E35FvFksayzQOHD62a"}],"disc_number":1,"duration_ms":118857,"explicit":false,"external_ids":{"isrc":"QT2M72550177"},"external_urls":{"spotify":"https://open.spotify.com/track/4wZL66HX6YPPh4Bm15nQTJ"},"href":"https://api.spotify.com/v1/tracks/4wZL66HX6YPPh4Bm15nQTJ","id":"4wZL66HX6YPPh4Bm15nQTJ","is_local":false,"is_playable":true,"name":"Night Breath","track_number":1,"type":"track","uri":"spotify:track:4wZL66HX6YPPh4Bm15nQTJ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/45eALtDbmGR824btHqpouF"},"href":"https://api.spotify.com/v1/artists/45eALtDbmGR824btHqpouF","id":"45eALtDbmGR824btHqpouF","name":"Spa Music Relaxation","type":"artist","uri":"spotify:artist:45eALtDbmGR824btHqpouF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3hCKWhFiEID6G0QAkPAHR2"},"href":"https://api.spotify.com/v1/artists/3hCKWhFiEID6G0QAkPAHR2","id":"3hCKWhFiEID6G0QAkPAHR2","name":"Yoga","type":"artist","uri":"spotify:artist:3hCKWhFiEID6G0QAkPAHR2"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4LUYOHM73gVlfY5TzRbIgX"},"href":"https://api.spotify.com/v1/artists/4LUYOHM73gVlfY5TzRbIgX","id":"4LUYOHM73gVlfY5TzRbIgX","name":"Spa","type":"artist","uri":"spotify:artist:4LUYOHM73gVlfY5TzRbIgX"}],"external_urls":{"spotify":"https://open.spotify.com/album/7diguQCU25urTb73T4YRzX"},"href":"https://api.spotify.com/v1/albums/7diguQCU25urTb73T4YRzX","id":"7diguQCU25urTb73T4YRzX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735aa661eb68668e1fd0956851"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025aa661eb68668e1fd0956851"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515aa661eb68668e1fd0956851"}],"is_playable":true,"name":"Spa Music Relaxation Meditation (6 Hours of Relaxation)","release_date":"2026-03-06","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:7diguQCU25urTb73T4YRzX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/45eALtDbmGR824btHqpouF"},"href":"https://api.spotify.com/v1/artists/45eALtDbmGR824btHqpouF","id":"45eALtDbmGR824btHqpouF","name":"Spa Music Relaxation","type":"artist","uri":"spotify:artist:45eALtDbmGR824btHqpouF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3hCKWhFiEID6G0QAkPAHR2"},"href":"https://api.spotify.com/v1/artists/3hCKWhFiEID6G0QAkPAHR2","id":"3hCKWhFiEID6G0QAkPAHR2","name":"Yoga","type":"artist","uri":"spotify:artist:3hCKWhFiEID6G0QAkPAHR2"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4LUYOHM73gVlfY5TzRbIgX"},"href":"https://api.spotify.com/v1/artists/4LUYOHM73gVlfY5TzRbIgX","id":"4LUYOHM73gVlfY5TzRbIgX","name":"Spa","type":"artist","uri":"spotify:artist:4LUYOHM73gVlfY5TzRbIgX"}],"disc_number":1,"duration_ms":188492,"explicit":false,"external_ids":{"isrc":"DEUE22655861"},"external_urls":{"spotify":"https://open.spotify.com/track/1QvS9fVz1hwVFVebtvWSiv"},"href":"https://api.spotify.com/v1/tracks/1QvS9fVz1hwVFVebtvWSiv","id":"1QvS9fVz1hwVFVebtvWSiv","is_local":false,"is_playable":true,"name":"Relax & Breathe","track_number":77,"type":"track","uri":"spotify:track:1QvS9fVz1hwVFVebtvWSiv"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5qP8SyE8Ppll5x6MBDMQWz"},"href":"https://api.spotify.com/v1/artists/5qP8SyE8Ppll5x6MBDMQWz","id":"5qP8SyE8Ppll5x6MBDMQWz","name":"Electric Sufi","type":"artist","uri":"spotify:artist:5qP8SyE8Ppll5x6MBDMQWz"}],"external_urls":{"spotify":"https://open.spotify.com/album/1WEKBPD92YBdXWFlzF8D4S"},"href":"https://api.spotify.com/v1/albums/1WEKBPD92YBdXWFlzF8D4S","id":"1WEKBPD92YBdXWFlzF8D4S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d90feb2aa736f6c687fb0726"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d90feb2aa736f6c687fb0726"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d90feb2aa736f6c687fb0726"}],"is_playable":true,"name":"Breathe in Love","release_date":"2023-07-07","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:1WEKBPD92YBdXWFlzF8D4S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5qP8SyE8Ppll5x6MBDMQWz"},"href":"https://api.spotify.com/v1/artists/5qP8SyE8Ppll5x6MBDMQWz","id":"5qP8SyE8Ppll5x6MBDMQWz","name":"Electric Sufi","type":"artist","uri":"spotify:artist:5qP8SyE8Ppll5x6MBDMQWz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1HgmSuYRhv4IMTNjmofGWL"},"href":"https://api.spotify.com/v1/artists/1HgmSuYRhv4IMTNjmofGWL","id":"1HgmSuYRhv4IMTNjmofGWL","name":"Professor Chill","type":"artist","uri":"spotify:artist:1HgmSuYRhv4IMTNjmofGWL"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0kO3r2W8nr0b4L23ry3bYD"},"href":"https://api.spotify.com/v1/artists/0kO3r2W8nr0b4L23ry3bYD","id":"0kO3r2W8nr0b4L23ry3bYD","name":"Sarah Yaseen","type":"artist","uri":"spotify:artist:0kO3r2W8nr0b4L23ry3bYD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6vYkEAjJmlcji5vX2ebiso"},"href":"https://api.spotify.com/v1/artists/6vYkEAjJmlcji5vX2ebiso","id":"6vYkEAjJmlcji5vX2ebiso","name":"Mina Salama","type":"artist","uri":"spotify:artist:6vYkEAjJmlcji5vX2ebiso"}],"disc_number":1,"duration_ms":207773,"explicit":false,"external_ids":{"isrc":"QZES62391286"},"external_urls":{"spotify":"https://open.spotify.com/track/2pmAefFstWZN4RCK4O3MVZ"},"href":"https://api.spotify.com/v1/tracks/2pmAefFstWZN4RCK4O3MVZ","id":"2pmAefFstWZN4RCK4O3MVZ","is_local":false,"is_playable":true,"name":"Breathe in Love","track_number":4,"type":"track","uri":"spotify:track:2pmAefFstWZN4RCK4O3MVZ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5qP8SyE8Ppll5x6MBDMQWz"},"href":"https://api.spotify.com/v1/artists/5qP8SyE8Ppll5x6MBDMQWz","id":"5qP8SyE8Ppll5x6MBDMQWz","name":"Electric Sufi","type":"artist","uri":"spotify:artist:5qP8SyE8Ppll5x6MBDMQWz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6EfL3wCsnqbJGpPXdYJ3kt"},"href":"https://api.spotify.com/v1/albums/6EfL3wCsnqbJGpPXdYJ3kt","id":"6EfL3wCsnqbJGpPXdYJ3kt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736f7c479dbd380c0596cdaa46"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026f7c479dbd380c0596cdaa46"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516f7c479dbd380c0596cdaa46"}],"is_playable":true,"name":"Destiny","release_date":"2023-06-15","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:6EfL3wCsnqbJGpPXdYJ3kt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5qP8SyE8Ppll5x6MBDMQWz"},"href":"https://api.spotify.com/v1/artists/5qP8SyE8Ppll5x6MBDMQWz","id":"5qP8SyE8Ppll5x6MBDMQWz","name":"Electric Sufi","type":"artist","uri":"spotify:artist:5qP8SyE8Ppll5x6MBDMQWz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1HgmSuYRhv4IMTNjmofGWL"},"href":"https://api.spotify.com/v1/artists/1HgmSuYRhv4IMTNjmofGWL","id":"1HgmSuYRhv4IMTNjmofGWL","name":"Professor Chill","type":"artist","uri":"spotify:artist:1HgmSuYRhv4IMTNjmofGWL"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0kO3r2W8nr0b4L23ry3bYD"},"href":"https://api.spotify.com/v1/artists/0kO3r2W8nr0b4L23ry3bYD","id":"0kO3r2W8nr0b4L23ry3bYD","name":"Sarah Yaseen","type":"artist","uri":"spotify:artist:0kO3r2W8nr0b4L23ry3bYD"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6vYkEAjJmlcji5vX2ebiso"},"href":"https://api.spotify.com/v1/artists/6vYkEAjJmlcji5vX2ebiso","id":"6vYkEAjJmlcji5vX2ebiso","name":"Mina Salama","type":"artist","uri":"spotify:artist:6vYkEAjJmlcji5vX2ebiso"}],"disc_number":1,"duration_ms":207773,"explicit":false,"external_ids":{"isrc":"QZES62391286"},"external_urls":{"spotify":"https://open.spotify.com/track/73YL6QKFfqlu3JjlaFMqtm"},"href":"https://api.spotify.com/v1/tracks/73YL6QKFfqlu3JjlaFMqtm","id":"73YL6QKFfqlu3JjlaFMqtm","is_local":false,"is_playable":true,"name":"Breathe in Love","track_number":3,"type":"track","uri":"spotify:track:73YL6QKFfqlu3JjlaFMqtm"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5qP8SyE8Ppll5x6MBDMQWz"},"href":"https://api.spotify.com/v1/artists/5qP8SyE8Ppll5x6MBDMQWz","id":"5qP8SyE8Ppll5x6MBDMQWz","name":"Electric Sufi","type":"artist","uri":"spotify:artist:5qP8SyE8Ppll5x6MBDMQWz"}],"external_urls":{"spotify":"https://open.spotify.com/album/4GxwhuIHSKGtCVrudWr4pJ"},"href":"https://api.spotify.com/v1/albums/4GxwhuIHSKGtCVrudWr4pJ","id":"4GxwhuIHSKGtCVrudWr4pJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732d7b6fe254de31ba861d432c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022d7b6fe254de31ba861d432c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512d7b6fe254de31ba861d432c"}],"is_playable":true,"name":"Hudaaya","release_date":"2023-05-17","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:4GxwhuIHSKGtCVrudWr4pJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5qP8SyE8Ppll5x6MBDMQWz"},"href":"https://api.spotify.com/v1/artists/5qP8SyE8Ppll5x6MBDMQWz","id":"5qP8SyE8Ppll5x6MBDMQWz","name":"Electric Sufi","type":"artist","uri":"spotify:artist:5qP8SyE8Ppll5x6MBDMQWz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1HgmSuYRhv4IMTNjmofGWL"},"href":"https://api.spotify.com/v1/artists/1HgmSuYRhv4IMTNjmofGWL","id":"1HgmSuYRhv4IMTNjmofGWL","name":"Professor Chill","type":"artist","uri":"spotify:artist:1HgmSuYRhv4IMTNjmofGWL"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6vYkEAjJmlcji5vX2ebiso"},"href":"https://api.spotify.com/v1/artists/6vYkEAjJmlcji5vX2ebiso","id":"6vYkEAjJmlcji5vX2ebiso","name":"Mina Salama","type":"artist","uri":"spotify:artist:6vYkEAjJmlcji5vX2ebiso"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0kO3r2W8nr0b4L23ry3bYD"},"href":"https://api.spotify.com/v1/artists/0kO3r2W8nr0b4L23ry3bYD","id":"0kO3r2W8nr0b4L23ry3bYD","name":"Sarah Yaseen","type":"artist","uri":"spotify:artist:0kO3r2W8nr0b4L23ry3bYD"}],"disc_number":1,"duration_ms":207773,"explicit":false,"external_ids":{"isrc":"QZES62391286"},"external_urls":{"spotify":"https://open.spotify.com/track/4gY5KWNQtLotslaQwchji7"},"href":"https://api.spotify.com/v1/tracks/4gY5KWNQtLotslaQwchji7","id":"4gY5KWNQtLotslaQwchji7","is_local":false,"is_playable":true,"name":"Breathe in Love","track_number":2,"type":"track","uri":"spotify:track:4gY5KWNQtLotslaQwchji7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/45eALtDbmGR824btHqpouF"},"href":"https://api.spotify.com/v1/artists/45eALtDbmGR824btHqpouF","id":"45eALtDbmGR824btHqpouF","name":"Spa Music Relaxation","type":"artist","uri":"spotify:artist:45eALtDbmGR824btHqpouF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3hCKWhFiEID6G0QAkPAHR2"},"href":"https://api.spotify.com/v1/artists/3hCKWhFiEID6G0QAkPAHR2","id":"3hCKWhFiEID6G0QAkPAHR2","name":"Yoga","type":"artist","uri":"spotify:artist:3hCKWhFiEID6G0QAkPAHR2"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4LUYOHM73gVlfY5TzRbIgX"},"href":"https://api.spotify.com/v1/artists/4LUYOHM73gVlfY5TzRbIgX","id":"4LUYOHM73gVlfY5TzRbIgX","name":"Spa","type":"artist","uri":"spotify:artist:4LUYOHM73gVlfY5TzRbIgX"}],"external_urls":{"spotify":"https://open.spotify.com/album/7diguQCU25urTb73T4YRzX"},"href":"https://api.spotify.com/v1/albums/7diguQCU25urTb73T4YRzX","id":"7diguQCU25urTb73T4YRzX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735aa661eb68668e1fd0956851"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025aa661eb68668e1fd0956851"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515aa661eb68668e1fd0956851"}],"is_playable":true,"name":"Spa Music Relaxation Meditation (6 Hours of Relaxation)","release_date":"2026-03-06","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:7diguQCU25urTb73T4YRzX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/45eALtDbmGR824btHqpouF"},"href":"https://api.spotify.com/v1/artists/45eALtDbmGR824btHqpouF","id":"45eALtDbmGR824btHqpouF","name":"Spa Music Relaxation","type":"artist","uri":"spotify:artist:45eALtDbmGR824btHqpouF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3hCKWhFiEID6G0QAkPAHR2"},"href":"https://api.spotify.com/v1/artists/3hCKWhFiEID6G0QAkPAHR2","id":"3hCKWhFiEID6G0QAkPAHR2","name":"Yoga","type":"artist","uri":"spotify:artist:3hCKWhFiEID6G0QAkPAHR2"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4LUYOHM73gVlfY5TzRbIgX"},"href":"https://api.spotify.com/v1/artists/4LUYOHM73gVlfY5TzRbIgX","id":"4LUYOHM73gVlfY5TzRbIgX","name":"Spa","type":"artist","uri":"spotify:artist:4LUYOHM73gVlfY5TzRbIgX"}],"disc_number":1,"duration_ms":218292,"explicit":false,"external_ids":{"isrc":"DEUE22655826"},"external_urls":{"spotify":"https://open.spotify.com/track/4yEeKFLdjfFBzqKrcqZF5l"},"href":"https://api.spotify.com/v1/tracks/4yEeKFLdjfFBzqKrcqZF5l","id":"4yEeKFLdjfFBzqKrcqZF5l","is_local":false,"is_playable":true,"name":"Balance & Breathe","track_number":42,"type":"track","uri":"spotify:track:4yEeKFLdjfFBzqKrcqZF5l"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJyZWF0aGUlMjIlMjBhcnRpc3QlM0ElMjJTLlAuWSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvc2VhcmNoP29mZnNldD0xMCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJyZWF0aGUlMjIlMjBhcnRpc3QlM0ElMjJTLlAuWSUyMiZ0eXBlPXRyYWNrIiwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjM2LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zWVIwMWtkT3p0ZzJwOW52RDZNUmc3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNZUjAxa2RPenRnMnA5bnZENk1SZzciLCJpZCI6IjNZUjAxa2RPenRnMnA5bnZENk1SZzciLCJuYW1lIjoiUG9sbHkgU2NhdHRlcmdvb2QiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1lSMDFrZE96dGcycDludkQ2TVJnNyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ6VVRSb29HMWVhQmtqRzgzYm1vQ1kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82elVUUm9v", + "RzFlYUJrakc4M2Jtb0NZIiwiaWQiOiI2elVUUm9vRzFlYUJrakc4M2Jtb0NZIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2JhZmVjMTFmNDA0NmZmNTVkN2EzYmQzYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiYWZlYzExZjQwNDZmZjU1ZDdhM2JkM2MifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWJhZmVjMTFmNDA0NmZmNTVkN2EzYmQzYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQb2xseSBTY2F0dGVyZ29vZCIsInJlbGVhc2VfZGF0ZSI6IjIwMDktMDMtMDkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2elVUUm9vRzFlYUJrakc4M2Jtb0NZIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1lSMDFrZE96dGcycDludkQ2TVJnNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zWVIwMWtkT3p0ZzJwOW52RDZNUmc3IiwiaWQiOiIzWVIwMWtkT3p0ZzJwOW52RDZNUmc3IiwibmFtZSI6IlBvbGx5IFNjYXR0ZXJnb29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNZUjAxa2RPenRnMnA5bnZENk1SZzcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjc0NzIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSkgwOTAwMDk0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zUVg4UGtIWjlsR3VaNGxyYXFQQ1lDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM1FYOFBrSFo5bEd1WjRscmFxUENZQyIsImlkIjoiM1FYOFBrSFo5bEd1WjRscmFxUENZQyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCcmVhdGhlIGluIEJyZWF0aGUgT3V0IiwidHJhY2tfbnVtYmVyIjoxMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozUVg4UGtIWjlsR3VaNGxyYXFQQ1lDIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNmRTb1ljbHdzWUxNQUtEM3RwT3I0In0sImhyZQ==", + "ZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjZkU29ZY2x3c1lMTUFLRDN0cE9yNCIsImlkIjoiMjZkU29ZY2x3c1lMTUFLRDN0cE9yNCIsIm5hbWUiOiJCcml0bmV5IFNwZWFycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNmRTb1ljbHdzWUxNQUtEM3RwT3I0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNHdkWmNxRHNzVWtRTlF6TlpEMkZQTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzR3ZFpjcURzc1VrUU5Rek5aRDJGUE4iLCJpZCI6IjR3ZFpjcURzc1VrUU5Rek5aRDJGUE4iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMWI4MDRkNDRjNDQ0MjI1ZThjY2NiODA2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjFiODA0ZDQ0YzQ0NDIyNWU4Y2NjYjgwNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMWI4MDRkNDRjNDQ0MjI1ZThjY2NiODA2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJyaXRuZXkgU3BlYXJzIFJlbWl4IFNhbXBsZXIiLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTEyLTMxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0d2RaY3FEc3NVa1FOUXpOWkQyRlBOIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjZkU29ZY2x3c1lMTUFLRDN0cE9yNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNmRTb1ljbHdzWUxNQUtEM3RwT3I0IiwiaWQiOiIyNmRTb1ljbHdzWUxNQUtEM3RwT3I0IiwibmFtZSI6IkJyaXRuZXkgU3BlYXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI2ZFNvWWNsd3NZTE1BS0QzdHBPcjQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDRQQTByQ1FYaWtnT1diZlk3RnE3bSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80NFBBMHJDUVhpa2dPV2JmWTdGcTdtIiwiaWQiOiI0NFBBMHJDUVhpa2dPV2JmWTdGcTdtIiwibmFtZSI6IllpbmcgWWFuZyBUd2lucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcA==", + "b3RpZnk6YXJ0aXN0OjQ0UEEwckNRWGlrZ09XYmZZN0ZxN20ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQwMDUzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNKSTEwNTAwNjEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81Z1YwTEZYd0VJZmZuV3d1cHdpWXNlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNWdWMExGWHdFSWZmbld3dXB3aVlzZSIsImlkIjoiNWdWMExGWHdFSWZmbld3dXB3aVlzZSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCcmVhdGhlIE9uIE1lIChmZWF0LiBZaW5nIFlhbmcgVHdpbnMpIC0gSmFxdWVzIEx1Q29udCdzIFRoaW4gV2hpdGUgRHVrZSBNaXgiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NWdWMExGWHdFSWZmbld3dXB3aVlzZSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNmRTb1ljbHdzWUxNQUtEM3RwT3I0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI2ZFNvWWNsd3NZTE1BS0QzdHBPcjQiLCJpZCI6IjI2ZFNvWWNsd3NZTE1BS0QzdHBPcjQiLCJuYW1lIjoiQnJpdG5leSBTcGVhcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjZkU29ZY2x3c1lMTUFLRDN0cE9yNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzV1Q1luaHlzZllOMGhrMURxMUthMzAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81dUNZbmh5c2ZZTjBoazFEcTFLYTMwIiwiaWQiOiI1dUNZbmh5c2ZZTjBoazFEcTFLYTMwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2VkZDU5ZWFhOTlkNTBjMmM1ZjY3ODg2MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlZGQ1OWVhYTk5ZDUwYzJjNWY2Nzg4NjIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVkZDU5ZWFhOTlkNTBjMmM1ZjY3ODg2MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCIGluIHRoZSBNaXgsIFRoZSBSZW1peGVzIFtEZWx1eA==", + "ZSBWZXJzaW9uXSIsInJlbGVhc2VfZGF0ZSI6IjIwMDUtMTEtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1dUNZbmh5c2ZZTjBoazFEcTFLYTMwIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjZkU29ZY2x3c1lMTUFLRDN0cE9yNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNmRTb1ljbHdzWUxNQUtEM3RwT3I0IiwiaWQiOiIyNmRTb1ljbHdzWUxNQUtEM3RwT3I0IiwibmFtZSI6IkJyaXRuZXkgU3BlYXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI2ZFNvWWNsd3NZTE1BS0QzdHBPcjQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDRQQTByQ1FYaWtnT1diZlk3RnE3bSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80NFBBMHJDUVhpa2dPV2JmWTdGcTdtIiwiaWQiOiI0NFBBMHJDUVhpa2dPV2JmWTdGcTdtIiwibmFtZSI6IllpbmcgWWFuZyBUd2lucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0NFBBMHJDUVhpa2dPV2JmWTdGcTdtIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNTgxMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSkkxMDUwMDYxMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2ZqUFlnb2poOXlMeHpzekRyVzB6QyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNmalBZZ29qaDl5THh6c3pEclcwekMiLCJpZCI6IjNmalBZZ29qaDl5THh6c3pEclcwekMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQnJlYXRoZSBPbiBNZSAoZmVhdC4gWWluZyBZYW5nIFR3aW5zKSAtIEphcXVlcyBMdUNvbnQncyBUaGluIFdoaXRlIER1a2UgTWl4IiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNmalBZZ29qaDl5THh6c3pEclcwekMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm5WTU1FeXdTNVk0dHNIUEt4MW5JbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82blZNTUV5d1M1WTR0c0hQS3gxbklvIiwiaWQiOiI2bg==", + "Vk1NRXl3UzVZNHRzSFBLeDFuSW8iLCJuYW1lIjoiVFZYUSEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm5WTU1FeXdTNVk0dHNIUEt4MW5JbyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRJNnB4NTNsWXFFcmdKY3NKa1VObHUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80STZweDUzbFlxRXJnSmNzSmtVTmx1IiwiaWQiOiI0STZweDUzbFlxRXJnSmNzSmtVTmx1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzkzZjYwNzYwNDI3ZmY5Y2I5NGE1YmE5NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5M2Y2MDc2MDQyN2ZmOWNiOTRhNWJhOTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTkzZjYwNzYwNDI3ZmY5Y2I5NGE1YmE5NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiIyMCYyIC0gVGhlIDl0aCBBbGJ1bSIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMTItMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0STZweDUzbFlxRXJnSmNzSmtVTmx1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm5WTU1FeXdTNVk0dHNIUEt4MW5JbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82blZNTUV5d1M1WTR0c0hQS3gxbklvIiwiaWQiOiI2blZNTUV5d1M1WTR0c0hQS3gxbklvIiwibmFtZSI6IlRWWFEhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZuVk1NRXl3UzVZNHRzSFBLeDFuSW8ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTkxODAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiS1JBMzAyMzAwNTExIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yelRpcklVTU5TdFNJZGhIZGxZTmlxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMnpUaXJJVU1OU3RTSWRoSGRsWU5pcSIsImlkIjoiMnpUaXJJVU1OU3RTSWRoSGRsWU5pcSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUYWtlIE15IEJyZQ==", + "YXRoIEF3YXkgKFN1bmcgYnkgTUFYIENIQU5HTUlOKSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyelRpcklVTU5TdFNJZGhIZGxZTmlxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJFcDJFMzVGdkZrc2F5elFPSEQ2MmEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkVwMkUzNUZ2RmtzYXl6UU9IRDYyYSIsImlkIjoiMkVwMkUzNUZ2RmtzYXl6UU9IRDYyYSIsIm5hbWUiOiJTIGwgZSBlIHAgeSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRXAyRTM1RnZGa3NheXpRT0hENjJhIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMDBJaXNEVWtCb0dHcDFyNzZ4dVRoViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzAwSWlzRFVrQm9HR3Axcjc2eHVUaFYiLCJpZCI6IjAwSWlzRFVrQm9HR3Axcjc2eHVUaFYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMTEzODQyNGFjYjE4NTEzNTYwYWI5YWQ1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjExMzg0MjRhY2IxODUxMzU2MGFiOWFkNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTEzODQyNGFjYjE4NTEzNTYwYWI5YWQ1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJsaXNzIFJldHJlYXQiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA5LTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowMElpc0RVa0JvR0dwMXI3Nnh1VGhWIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkVwMkUzNUZ2RmtzYXl6UU9IRDYyYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRXAyRTM1RnZGa3NheXpRT0hENjJhIiwiaWQiOiIyRXAyRTM1RnZGa3NheXpRT0hENjJhIiwibmFtZSI6IlMgbCBlIGUgcCB5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJFcDJFMzVGdkZrc2F5elFPSEQ2MmEifV0sImRpc2NfbnVtYg==", + "ZXIiOjEsImR1cmF0aW9uX21zIjoxMTg4NTcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRVDJNNzI1NTAxNzcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzR3Wkw2NkhYNllQUGg0Qm0xNW5RVEoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80d1pMNjZIWDZZUFBoNEJtMTVuUVRKIiwiaWQiOiI0d1pMNjZIWDZZUFBoNEJtMTVuUVRKIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5pZ2h0IEJyZWF0aCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0d1pMNjZIWDZZUFBoNEJtMTVuUVRKIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzQ1ZUFMdERibUdSODI0YnRIcXBvdUYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNDVlQUx0RGJtR1I4MjRidEhxcG91RiIsImlkIjoiNDVlQUx0RGJtR1I4MjRidEhxcG91RiIsIm5hbWUiOiJTcGEgTXVzaWMgUmVsYXhhdGlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0NWVBTHREYm1HUjgyNGJ0SHFwb3VGIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNoQ0tXaEZpRUlENkcwUUFrUEFIUjIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2hDS1doRmlFSUQ2RzBRQWtQQUhSMiIsImlkIjoiM2hDS1doRmlFSUQ2RzBRQWtQQUhSMiIsIm5hbWUiOiJZb2dhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNoQ0tXaEZpRUlENkcwUUFrUEFIUjIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNExVWU9ITTczZ1ZsZlk1VHpSYklnWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80TFVZT0hNNzNnVmxmWTVUelJiSWdYIiwiaWQiOiI0TFVZT0hNNzNnVmxmWTVUelJiSWdYIiwibmFtZSI6IlNwYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0TFVZT0hNNzNnVmxmWTVUelJiSWdYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN2RpZ3VRQ1UyNXVyVGI3M1Q0WVJ6WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdkaWd1UUNVMjV1clRiNw==", + "M1Q0WVJ6WCIsImlkIjoiN2RpZ3VRQ1UyNXVyVGI3M1Q0WVJ6WCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1YWE2NjFlYjY4NjY4ZTFmZDA5NTY4NTEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWFhNjYxZWI2ODY2OGUxZmQwOTU2ODUxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1YWE2NjFlYjY4NjY4ZTFmZDA5NTY4NTEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3BhIE11c2ljIFJlbGF4YXRpb24gTWVkaXRhdGlvbiAoNiBIb3VycyBvZiBSZWxheGF0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDMtMDYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N2RpZ3VRQ1UyNXVyVGI3M1Q0WVJ6WCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzQ1ZUFMdERibUdSODI0YnRIcXBvdUYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNDVlQUx0RGJtR1I4MjRidEhxcG91RiIsImlkIjoiNDVlQUx0RGJtR1I4MjRidEhxcG91RiIsIm5hbWUiOiJTcGEgTXVzaWMgUmVsYXhhdGlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0NWVBTHREYm1HUjgyNGJ0SHFwb3VGIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNoQ0tXaEZpRUlENkcwUUFrUEFIUjIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2hDS1doRmlFSUQ2RzBRQWtQQUhSMiIsImlkIjoiM2hDS1doRmlFSUQ2RzBRQWtQQUhSMiIsIm5hbWUiOiJZb2dhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNoQ0tXaEZpRUlENkcwUUFrUEFIUjIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNExVWU9ITTczZ1ZsZlk1VHpSYklnWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80TFVZT0hNNzNnVmxmWTVUelJiSWdYIiwiaWQiOiI0TFVZT0hNNzNnVmxmWTVUelJiSWdYIiwibmFtZSI6IlNwYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0TFVZT0hNNzNnVmxmWTVUelJiSWdYIn1dLA==", + "ImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg4NDkyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiREVVRTIyNjU1ODYxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xUXZTOWZWejFod1ZGVmVidHZXU2l2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVF2UzlmVnoxaHdWRlZlYnR2V1NpdiIsImlkIjoiMVF2UzlmVnoxaHdWRlZlYnR2V1NpdiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWxheCAmIEJyZWF0aGUiLCJ0cmFja19udW1iZXIiOjc3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFRdlM5ZlZ6MWh3VkZWZWJ0dldTaXYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXFQOFN5RThQcGxsNXg2TUJETVFXeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81cVA4U3lFOFBwbGw1eDZNQkRNUVd6IiwiaWQiOiI1cVA4U3lFOFBwbGw1eDZNQkRNUVd6IiwibmFtZSI6IkVsZWN0cmljIFN1ZmkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFQOFN5RThQcGxsNXg2TUJETVFXeiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFXRUtCUEQ5MllCZFhXRmx6RjhENFMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xV0VLQlBEOTJZQmRYV0ZsekY4RDRTIiwiaWQiOiIxV0VLQlBEOTJZQmRYV0ZsekY4RDRTIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2Q5MGZlYjJhYTczNmY2YzY4N2ZiMDcyNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkOTBmZWIyYWE3MzZmNmM2ODdmYjA3MjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWQ5MGZlYjJhYTczNmY2YzY4N2ZiMDcyNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCcmVhdGhlIGluIExvdmUiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA3LTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVdFS0JQRA==", + "OTJZQmRYV0ZsekY4RDRTIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXFQOFN5RThQcGxsNXg2TUJETVFXeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81cVA4U3lFOFBwbGw1eDZNQkRNUVd6IiwiaWQiOiI1cVA4U3lFOFBwbGw1eDZNQkRNUVd6IiwibmFtZSI6IkVsZWN0cmljIFN1ZmkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFQOFN5RThQcGxsNXg2TUJETVFXeiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xSGdtU3VZUmh2NElNVE5qbW9mR1dMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFIZ21TdVlSaHY0SU1UTmptb2ZHV0wiLCJpZCI6IjFIZ21TdVlSaHY0SU1UTmptb2ZHV0wiLCJuYW1lIjoiUHJvZmVzc29yIENoaWxsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFIZ21TdVlSaHY0SU1UTmptb2ZHV0wifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGtPM3IyVzhucjBiNEwyM3J5M2JZRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa08zcjJXOG5yMGI0TDIzcnkzYllEIiwiaWQiOiIwa08zcjJXOG5yMGI0TDIzcnkzYllEIiwibmFtZSI6IlNhcmFoIFlhc2VlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa08zcjJXOG5yMGI0TDIzcnkzYllEIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ2WWtFQWpKbWxjamk1dlgyZWJpc28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnZZa0VBakptbGNqaTV2WDJlYmlzbyIsImlkIjoiNnZZa0VBakptbGNqaTV2WDJlYmlzbyIsIm5hbWUiOiJNaW5hIFNhbGFtYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2dllrRUFqSm1sY2ppNXZYMmViaXNvIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNzc3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaRVM2MjM5MTI4NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMnBtQWVmRnN0V1pONFJDSzRPM01WWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJwbUFlZkZzdFdaTjRSQ0s0TzNNVloiLCJpZCI6IjJwbUFlZkZzdFdaTjRSQ0s0TzNNVloiLA==", + "ImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCcmVhdGhlIGluIExvdmUiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MnBtQWVmRnN0V1pONFJDSzRPM01WWiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXFQOFN5RThQcGxsNXg2TUJETVFXeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81cVA4U3lFOFBwbGw1eDZNQkRNUVd6IiwiaWQiOiI1cVA4U3lFOFBwbGw1eDZNQkRNUVd6IiwibmFtZSI6IkVsZWN0cmljIFN1ZmkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFQOFN5RThQcGxsNXg2TUJETVFXeiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZFZkwzd0NzbnFiSkdwUFhkWUoza3QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82RWZMM3dDc25xYkpHcFBYZFlKM2t0IiwiaWQiOiI2RWZMM3dDc25xYkpHcFBYZFlKM2t0IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZmN2M0NzlkYmQzODBjMDU5NmNkYWE0NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2ZjdjNDc5ZGJkMzgwYzA1OTZjZGFhNDYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZmN2M0NzlkYmQzODBjMDU5NmNkYWE0NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZXN0aW55IiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wNi0xNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkVmTDN3Q3NucWJKR3BQWGRZSjNrdCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVxUDhTeUU4UHBsbDV4Nk1CRE1RV3oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXFQOFN5RThQcGxsNXg2TUJETVFXeiIsImlkIjoiNXFQOFN5RThQcGxsNXg2TUJETVFXeiIsIm5hbWUiOiJFbGVjdHJpYyBTdWZpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVxUDhTeUU4UA==", + "cGxsNXg2TUJETVFXeiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xSGdtU3VZUmh2NElNVE5qbW9mR1dMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFIZ21TdVlSaHY0SU1UTmptb2ZHV0wiLCJpZCI6IjFIZ21TdVlSaHY0SU1UTmptb2ZHV0wiLCJuYW1lIjoiUHJvZmVzc29yIENoaWxsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFIZ21TdVlSaHY0SU1UTmptb2ZHV0wifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGtPM3IyVzhucjBiNEwyM3J5M2JZRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa08zcjJXOG5yMGI0TDIzcnkzYllEIiwiaWQiOiIwa08zcjJXOG5yMGI0TDIzcnkzYllEIiwibmFtZSI6IlNhcmFoIFlhc2VlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa08zcjJXOG5yMGI0TDIzcnkzYllEIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ2WWtFQWpKbWxjamk1dlgyZWJpc28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnZZa0VBakptbGNqaTV2WDJlYmlzbyIsImlkIjoiNnZZa0VBakptbGNqaTV2WDJlYmlzbyIsIm5hbWUiOiJNaW5hIFNhbGFtYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2dllrRUFqSm1sY2ppNXZYMmViaXNvIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNzc3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaRVM2MjM5MTI4NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNzNZTDZRS0ZmcWx1M0pqbGFGTXF0bSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzczWUw2UUtGZnFsdTNKamxhRk1xdG0iLCJpZCI6IjczWUw2UUtGZnFsdTNKamxhRk1xdG0iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQnJlYXRoZSBpbiBMb3ZlIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjczWUw2UUtGZnFsdTNKamxhRk1xdG0ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVxUDhTeUU4UHBsbDV4Nk1CRE1RV3oifSwiaHJlZiI6Imh0dHBzOg==", + "Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81cVA4U3lFOFBwbGw1eDZNQkRNUVd6IiwiaWQiOiI1cVA4U3lFOFBwbGw1eDZNQkRNUVd6IiwibmFtZSI6IkVsZWN0cmljIFN1ZmkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXFQOFN5RThQcGxsNXg2TUJETVFXeiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRHeHdodUlIU0tHdENWcnVkV3I0cEoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80R3h3aHVJSFNLR3RDVnJ1ZFdyNHBKIiwiaWQiOiI0R3h3aHVJSFNLR3RDVnJ1ZFdyNHBKIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzJkN2I2ZmUyNTRkZTMxYmE4NjFkNDMyYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyZDdiNmZlMjU0ZGUzMWJhODYxZDQzMmMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJkN2I2ZmUyNTRkZTMxYmE4NjFkNDMyYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIdWRhYXlhIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wNS0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEd4d2h1SUhTS0d0Q1ZydWRXcjRwSiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVxUDhTeUU4UHBsbDV4Nk1CRE1RV3oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXFQOFN5RThQcGxsNXg2TUJETVFXeiIsImlkIjoiNXFQOFN5RThQcGxsNXg2TUJETVFXeiIsIm5hbWUiOiJFbGVjdHJpYyBTdWZpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVxUDhTeUU4UHBsbDV4Nk1CRE1RV3oifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMUhnbVN1WVJodjRJTVROam1vZkdXTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xSGdtU3VZUmh2NElNVE5qbW9mR1dMIiwiaWQiOiIxSGdtU3VZUmh2NElNVE5qbW9mR1dMIiwibmFtZSI6IlByb2Zlc3NvciBDaGlsbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxSGdtU3VZUmh2NElNVE5qbW9mRw==", + "V0wifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnZZa0VBakptbGNqaTV2WDJlYmlzbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82dllrRUFqSm1sY2ppNXZYMmViaXNvIiwiaWQiOiI2dllrRUFqSm1sY2ppNXZYMmViaXNvIiwibmFtZSI6Ik1pbmEgU2FsYW1hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZ2WWtFQWpKbWxjamk1dlgyZWJpc28ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGtPM3IyVzhucjBiNEwyM3J5M2JZRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wa08zcjJXOG5yMGI0TDIzcnkzYllEIiwiaWQiOiIwa08zcjJXOG5yMGI0TDIzcnkzYllEIiwibmFtZSI6IlNhcmFoIFlhc2VlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowa08zcjJXOG5yMGI0TDIzcnkzYllEIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNzc3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaRVM2MjM5MTI4NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGdZNUtXTlF0TG90c2xhUXdjaGppNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRnWTVLV05RdExvdHNsYVF3Y2hqaTciLCJpZCI6IjRnWTVLV05RdExvdHNsYVF3Y2hqaTciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQnJlYXRoZSBpbiBMb3ZlIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRnWTVLV05RdExvdHNsYVF3Y2hqaTcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDVlQUx0RGJtR1I4MjRidEhxcG91RiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80NWVBTHREYm1HUjgyNGJ0SHFwb3VGIiwiaWQiOiI0NWVBTHREYm1HUjgyNGJ0SHFwb3VGIiwibmFtZSI6IlNwYSBNdXNpYyBSZWxheGF0aW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjQ1ZUFMdERibUdSODI0YnRIcXBvdUYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2hDS1doRmlFSUQ2RzBRQWtQQUhSMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkucw==", + "cG90aWZ5LmNvbS92MS9hcnRpc3RzLzNoQ0tXaEZpRUlENkcwUUFrUEFIUjIiLCJpZCI6IjNoQ0tXaEZpRUlENkcwUUFrUEFIUjIiLCJuYW1lIjoiWW9nYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozaENLV2hGaUVJRDZHMFFBa1BBSFIyIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRMVVlPSE03M2dWbGZZNVR6UmJJZ1gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNExVWU9ITTczZ1ZsZlk1VHpSYklnWCIsImlkIjoiNExVWU9ITTczZ1ZsZlk1VHpSYklnWCIsIm5hbWUiOiJTcGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExVWU9ITTczZ1ZsZlk1VHpSYklnWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdkaWd1UUNVMjV1clRiNzNUNFlSelgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83ZGlndVFDVTI1dXJUYjczVDRZUnpYIiwiaWQiOiI3ZGlndVFDVTI1dXJUYjczVDRZUnpYIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzVhYTY2MWViNjg2NjhlMWZkMDk1Njg1MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1YWE2NjFlYjY4NjY4ZTFmZDA5NTY4NTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTVhYTY2MWViNjg2NjhlMWZkMDk1Njg1MSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTcGEgTXVzaWMgUmVsYXhhdGlvbiBNZWRpdGF0aW9uICg2IEhvdXJzIG9mIFJlbGF4YXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wMy0wNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3ZGlndVFDVTI1dXJUYjczVDRZUnpYIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDVlQUx0RGJtR1I4MjRidEhxcG91RiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80NWVBTHREYm1HUjgyNGJ0SHFwb3VGIiwiaWQiOiI0NWVBTHREYm1HUjgyNGJ0SHFwb3VGIiwibmFtZSI6IlNwYSBNdXNpYyBSZWxheGF0aW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZg==", + "eTphcnRpc3Q6NDVlQUx0RGJtR1I4MjRidEhxcG91RiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zaENLV2hGaUVJRDZHMFFBa1BBSFIyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNoQ0tXaEZpRUlENkcwUUFrUEFIUjIiLCJpZCI6IjNoQ0tXaEZpRUlENkcwUUFrUEFIUjIiLCJuYW1lIjoiWW9nYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozaENLV2hGaUVJRDZHMFFBa1BBSFIyIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRMVVlPSE03M2dWbGZZNVR6UmJJZ1gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNExVWU9ITTczZ1ZsZlk1VHpSYklnWCIsImlkIjoiNExVWU9ITTczZ1ZsZlk1VHpSYklnWCIsIm5hbWUiOiJTcGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExVWU9ITTczZ1ZsZlk1VHpSYklnWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTgyOTIsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJERVVFMjI2NTU4MjYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzR5RWVLRkxkamZGQnpxS3JjcVpGNWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80eUVlS0ZMZGpmRkJ6cUtyY3FaRjVsIiwiaWQiOiI0eUVlS0ZMZGpmRkJ6cUtyY3FaRjVsIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhbGFuY2UgJiBCcmVhdGhlIiwidHJhY2tfbnVtYmVyIjo0MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0eUVlS0ZMZGpmRkJ6cUtyY3FaRjVsIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Breathe%22+artist%3A%22S.P.Y%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNvbG91cnMlMjIlMjBhcnRpc3QlM0ElMjJLYXNyYSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNvbG91cnMlMjIlMjBhcnRpc3QlM0ElMjJLYXNyYSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Colours%22+artist%3A%22Kasra%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkF3YWtlJTIyJTIwYXJ0aXN0JTNBJTIyTnUlM0FMb2dpYyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkF3YWtlJTIyJTIwYXJ0aXN0JTNBJTIyTnUlM0FMb2dpYyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Awake%22+artist%3A%22Nu%3ALogic%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Fireflies%20Netsky&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3mfzGU2lo4GHJpwiPSxCWk"},"href":"https://api.spotify.com/v1/artists/3mfzGU2lo4GHJpwiPSxCWk","id":"3mfzGU2lo4GHJpwiPSxCWk","name":"Noire","type":"artist","uri":"spotify:artist:3mfzGU2lo4GHJpwiPSxCWk"}],"external_urls":{"spotify":"https://open.spotify.com/album/5SfOCbq9zKXeMX22DRfT30"},"href":"https://api.spotify.com/v1/albums/5SfOCbq9zKXeMX22DRfT30","id":"5SfOCbq9zKXeMX22DRfT30","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730443057a8ff6bf28f55ef4b8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020443057a8ff6bf28f55ef4b8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510443057a8ff6bf28f55ef4b8"}],"is_playable":true,"name":"Fireflies","release_date":"2023-09-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5SfOCbq9zKXeMX22DRfT30"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3mfzGU2lo4GHJpwiPSxCWk"},"href":"https://api.spotify.com/v1/artists/3mfzGU2lo4GHJpwiPSxCWk","id":"3mfzGU2lo4GHJpwiPSxCWk","name":"Noire","type":"artist","uri":"spotify:artist:3mfzGU2lo4GHJpwiPSxCWk"}],"disc_number":1,"duration_ms":147365,"explicit":false,"external_ids":{"isrc":"DEH742320985"},"external_urls":{"spotify":"https://open.spotify.com/track/3a4IWxPdLtUn7vXnRUTbEs"},"href":"https://api.spotify.com/v1/tracks/3a4IWxPdLtUn7vXnRUTbEs","id":"3a4IWxPdLtUn7vXnRUTbEs","is_local":false,"is_playable":true,"name":"Fireflies","track_number":1,"type":"track","uri":"spotify:track:3a4IWxPdLtUn7vXnRUTbEs"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1HON4xJAWJNuUpb6G64bNr"},"href":"https://api.spotify.com/v1/artists/1HON4xJAWJNuUpb6G64bNr","id":"1HON4xJAWJNuUpb6G64bNr","name":"Soothing Oasis","type":"artist","uri":"spotify:artist:1HON4xJAWJNuUpb6G64bNr"}],"external_urls":{"spotify":"https://open.spotify.com/album/7kH0MiIwjbYQdfI83dZdOt"},"href":"https://api.spotify.com/v1/albums/7kH0MiIwjbYQdfI83dZdOt","id":"7kH0MiIwjbYQdfI83dZdOt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dee2b36cac402dcba897f99c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dee2b36cac402dcba897f99c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dee2b36cac402dcba897f99c"}],"is_playable":true,"name":"Breathing Forest","release_date":"2024-10-22","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:7kH0MiIwjbYQdfI83dZdOt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1HON4xJAWJNuUpb6G64bNr"},"href":"https://api.spotify.com/v1/artists/1HON4xJAWJNuUpb6G64bNr","id":"1HON4xJAWJNuUpb6G64bNr","name":"Soothing Oasis","type":"artist","uri":"spotify:artist:1HON4xJAWJNuUpb6G64bNr"}],"disc_number":1,"duration_ms":132260,"explicit":false,"external_ids":{"isrc":"NL1Y62401092"},"external_urls":{"spotify":"https://open.spotify.com/track/72n6VeSV4s6jXW3Fh5sy8y"},"href":"https://api.spotify.com/v1/tracks/72n6VeSV4s6jXW3Fh5sy8y","id":"72n6VeSV4s6jXW3Fh5sy8y","is_local":false,"is_playable":true,"name":"Fireflies","track_number":2,"type":"track","uri":"spotify:track:72n6VeSV4s6jXW3Fh5sy8y"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04VLPuPMkGCDtN98wQbuob"},"href":"https://api.spotify.com/v1/artists/04VLPuPMkGCDtN98wQbuob","id":"04VLPuPMkGCDtN98wQbuob","name":"Sunset Chasers","type":"artist","uri":"spotify:artist:04VLPuPMkGCDtN98wQbuob"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UJZu7S4F22tWYZ2CdsJQr"},"href":"https://api.spotify.com/v1/artists/2UJZu7S4F22tWYZ2CdsJQr","id":"2UJZu7S4F22tWYZ2CdsJQr","name":"Bikini Bandits","type":"artist","uri":"spotify:artist:2UJZu7S4F22tWYZ2CdsJQr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6KTaHMqi4D1QVSO5flHJNV"},"href":"https://api.spotify.com/v1/artists/6KTaHMqi4D1QVSO5flHJNV","id":"6KTaHMqi4D1QVSO5flHJNV","name":"Charlie Arthur","type":"artist","uri":"spotify:artist:6KTaHMqi4D1QVSO5flHJNV"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ThYVevN9CTQ4jDXhNvTgR"},"href":"https://api.spotify.com/v1/albums/5ThYVevN9CTQ4jDXhNvTgR","id":"5ThYVevN9CTQ4jDXhNvTgR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27343997834402c504d49628017"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0243997834402c504d49628017"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485143997834402c504d49628017"}],"is_playable":true,"name":"Fireflies","release_date":"2025-07-04","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5ThYVevN9CTQ4jDXhNvTgR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04VLPuPMkGCDtN98wQbuob"},"href":"https://api.spotify.com/v1/artists/04VLPuPMkGCDtN98wQbuob","id":"04VLPuPMkGCDtN98wQbuob","name":"Sunset Chasers","type":"artist","uri":"spotify:artist:04VLPuPMkGCDtN98wQbuob"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UJZu7S4F22tWYZ2CdsJQr"},"href":"https://api.spotify.com/v1/artists/2UJZu7S4F22tWYZ2CdsJQr","id":"2UJZu7S4F22tWYZ2CdsJQr","name":"Bikini Bandits","type":"artist","uri":"spotify:artist:2UJZu7S4F22tWYZ2CdsJQr"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6KTaHMqi4D1QVSO5flHJNV"},"href":"https://api.spotify.com/v1/artists/6KTaHMqi4D1QVSO5flHJNV","id":"6KTaHMqi4D1QVSO5flHJNV","name":"Charlie Arthur","type":"artist","uri":"spotify:artist:6KTaHMqi4D1QVSO5flHJNV"}],"disc_number":1,"duration_ms":167368,"explicit":false,"external_ids":{"isrc":"NLYK92500309"},"external_urls":{"spotify":"https://open.spotify.com/track/7aXocHCk3ApGqfUp8ZEVzj"},"href":"https://api.spotify.com/v1/tracks/7aXocHCk3ApGqfUp8ZEVzj","id":"7aXocHCk3ApGqfUp8ZEVzj","is_local":false,"is_playable":true,"name":"Fireflies","track_number":1,"type":"track","uri":"spotify:track:7aXocHCk3ApGqfUp8ZEVzj"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7FCIr12pixiPP7tT5uctup"},"href":"https://api.spotify.com/v1/artists/7FCIr12pixiPP7tT5uctup","id":"7FCIr12pixiPP7tT5uctup","name":"Brad Vesper","type":"artist","uri":"spotify:artist:7FCIr12pixiPP7tT5uctup"}],"external_urls":{"spotify":"https://open.spotify.com/album/4xEdPSgx2PY3pis6nAA44Y"},"href":"https://api.spotify.com/v1/albums/4xEdPSgx2PY3pis6nAA44Y","id":"4xEdPSgx2PY3pis6nAA44Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f329a482a75ffc7ba139ba48"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f329a482a75ffc7ba139ba48"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f329a482a75ffc7ba139ba48"}],"is_playable":true,"name":"Azure Echo","release_date":"2025-10-24","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:4xEdPSgx2PY3pis6nAA44Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7FCIr12pixiPP7tT5uctup"},"href":"https://api.spotify.com/v1/artists/7FCIr12pixiPP7tT5uctup","id":"7FCIr12pixiPP7tT5uctup","name":"Brad Vesper","type":"artist","uri":"spotify:artist:7FCIr12pixiPP7tT5uctup"}],"disc_number":1,"duration_ms":72807,"explicit":false,"external_ids":{"isrc":"GXHUT2549328"},"external_urls":{"spotify":"https://open.spotify.com/track/1lp0dZMxA0u72vudSdxkh1"},"href":"https://api.spotify.com/v1/tracks/1lp0dZMxA0u72vudSdxkh1","id":"1lp0dZMxA0u72vudSdxkh1","is_local":false,"is_playable":true,"name":"Firefight","track_number":2,"type":"track","uri":"spotify:track:1lp0dZMxA0u72vudSdxkh1"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1GaXJlZmxpZXMlMjBOZXRza3kmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjQsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zbWZ6R1UybG80R0hKcHdpUFN4Q1drIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNtZnpHVTJsbzRHSEpwd2lQU3hDV2siLCJpZCI6IjNtZnpHVTJsbzRHSEpwd2lQU3hDV2siLCJuYW1lIjoiTm9pcmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M21mekdVMmxvNEdISnB3aVBTeENXayJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVTZk9DYnE5ektYZU1YMjJEUmZUMzAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81U2ZPQ2JxOXpLWGVNWDIyRFJmVDMwIiwiaWQiOiI1U2ZPQ2JxOXpLWGVNWDIyRFJmVDMwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzA0NDMwNTdhOGZmNmJmMjhmNTVlZg==", + "NGI4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA0NDMwNTdhOGZmNmJmMjhmNTVlZjRiOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDQ0MzA1N2E4ZmY2YmYyOGY1NWVmNGI4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZpcmVmbGllcyIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDktMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVTZk9DYnE5ektYZU1YMjJEUmZUMzAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zbWZ6R1UybG80R0hKcHdpUFN4Q1drIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNtZnpHVTJsbzRHSEpwd2lQU3hDV2siLCJpZCI6IjNtZnpHVTJsbzRHSEpwd2lQU3hDV2siLCJuYW1lIjoiTm9pcmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M21mekdVMmxvNEdISnB3aVBTeENXayJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDczNjUsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJERUg3NDIzMjA5ODUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNhNElXeFBkTHRVbjd2WG5SVVRiRXMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zYTRJV3hQZEx0VW43dlhuUlVUYkVzIiwiaWQiOiIzYTRJV3hQZEx0VW43dlhuUlVUYkVzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZpcmVmbGllcyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozYTRJV3hQZEx0VW43dlhuUlVUYkVzIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFIT040eEpBV0pOdVVwYjZHNjRiTnIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUhPTjR4SkFXSk51VXBiNkc2NGJOciIsImlkIjoiMUhPTjR4SkFXSk51VXBiNkc2NGJOciIsIm5hbWUiOiJTb290aGluZyBPYXNpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxSE9ONHhKQVdKTnVVcGI2RzY0Yk5yIn1dLCJleHRlcg==", + "bmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83a0gwTWlJd2piWVFkZkk4M2RaZE90In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN2tIME1pSXdqYllRZGZJODNkWmRPdCIsImlkIjoiN2tIME1pSXdqYllRZGZJODNkWmRPdCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkZWUyYjM2Y2FjNDAyZGNiYTg5N2Y5OWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZGVlMmIzNmNhYzQwMmRjYmE4OTdmOTljIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkZWUyYjM2Y2FjNDAyZGNiYTg5N2Y5OWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQnJlYXRoaW5nIEZvcmVzdCIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMTAtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdrSDBNaUl3amJZUWRmSTgzZFpkT3QifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xSE9ONHhKQVdKTnVVcGI2RzY0Yk5yIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFIT040eEpBV0pOdVVwYjZHNjRiTnIiLCJpZCI6IjFIT040eEpBV0pOdVVwYjZHNjRiTnIiLCJuYW1lIjoiU29vdGhpbmcgT2FzaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUhPTjR4SkFXSk51VXBiNkc2NGJOciJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxMzIyNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTDFZNjI0MDEwOTIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzcybjZWZVNWNHM2alhXM0ZoNXN5OHkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83Mm42VmVTVjRzNmpYVzNGaDVzeTh5IiwiaWQiOiI3Mm42VmVTVjRzNmpYVzNGaDVzeTh5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZpcmVmbGllcyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3Mm42VmVTVjRzNmpYVzNGaDVzeTh5In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoicw==", + "aW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA0VkxQdVBNa0dDRHROOTh3UWJ1b2IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDRWTFB1UE1rR0NEdE45OHdRYnVvYiIsImlkIjoiMDRWTFB1UE1rR0NEdE45OHdRYnVvYiIsIm5hbWUiOiJTdW5zZXQgQ2hhc2VycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNFZMUHVQTWtHQ0R0Tjk4d1FidW9iIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVSlp1N1M0RjIydFdZWjJDZHNKUXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVKWnU3UzRGMjJ0V1laMkNkc0pRciIsImlkIjoiMlVKWnU3UzRGMjJ0V1laMkNkc0pRciIsIm5hbWUiOiJCaWtpbmkgQmFuZGl0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVUpadTdTNEYyMnRXWVoyQ2RzSlFyIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZLVGFITXFpNEQxUVZTTzVmbEhKTlYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNktUYUhNcWk0RDFRVlNPNWZsSEpOViIsImlkIjoiNktUYUhNcWk0RDFRVlNPNWZsSEpOViIsIm5hbWUiOiJDaGFybGllIEFydGh1ciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2S1RhSE1xaTREMVFWU081ZmxISk5WIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVRoWVZldk45Q1RRNGpEWGhOdlRnUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVUaFlWZXZOOUNUUTRqRFhoTnZUZ1IiLCJpZCI6IjVUaFlWZXZOOUNUUTRqRFhoTnZUZ1IiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDM5OTc4MzQ0MDJjNTA0ZDQ5NjI4MDE3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQzOTk3ODM0NDAyYzUwNGQ0OTYyODAxNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDM5OTc4MzQ0MDJjNTA0ZDQ5NjI4MDE3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZpcmVmbGllcyIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMA==", + "Ny0wNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVRoWVZldk45Q1RRNGpEWGhOdlRnUiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA0VkxQdVBNa0dDRHROOTh3UWJ1b2IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDRWTFB1UE1rR0NEdE45OHdRYnVvYiIsImlkIjoiMDRWTFB1UE1rR0NEdE45OHdRYnVvYiIsIm5hbWUiOiJTdW5zZXQgQ2hhc2VycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNFZMUHVQTWtHQ0R0Tjk4d1FidW9iIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVSlp1N1M0RjIydFdZWjJDZHNKUXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVKWnU3UzRGMjJ0V1laMkNkc0pRciIsImlkIjoiMlVKWnU3UzRGMjJ0V1laMkNkc0pRciIsIm5hbWUiOiJCaWtpbmkgQmFuZGl0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVUpadTdTNEYyMnRXWVoyQ2RzSlFyIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZLVGFITXFpNEQxUVZTTzVmbEhKTlYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNktUYUhNcWk0RDFRVlNPNWZsSEpOViIsImlkIjoiNktUYUhNcWk0RDFRVlNPNWZsSEpOViIsIm5hbWUiOiJDaGFybGllIEFydGh1ciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2S1RhSE1xaTREMVFWU081ZmxISk5WIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2NzM2OCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MWUs5MjUwMDMwOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2FYb2NIQ2szQXBHcWZVcDhaRVZ6aiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdhWG9jSENrM0FwR3FmVXA4WkVWemoiLCJpZCI6IjdhWG9jSENrM0FwR3FmVXA4WkVWemoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmlyZWZsaWVzIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdhWG9jSENrM0FwR3FmVXA4WkVWemoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydA==", + "aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83RkNJcjEycGl4aVBQN3RUNXVjdHVwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdGQ0lyMTJwaXhpUFA3dFQ1dWN0dXAiLCJpZCI6IjdGQ0lyMTJwaXhpUFA3dFQ1dWN0dXAiLCJuYW1lIjoiQnJhZCBWZXNwZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0ZDSXIxMnBpeGlQUDd0VDV1Y3R1cCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzR4RWRQU2d4MlBZM3BpczZuQUE0NFkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80eEVkUFNneDJQWTNwaXM2bkFBNDRZIiwiaWQiOiI0eEVkUFNneDJQWTNwaXM2bkFBNDRZIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2YzMjlhNDgyYTc1ZmZjN2JhMTM5YmE0OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmMzI5YTQ4MmE3NWZmYzdiYTEzOWJhNDgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWYzMjlhNDgyYTc1ZmZjN2JhMTM5YmE0OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBenVyZSBFY2hvIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0xMC0yNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NHhFZFBTZ3gyUFkzcGlzNm5BQTQ0WSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdGQ0lyMTJwaXhpUFA3dFQ1dWN0dXAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0ZDSXIxMnBpeGlQUDd0VDV1Y3R1cCIsImlkIjoiN0ZDSXIxMnBpeGlQUDd0VDV1Y3R1cCIsIm5hbWUiOiJCcmFkIFZlc3BlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3RkNJcjEycGl4aVBQN3RUNXVjdHVwIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjcyODA3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR1hIVVQyNTQ5MzI4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xbHAwZFpNeA==", + "QTB1NzJ2dWRTZHhraDEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xbHAwZFpNeEEwdTcydnVkU2R4a2gxIiwiaWQiOiIxbHAwZFpNeEEwdTcydnVkU2R4a2gxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZpcmVmaWdodCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxbHAwZFpNeEEwdTcydnVkU2R4a2gxIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Fireflies+Netsky&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Water%20Etherwood&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GEUIa3Z0Qlivy3EcJm5RX"},"href":"https://api.spotify.com/v1/artists/3GEUIa3Z0Qlivy3EcJm5RX","id":"3GEUIa3Z0Qlivy3EcJm5RX","name":"Etherwood","type":"artist","uri":"spotify:artist:3GEUIa3Z0Qlivy3EcJm5RX"}],"external_urls":{"spotify":"https://open.spotify.com/album/55TBJxFWNk8t8SqBajqfDt"},"href":"https://api.spotify.com/v1/albums/55TBJxFWNk8t8SqBajqfDt","id":"55TBJxFWNk8t8SqBajqfDt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27325cb39a4fe13412e8a5dd2c4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0225cb39a4fe13412e8a5dd2c4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485125cb39a4fe13412e8a5dd2c4"}],"is_playable":true,"name":"Neon Dust","release_date":"2021-09-24","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:55TBJxFWNk8t8SqBajqfDt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GEUIa3Z0Qlivy3EcJm5RX"},"href":"https://api.spotify.com/v1/artists/3GEUIa3Z0Qlivy3EcJm5RX","id":"3GEUIa3Z0Qlivy3EcJm5RX","name":"Etherwood","type":"artist","uri":"spotify:artist:3GEUIa3Z0Qlivy3EcJm5RX"}],"disc_number":1,"duration_ms":242253,"explicit":false,"external_ids":{"isrc":"GBCJY2100267"},"external_urls":{"spotify":"https://open.spotify.com/track/3fUxV9VPA0f79OfzYFCJj4"},"href":"https://api.spotify.com/v1/tracks/3fUxV9VPA0f79OfzYFCJj4","id":"3fUxV9VPA0f79OfzYFCJj4","is_local":false,"is_playable":true,"name":"Water In Your Veins","track_number":9,"type":"track","uri":"spotify:track:3fUxV9VPA0f79OfzYFCJj4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GEUIa3Z0Qlivy3EcJm5RX"},"href":"https://api.spotify.com/v1/artists/3GEUIa3Z0Qlivy3EcJm5RX","id":"3GEUIa3Z0Qlivy3EcJm5RX","name":"Etherwood","type":"artist","uri":"spotify:artist:3GEUIa3Z0Qlivy3EcJm5RX"}],"external_urls":{"spotify":"https://open.spotify.com/album/7xXLjqDBPmbPwYLw0b3uL3"},"href":"https://api.spotify.com/v1/albums/7xXLjqDBPmbPwYLw0b3uL3","id":"7xXLjqDBPmbPwYLw0b3uL3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739037bb2d15cf03955ee292ec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029037bb2d15cf03955ee292ec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519037bb2d15cf03955ee292ec"}],"is_playable":true,"name":"Etherwood","release_date":"2013-11-04","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:7xXLjqDBPmbPwYLw0b3uL3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3GEUIa3Z0Qlivy3EcJm5RX"},"href":"https://api.spotify.com/v1/artists/3GEUIa3Z0Qlivy3EcJm5RX","id":"3GEUIa3Z0Qlivy3EcJm5RX","name":"Etherwood","type":"artist","uri":"spotify:artist:3GEUIa3Z0Qlivy3EcJm5RX"}],"disc_number":1,"duration_ms":261901,"explicit":false,"external_ids":{"isrc":"GBCJY1300190"},"external_urls":{"spotify":"https://open.spotify.com/track/53AOW4L7foxaTYekXTYwMf"},"href":"https://api.spotify.com/v1/tracks/53AOW4L7foxaTYekXTYwMf","id":"53AOW4L7foxaTYekXTYwMf","is_local":false,"is_playable":true,"name":"Begin By Letting Go","track_number":1,"type":"track","uri":"spotify:track:53AOW4L7foxaTYekXTYwMf"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VVLqeEqQQqTgT8YhfY9Z6"},"href":"https://api.spotify.com/v1/artists/3VVLqeEqQQqTgT8YhfY9Z6","id":"3VVLqeEqQQqTgT8YhfY9Z6","name":"Emmit Fenn","type":"artist","uri":"spotify:artist:3VVLqeEqQQqTgT8YhfY9Z6"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4iH5e8eV3hGNCzhFwr1cND"},"href":"https://api.spotify.com/v1/artists/4iH5e8eV3hGNCzhFwr1cND","id":"4iH5e8eV3hGNCzhFwr1cND","name":"LudoWic","type":"artist","uri":"spotify:artist:4iH5e8eV3hGNCzhFwr1cND"}],"external_urls":{"spotify":"https://open.spotify.com/album/2JCyPSqdYGxmP9ylw6n3JV"},"href":"https://api.spotify.com/v1/albums/2JCyPSqdYGxmP9ylw6n3JV","id":"2JCyPSqdYGxmP9ylw6n3JV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ac64214dcf15d2b2bf798280"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ac64214dcf15d2b2bf798280"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ac64214dcf15d2b2bf798280"}],"is_playable":true,"name":"Water","release_date":"2026-07-24","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2JCyPSqdYGxmP9ylw6n3JV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3VVLqeEqQQqTgT8YhfY9Z6"},"href":"https://api.spotify.com/v1/artists/3VVLqeEqQQqTgT8YhfY9Z6","id":"3VVLqeEqQQqTgT8YhfY9Z6","name":"Emmit Fenn","type":"artist","uri":"spotify:artist:3VVLqeEqQQqTgT8YhfY9Z6"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4iH5e8eV3hGNCzhFwr1cND"},"href":"https://api.spotify.com/v1/artists/4iH5e8eV3hGNCzhFwr1cND","id":"4iH5e8eV3hGNCzhFwr1cND","name":"LudoWic","type":"artist","uri":"spotify:artist:4iH5e8eV3hGNCzhFwr1cND"}],"disc_number":1,"duration_ms":230080,"explicit":false,"external_ids":{"isrc":"NL3M12603001"},"external_urls":{"spotify":"https://open.spotify.com/track/1vRCyFptmOOme4tzUAravo"},"href":"https://api.spotify.com/v1/tracks/1vRCyFptmOOme4tzUAravo","id":"1vRCyFptmOOme4tzUAravo","is_local":false,"is_playable":true,"name":"Water","track_number":1,"type":"track","uri":"spotify:track:1vRCyFptmOOme4tzUAravo"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3Q7czp0WDDlH4Z1Zt8yWKG"},"href":"https://api.spotify.com/v1/artists/3Q7czp0WDDlH4Z1Zt8yWKG","id":"3Q7czp0WDDlH4Z1Zt8yWKG","name":"Myles Dale","type":"artist","uri":"spotify:artist:3Q7czp0WDDlH4Z1Zt8yWKG"}],"external_urls":{"spotify":"https://open.spotify.com/album/49YyZgXdyepJ30xVYIqOiV"},"href":"https://api.spotify.com/v1/albums/49YyZgXdyepJ30xVYIqOiV","id":"49YyZgXdyepJ30xVYIqOiV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ceeb64b061fd6dccedbd6f06"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ceeb64b061fd6dccedbd6f06"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ceeb64b061fd6dccedbd6f06"}],"is_playable":true,"name":"Water","release_date":"2025-08-08","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:49YyZgXdyepJ30xVYIqOiV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3Q7czp0WDDlH4Z1Zt8yWKG"},"href":"https://api.spotify.com/v1/artists/3Q7czp0WDDlH4Z1Zt8yWKG","id":"3Q7czp0WDDlH4Z1Zt8yWKG","name":"Myles Dale","type":"artist","uri":"spotify:artist:3Q7czp0WDDlH4Z1Zt8yWKG"}],"disc_number":1,"duration_ms":145602,"explicit":false,"external_ids":{"isrc":"SE69Z2509850"},"external_urls":{"spotify":"https://open.spotify.com/track/1RYyyfkC5oiqpAubtkc6k2"},"href":"https://api.spotify.com/v1/tracks/1RYyyfkC5oiqpAubtkc6k2","id":"1RYyyfkC5oiqpAubtkc6k2","is_local":false,"is_playable":true,"name":"Water","track_number":1,"type":"track","uri":"spotify:track:1RYyyfkC5oiqpAubtkc6k2"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1XYXRlciUyMEV0aGVyd29vZCZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0dFVUlhM1owUWxpdnkzRWNKbTVSWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zR0VVSWEzWjBRbGl2eTNFY0ptNVJYIiwiaWQiOiIzR0VVSWEzWjBRbGl2eTNFY0ptNVJYIiwibmFtZSI6IkV0aGVyd29vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozR0VVSWEzWjBRbGl2eTNFY0ptNVJYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNTVUQkp4RldOazh0OFNxQmFqcWZEdCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzU1VEJKeEZXTms4dDhTcUJhanFmRHQiLCJpZCI6IjU1VEJKeEZXTms4dDhTcUJhanFmRHQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjVjYjM5YTRmZTEzNDEyZThhNQ==", + "ZGQyYzQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMjVjYjM5YTRmZTEzNDEyZThhNWRkMmM0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyNWNiMzlhNGZlMTM0MTJlOGE1ZGQyYzQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmVvbiBEdXN0IiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wOS0yNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjU1VEJKeEZXTms4dDhTcUJhanFmRHQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zR0VVSWEzWjBRbGl2eTNFY0ptNVJYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNHRVVJYTNaMFFsaXZ5M0VjSm01UlgiLCJpZCI6IjNHRVVJYTNaMFFsaXZ5M0VjSm01UlgiLCJuYW1lIjoiRXRoZXJ3b29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNHRVVJYTNaMFFsaXZ5M0VjSm01UlgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQyMjUzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JDSlkyMTAwMjY3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zZlV4VjlWUEEwZjc5T2Z6WUZDSmo0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM2ZVeFY5VlBBMGY3OU9mellGQ0pqNCIsImlkIjoiM2ZVeFY5VlBBMGY3OU9mellGQ0pqNCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYXRlciBJbiBZb3VyIFZlaW5zIiwidHJhY2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNmVXhWOVZQQTBmNzlPZnpZRkNKajQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0dFVUlhM1owUWxpdnkzRWNKbTVSWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zR0VVSWEzWjBRbGl2eTNFY0ptNVJYIiwiaWQiOiIzR0VVSWEzWjBRbGl2eTNFY0ptNVJYIiwibmFtZSI6IkV0aGVyd29vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozR0VVSWEzWjBRbGl2eTNFY0ptNQ==", + "UlgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83eFhManFEQlBtYlB3WUx3MGIzdUwzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3hYTGpxREJQbWJQd1lMdzBiM3VMMyIsImlkIjoiN3hYTGpxREJQbWJQd1lMdzBiM3VMMyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5MDM3YmIyZDE1Y2YwMzk1NWVlMjkyZWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTAzN2JiMmQxNWNmMDM5NTVlZTI5MmVjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5MDM3YmIyZDE1Y2YwMzk1NWVlMjkyZWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRXRoZXJ3b29kIiwicmVsZWFzZV9kYXRlIjoiMjAxMy0xMS0wNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjd4WExqcURCUG1iUHdZTHcwYjN1TDMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zR0VVSWEzWjBRbGl2eTNFY0ptNVJYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNHRVVJYTNaMFFsaXZ5M0VjSm01UlgiLCJpZCI6IjNHRVVJYTNaMFFsaXZ5M0VjSm01UlgiLCJuYW1lIjoiRXRoZXJ3b29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNHRVVJYTNaMFFsaXZ5M0VjSm01UlgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjYxOTAxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JDSlkxMzAwMTkwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81M0FPVzRMN2ZveGFUWWVrWFRZd01mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNTNBT1c0TDdmb3hhVFlla1hUWXdNZiIsImlkIjoiNTNBT1c0TDdmb3hhVFlla1hUWXdNZiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCZWdpbiBCeSBMZXR0aW5nIEdvIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjUzQU9XNEw3Zm94YVRZZWtYVFl3TWYifSx7ImFsYnVtIjp7ImFsYg==", + "dW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1ZWTHFlRXFRUXFUZ1Q4WWhmWTlaNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zVlZMcWVFcVFRcVRnVDhZaGZZOVo2IiwiaWQiOiIzVlZMcWVFcVFRcVRnVDhZaGZZOVo2IiwibmFtZSI6IkVtbWl0IEZlbm4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1ZWTHFlRXFRUXFUZ1Q4WWhmWTlaNiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80aUg1ZThlVjNoR05DemhGd3IxY05EIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRpSDVlOGVWM2hHTkN6aEZ3cjFjTkQiLCJpZCI6IjRpSDVlOGVWM2hHTkN6aEZ3cjFjTkQiLCJuYW1lIjoiTHVkb1dpYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0aUg1ZThlVjNoR05DemhGd3IxY05EIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkpDeVBTcWRZR3htUDl5bHc2bjNKViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJKQ3lQU3FkWUd4bVA5eWx3Nm4zSlYiLCJpZCI6IjJKQ3lQU3FkWUd4bVA5eWx3Nm4zSlYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYWM2NDIxNGRjZjE1ZDJiMmJmNzk4MjgwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmFjNjQyMTRkY2YxNWQyYjJiZjc5ODI4MCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYWM2NDIxNGRjZjE1ZDJiMmJmNzk4MjgwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhdGVyIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNy0yNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MkpDeVBTcWRZR3htUDl5bHc2bjNKViJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNWVkxxZUVxUVFxVGdUOFloZlk5WjYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM1ZWTHFlRXFRUXFUZ1Q4WWhmWQ==", + "OVo2IiwiaWQiOiIzVlZMcWVFcVFRcVRnVDhZaGZZOVo2IiwibmFtZSI6IkVtbWl0IEZlbm4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1ZWTHFlRXFRUXFUZ1Q4WWhmWTlaNiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80aUg1ZThlVjNoR05DemhGd3IxY05EIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRpSDVlOGVWM2hHTkN6aEZ3cjFjTkQiLCJpZCI6IjRpSDVlOGVWM2hHTkN6aEZ3cjFjTkQiLCJuYW1lIjoiTHVkb1dpYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0aUg1ZThlVjNoR05DemhGd3IxY05EIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzMDA4MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MM00xMjYwMzAwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXZSQ3lGcHRtT09tZTR0elVBcmF2byJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzF2UkN5RnB0bU9PbWU0dHpVQXJhdm8iLCJpZCI6IjF2UkN5RnB0bU9PbWU0dHpVQXJhdm8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2F0ZXIiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXZSQ3lGcHRtT09tZTR0elVBcmF2byJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1E3Y3pwMFdERGxINFoxWnQ4eVdLRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zUTdjenAwV0REbEg0WjFadDh5V0tHIiwiaWQiOiIzUTdjenAwV0REbEg0WjFadDh5V0tHIiwibmFtZSI6Ik15bGVzIERhbGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1E3Y3pwMFdERGxINFoxWnQ4eVdLRyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzQ5WXlaZ1hkeWVwSjMweFZZSXFPaVYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80OVl5WmdYZHllcEozMHhWWUlxT2lWIiwiaWQiOiI0OVl5WmdYZHllcEozMHhWWUlxT2lWIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2NlZWI2NGIwNjFmZDZkY2NlZGJkNg==", + "ZjA2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmNlZWI2NGIwNjFmZDZkY2NlZGJkNmYwNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxY2VlYjY0YjA2MWZkNmRjY2VkYmQ2ZjA2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhdGVyIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wOC0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NDlZeVpnWGR5ZXBKMzB4VllJcU9pViJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNRN2N6cDBXRERsSDRaMVp0OHlXS0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM1E3Y3pwMFdERGxINFoxWnQ4eVdLRyIsImlkIjoiM1E3Y3pwMFdERGxINFoxWnQ4eVdLRyIsIm5hbWUiOiJNeWxlcyBEYWxlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNRN2N6cDBXRERsSDRaMVp0OHlXS0cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQ1NjAyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiU0U2OVoyNTA5ODUwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xUll5eWZrQzVvaXFwQXVidGtjNmsyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVJZeXlma0M1b2lxcEF1YnRrYzZrMiIsImlkIjoiMVJZeXlma0M1b2lxcEF1YnRrYzZrMiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYXRlciIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxUll5eWZrQzVvaXFwQXVidGtjNmsyIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Water+Etherwood&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1pc3NpbmclMjIlMjBhcnRpc3QlM0ElMjJGbG93aWR1cyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1pc3NpbmclMjIlMjBhcnRpc3QlM0ElMjJGbG93aWR1cyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Missing%22+artist%3A%22Flowidus%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1Db2xvdXJzJTIwS2FzcmEmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjMsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd0UGhvRWU5VkQxbTM3VnFVaUM2aEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3RQaG9FZTlWRDFtMzdWcVVpQzZoQSIsImlkIjoiN3RQaG9FZTlWRDFtMzdWcVVpQzZoQSIsIm5hbWUiOiJJc2FhYyBSb3V4IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd0UGhvRWU5VkQxbTM3VnFVaUM2aEEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yNlBCTDFEMGx0Qlg3Y1hXbTNsdUltIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMjZQQkwxRDBsdEJYN2NYV20zbHVJbSIsImlkIjoiMjZQQkwxRDBsdEJYN2NYV20zbHVJbSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkYjJkMDJkMWFiYWZhY2Q0YjE0NjhkMmQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZGIyZDAyZDFhYmFmYWNkNGIxNDY4ZDJkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkYjJkMDJkMWFiYWZhY2Q0YjE0NjhkMmQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHJvdWJsZWQgV2F0ZXJzIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0xMS0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjI2UEJMMUQwbHRCWDdjWFdtM2x1SW0ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83dFBob0VlOVZEMW0zN1ZxVWlDNmhBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd0UGhvRWU5VkQxbTM3VnFVaUM2aEEiLCJpZCI6Ijd0UGhvRWU5VkQxbTM3VnFVaUM2aEEiLCJuYW1lIjoiSXNhYWMgUm91eCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3dFBob0VlOVZEMW0zN1ZxVWlDNmhBIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MjYwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkJFS0U1MjMwMDAzMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMmNpNHhKRVVWaTI1T3F5dTlmY1p5eSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJjaTR4SkVVVmkyNU9xeXU5ZmNaeXkiLCJpZCI6IjJjaTR4SkVVVmkyNU9xeXU5ZmNaeXkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29sb3VycyIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyY2k0eEpFVVZpMjVPcXl1OWZjWnl5In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80RWdjQ3JiWnpPQTBUZFNmekJiSXQxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRFZ2NDcmJaek9BMFRkU2Z6QmJJdDEiLCJpZCI6IjRFZ2NDcmJaek9BMFRkU2Z6QmJJdDEiLCJuYW1lIjoiU2VhbiBNYXRoZXdzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRFZ2NDcmJaek9BMFRkU2Z6QmJJdDEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xV1BOZjNpYXd0ZGFoODlOWWV3aXVsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVdQTmYzaWF3dGRhaDg5Tllld2l1bCIsImlkIjoiMVdQTmYzaWF3dGRhaDg5Tllld2l1bCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmNjRkNWE3NzQxNGRiNmIyZTJmMmJiODIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjY0ZDVhNzc0MTRkYjZiMmUyZjJiYjgyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmNjRkNWE3NzQxNGRiNmIyZTJmMmJiODIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29sb3VycyIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDEtMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFXUE5mM2lhd3RkYWg4OU5ZZXdpdWwifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80RWdjQ3JiWnpPQTBUZFNmekJiSXQxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRFZ2NDcmJaek9BMFRkU2Z6QmJJdDEiLCJpZCI6IjRFZ2NDcmJaek9BMFRkU2Z6QmJJdDEiLCJuYW1lIjoiU2VhbiBNYXRoZXdzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRFZ2NDcmJaek9BMFRkU2Z6QmJJdDEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA1NDM0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVUtSTVEyNTAwMDAyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yMmxOT01hcnQ2MVB4akVhYUNJSU5PIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMjJsTk9NYXJ0NjFQeGpFYWFDSUlOTyIsImlkIjoiMjJsTk9NYXJ0NjFQeGpFYWFDSUlOTyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDb2xvdXJzIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjIybE5PTWFydDYxUHhqRWFhQ0lJTk8ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVSbFRmZHFsU0dHQVNMeGhEQUhZdFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJsVGZkcWxTR0dBU0x4aERBSFl0UCIsImlkIjoiNVJsVGZkcWxTR0dBU0x4aERBSFl0UCIsIm5hbWUiOiJMWU1BIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVSbFRmZHFsU0dHQVNMeGhEQUhZdFAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEpvaHBobE94QlJNSHJZTGNXdklGTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wSm9ocGhsT3hCUk1IcllMY1d2SUZOIiwiaWQiOiIwSm9ocGhsT3hCUk1IcllMY1d2SUZOIiwibmFtZSI6IlBsZWlqIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBKb2hwaGxPeEJSTUhyWUxjV3ZJRk4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zR25MUHBEd1dZcElFZEJsZ2FFazRvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0duTFBwRHdXWXBJRWRCbGdhRWs0byIsImlkIjoiM0duTFBwRHdXWXBJRWRCbGdhRWs0byIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhZGQzYWQ5NmMzOGM0OTI1ODJlMTM5YTIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWRkM2FkOTZjMzhjNDkyNTgyZTEzOWEyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhZGQzYWQ5NmMzOGM0OTI1ODJlMTM5YTIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29sb3JzIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wNi0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0duTFBwRHdXWXBJRWRCbGdhRWs0byJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVSbFRmZHFsU0dHQVNMeGhEQUhZdFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJsVGZkcWxTR0dBU0x4aERBSFl0UCIsImlkIjoiNVJsVGZkcWxTR0dBU0x4aERBSFl0UCIsIm5hbWUiOiJMWU1BIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVSbFRmZHFsU0dHQVNMeGhEQUhZdFAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEpvaHBobE94QlJNSHJZTGNXdklGTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wSm9ocGhsT3hCUk1IcllMY1d2SUZOIiwiaWQiOiIwSm9ocGhsT3hCUk1IcllMY1d2SUZOIiwibmFtZSI6IlBsZWlqIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBKb2hwaGxPeEJSTUhyWUxjV3ZJRk4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA0MDU4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxTQjcyNTAwMzU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80V3FHNHlNQ1gyUWJqUWM4U0JhRHl0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNFdxRzR5TUNYMlFialFjOFNCYUR5dCIsImlkIjoiNFdxRzR5TUNYMlFialFjOFNCYUR5dCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDb2xvcnMiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFdxRzR5TUNYMlFialFjOFNCYUR5dCJ9XX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1Db2xvdXJzJTIwS2FzcmEmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjMsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd0UGhvRWU5VkQxbTM3VnFVaUM2aEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3RQaG9FZTlWRDFtMzdWcVVpQzZoQSIsImlkIjoiN3RQaG9FZTlWRDFtMzdWcVVpQzZoQSIsIm5hbWUiOiJJc2FhYyBSb3V4IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd0UGhvRWU5VkQxbTM3VnFVaUM2aEEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yNlBCTDFEMGx0Qlg3Y1hXbTNsdUltIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMjZQQkwxRDBsdEJYN2NYV20zbHVJbSIsImlkIjoiMjZQQkwxRDBsdEJYN2NYV20zbHVJbSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkYjJkMDJkMWFiYWZhY2Q0YjE0Ng==", + "OGQyZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkYjJkMDJkMWFiYWZhY2Q0YjE0NjhkMmQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWRiMmQwMmQxYWJhZmFjZDRiMTQ2OGQyZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUcm91YmxlZCBXYXRlcnMiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTExLTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MjZQQkwxRDBsdEJYN2NYV20zbHVJbSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd0UGhvRWU5VkQxbTM3VnFVaUM2aEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3RQaG9FZTlWRDFtMzdWcVVpQzZoQSIsImlkIjoiN3RQaG9FZTlWRDFtMzdWcVVpQzZoQSIsIm5hbWUiOiJJc2FhYyBSb3V4IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd0UGhvRWU5VkQxbTM3VnFVaUM2aEEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQyNjAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiQkVLRTUyMzAwMDMwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yY2k0eEpFVVZpMjVPcXl1OWZjWnl5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMmNpNHhKRVVWaTI1T3F5dTlmY1p5eSIsImlkIjoiMmNpNHhKRVVWaTI1T3F5dTlmY1p5eSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDb2xvdXJzIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJjaTR4SkVVVmkyNU9xeXU5ZmNaeXkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRFZ2NDcmJaek9BMFRkU2Z6QmJJdDEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEVnY0NyYlp6T0EwVGRTZnpCYkl0MSIsImlkIjoiNEVnY0NyYlp6T0EwVGRTZnpCYkl0MSIsIm5hbWUiOiJTZWFuIE1hdGhld3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEVnY0NyYlp6T0EwVGRTZnpCYkl0MQ==", + "In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMVdQTmYzaWF3dGRhaDg5Tllld2l1bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFXUE5mM2lhd3RkYWg4OU5ZZXdpdWwiLCJpZCI6IjFXUE5mM2lhd3RkYWg4OU5ZZXdpdWwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjY0ZDVhNzc0MTRkYjZiMmUyZjJiYjgyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY2NGQ1YTc3NDE0ZGI2YjJlMmYyYmI4MiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjY0ZDVhNzc0MTRkYjZiMmUyZjJiYjgyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbG91cnMiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTAxLTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxV1BOZjNpYXd0ZGFoODlOWWV3aXVsIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEVnY0NyYlp6T0EwVGRTZnpCYkl0MSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80RWdjQ3JiWnpPQTBUZFNmekJiSXQxIiwiaWQiOiI0RWdjQ3JiWnpPQTBUZFNmekJiSXQxIiwibmFtZSI6IlNlYW4gTWF0aGV3cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0RWdjQ3JiWnpPQTBUZFNmekJiSXQxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNTQzNCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVLUk1RMjUwMDAwMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMjJsTk9NYXJ0NjFQeGpFYWFDSUlOTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzIybE5PTWFydDYxUHhqRWFhQ0lJTk8iLCJpZCI6IjIybE5PTWFydDYxUHhqRWFhQ0lJTk8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29sb3VycyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyMmxOT01hcnQ2MVB4akVhYUNJSU5PIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZw==", + "bGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVSbFRmZHFsU0dHQVNMeGhEQUhZdFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJsVGZkcWxTR0dBU0x4aERBSFl0UCIsImlkIjoiNVJsVGZkcWxTR0dBU0x4aERBSFl0UCIsIm5hbWUiOiJMWU1BIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVSbFRmZHFsU0dHQVNMeGhEQUhZdFAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEpvaHBobE94QlJNSHJZTGNXdklGTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wSm9ocGhsT3hCUk1IcllMY1d2SUZOIiwiaWQiOiIwSm9ocGhsT3hCUk1IcllMY1d2SUZOIiwibmFtZSI6IlBsZWlqIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBKb2hwaGxPeEJSTUhyWUxjV3ZJRk4ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zR25MUHBEd1dZcElFZEJsZ2FFazRvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0duTFBwRHdXWXBJRWRCbGdhRWs0byIsImlkIjoiM0duTFBwRHdXWXBJRWRCbGdhRWs0byIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhZGQzYWQ5NmMzOGM0OTI1ODJlMTM5YTIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWRkM2FkOTZjMzhjNDkyNTgyZTEzOWEyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhZGQzYWQ5NmMzOGM0OTI1ODJlMTM5YTIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29sb3JzIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wNi0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0duTFBwRHdXWXBJRWRCbGdhRWs0byJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVSbFRmZHFsU0dHQVNMeGhEQUhZdFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVJsVGZkcWxTR0dBU0x4aERBSFl0UCIsImlkIjoiNVJsVGZkcWxTRw==", + "R0FTTHhoREFIWXRQIiwibmFtZSI6IkxZTUEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVJsVGZkcWxTR0dBU0x4aERBSFl0UCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wSm9ocGhsT3hCUk1IcllMY1d2SUZOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBKb2hwaGxPeEJSTUhyWUxjV3ZJRk4iLCJpZCI6IjBKb2hwaGxPeEJSTUhyWUxjV3ZJRk4iLCJuYW1lIjoiUGxlaWoiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEpvaHBobE94QlJNSHJZTGNXdklGTiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDQwNTgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFNCNzI1MDAzNTQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRXcUc0eU1DWDJRYmpRYzhTQmFEeXQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80V3FHNHlNQ1gyUWJqUWM4U0JhRHl0IiwiaWQiOiI0V3FHNHlNQ1gyUWJqUWM4U0JhRHl0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbG9ycyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0V3FHNHlNQ1gyUWJqUWM4U0JhRHl0In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Colours+Kasra&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Silver%20Mind%20vs%20Machine&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Silver%20Mind%20vs%20Machine&type=track","offset":0,"previous":null,"total":15,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"external_urls":{"spotify":"https://open.spotify.com/album/2qZd7lp0lLRjeFe0O9Ou6S"},"href":"https://api.spotify.com/v1/albums/2qZd7lp0lLRjeFe0O9Ou6S","id":"2qZd7lp0lLRjeFe0O9Ou6S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d2e39ea289f5cdc3a2c1ae13"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d2e39ea289f5cdc3a2c1ae13"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d2e39ea289f5cdc3a2c1ae13"}],"is_playable":true,"name":"Cuts & Bruises","release_date":"2023-02-17","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:2qZd7lp0lLRjeFe0O9Ou6S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"disc_number":1,"duration_ms":225613,"explicit":false,"external_ids":{"isrc":"GBUM72203107"},"external_urls":{"spotify":"https://open.spotify.com/track/7iqQK2bzlcVePuTbfw7zEd"},"href":"https://api.spotify.com/v1/tracks/7iqQK2bzlcVePuTbfw7zEd","id":"7iqQK2bzlcVePuTbfw7zEd","is_local":false,"is_playable":true,"name":"These Are The Days","track_number":4,"type":"track","uri":"spotify:track:7iqQK2bzlcVePuTbfw7zEd"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"external_urls":{"spotify":"https://open.spotify.com/album/2cP0n7ZCTCH4MDgirIWZmz"},"href":"https://api.spotify.com/v1/albums/2cP0n7ZCTCH4MDgirIWZmz","id":"2cP0n7ZCTCH4MDgirIWZmz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273640bbff0623abe983cec1fce"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02640bbff0623abe983cec1fce"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851640bbff0623abe983cec1fce"}],"is_playable":true,"name":"These Are The Days","release_date":"2022-06-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2cP0n7ZCTCH4MDgirIWZmz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"disc_number":1,"duration_ms":222297,"explicit":false,"external_ids":{"isrc":"GBUM72203107"},"external_urls":{"spotify":"https://open.spotify.com/track/6fyCVdU5lJT9ErO9QicFWC"},"href":"https://api.spotify.com/v1/tracks/6fyCVdU5lJT9ErO9QicFWC","id":"6fyCVdU5lJT9ErO9QicFWC","is_local":false,"is_playable":true,"name":"These Are The Days","track_number":1,"type":"track","uri":"spotify:track:6fyCVdU5lJT9ErO9QicFWC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/0qzmQzJH4ZDYMHvfN1Px15"},"href":"https://api.spotify.com/v1/albums/0qzmQzJH4ZDYMHvfN1Px15","id":"0qzmQzJH4ZDYMHvfN1Px15","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736ec43a073010b82164692d91"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026ec43a073010b82164692d91"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516ec43a073010b82164692d91"}],"is_playable":true,"name":"Dig Out Your Soul","release_date":"2008-10-06","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:0qzmQzJH4ZDYMHvfN1Px15"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":1,"duration_ms":299946,"explicit":false,"external_ids":{"isrc":"GBQCP0800005"},"external_urls":{"spotify":"https://open.spotify.com/track/72pRggptACNxeYG0vG3V3Q"},"href":"https://api.spotify.com/v1/tracks/72pRggptACNxeYG0vG3V3Q","id":"72pRggptACNxeYG0vG3V3Q","is_local":false,"is_playable":true,"name":"The Shock Of The Lightning","track_number":4,"type":"track","uri":"spotify:track:72pRggptACNxeYG0vG3V3Q"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"external_urls":{"spotify":"https://open.spotify.com/album/0HINCw0Pfo7xmGaMTXS51l"},"href":"https://api.spotify.com/v1/albums/0HINCw0Pfo7xmGaMTXS51l","id":"0HINCw0Pfo7xmGaMTXS51l","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fe85f3fd9cfa7f0b3f50d134"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fe85f3fd9cfa7f0b3f50d134"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fe85f3fd9cfa7f0b3f50d134"}],"is_playable":true,"name":"If You\u2019re Gonna Break My Heart","release_date":"2023-02-01","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:0HINCw0Pfo7xmGaMTXS51l"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"disc_number":1,"duration_ms":225613,"explicit":false,"external_ids":{"isrc":"GBUM72203107"},"external_urls":{"spotify":"https://open.spotify.com/track/6uLjRv19Z3I9L3ZeICmmNW"},"href":"https://api.spotify.com/v1/tracks/6uLjRv19Z3I9L3ZeICmmNW","id":"6uLjRv19Z3I9L3ZeICmmNW","is_local":false,"is_playable":true,"name":"These Are The Days","track_number":3,"type":"track","uri":"spotify:track:6uLjRv19Z3I9L3ZeICmmNW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"external_urls":{"spotify":"https://open.spotify.com/album/4WXV0n8Gk8TlNJHyXAhyWq"},"href":"https://api.spotify.com/v1/albums/4WXV0n8Gk8TlNJHyXAhyWq","id":"4WXV0n8Gk8TlNJHyXAhyWq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bf20c4c8cccad7dd2a321ff2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bf20c4c8cccad7dd2a321ff2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bf20c4c8cccad7dd2a321ff2"}],"is_playable":true,"name":"Love Will Get You There","release_date":"2022-10-13","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:4WXV0n8Gk8TlNJHyXAhyWq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"disc_number":1,"duration_ms":222297,"explicit":false,"external_ids":{"isrc":"GBUM72203107"},"external_urls":{"spotify":"https://open.spotify.com/track/1ZRqmyOwZAwBYgMcOcAlQh"},"href":"https://api.spotify.com/v1/tracks/1ZRqmyOwZAwBYgMcOcAlQh","id":"1ZRqmyOwZAwBYgMcOcAlQh","is_local":false,"is_playable":true,"name":"These Are The Days","track_number":2,"type":"track","uri":"spotify:track:1ZRqmyOwZAwBYgMcOcAlQh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3q7HBObVc0L8jNeTe5Gofh"},"href":"https://api.spotify.com/v1/artists/3q7HBObVc0L8jNeTe5Gofh","id":"3q7HBObVc0L8jNeTe5Gofh","name":"50 Cent","type":"artist","uri":"spotify:artist:3q7HBObVc0L8jNeTe5Gofh"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Sbt1eefEMSN33HqdhOM3g"},"href":"https://api.spotify.com/v1/albums/3Sbt1eefEMSN33HqdhOM3g","id":"3Sbt1eefEMSN33HqdhOM3g","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f4f2ccbae0c1905fcaf75b77"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f4f2ccbae0c1905fcaf75b77"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f4f2ccbae0c1905fcaf75b77"}],"is_playable":true,"name":"Best Of 50 Cent","release_date":"2017-03-31","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:3Sbt1eefEMSN33HqdhOM3g"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3q7HBObVc0L8jNeTe5Gofh"},"href":"https://api.spotify.com/v1/artists/3q7HBObVc0L8jNeTe5Gofh","id":"3q7HBObVc0L8jNeTe5Gofh","name":"50 Cent","type":"artist","uri":"spotify:artist:3q7HBObVc0L8jNeTe5Gofh"}],"disc_number":1,"duration_ms":237346,"explicit":true,"external_ids":{"isrc":"USUM70504263"},"external_urls":{"spotify":"https://open.spotify.com/track/0dZlON0G0od05O549PikZU"},"href":"https://api.spotify.com/v1/tracks/0dZlON0G0od05O549PikZU","id":"0dZlON0G0od05O549PikZU","is_local":false,"is_playable":true,"name":"Hustler's Ambition","track_number":2,"type":"track","uri":"spotify:track:0dZlON0G0od05O549PikZU"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2LpnVQdlKLHTJZSd68cARu"},"href":"https://api.spotify.com/v1/artists/2LpnVQdlKLHTJZSd68cARu","id":"2LpnVQdlKLHTJZSd68cARu","name":"Cael Lunor","type":"artist","uri":"spotify:artist:2LpnVQdlKLHTJZSd68cARu"}],"external_urls":{"spotify":"https://open.spotify.com/album/3KaPWa1a2R40H52NbqCcBN"},"href":"https://api.spotify.com/v1/albums/3KaPWa1a2R40H52NbqCcBN","id":"3KaPWa1a2R40H52NbqCcBN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27336fbaf0436f8ae91e18d4194"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0236fbaf0436f8ae91e18d4194"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485136fbaf0436f8ae91e18d4194"}],"is_playable":true,"name":"Silver Wakes","release_date":"2026-04-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3KaPWa1a2R40H52NbqCcBN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2LpnVQdlKLHTJZSd68cARu"},"href":"https://api.spotify.com/v1/artists/2LpnVQdlKLHTJZSd68cARu","id":"2LpnVQdlKLHTJZSd68cARu","name":"Cael Lunor","type":"artist","uri":"spotify:artist:2LpnVQdlKLHTJZSd68cARu"}],"disc_number":1,"duration_ms":144000,"explicit":false,"external_ids":{"isrc":"SE69Z2608902"},"external_urls":{"spotify":"https://open.spotify.com/track/0BIsSTUGjOy6vSPHDoRQaI"},"href":"https://api.spotify.com/v1/tracks/0BIsSTUGjOy6vSPHDoRQaI","id":"0BIsSTUGjOy6vSPHDoRQaI","is_local":false,"is_playable":true,"name":"Silver Wakes","track_number":1,"type":"track","uri":"spotify:track:0BIsSTUGjOy6vSPHDoRQaI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2a9nGgopYoBxxQMwXO7bvi"},"href":"https://api.spotify.com/v1/artists/2a9nGgopYoBxxQMwXO7bvi","id":"2a9nGgopYoBxxQMwXO7bvi","name":"Elysian Woods","type":"artist","uri":"spotify:artist:2a9nGgopYoBxxQMwXO7bvi"}],"external_urls":{"spotify":"https://open.spotify.com/album/1S69O9i42zGrY1orv8I8c9"},"href":"https://api.spotify.com/v1/albums/1S69O9i42zGrY1orv8I8c9","id":"1S69O9i42zGrY1orv8I8c9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a0a820a13052e137299b4859"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a0a820a13052e137299b4859"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a0a820a13052e137299b4859"}],"is_playable":true,"name":"Silverhollow","release_date":"2025-12-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1S69O9i42zGrY1orv8I8c9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2a9nGgopYoBxxQMwXO7bvi"},"href":"https://api.spotify.com/v1/artists/2a9nGgopYoBxxQMwXO7bvi","id":"2a9nGgopYoBxxQMwXO7bvi","name":"Elysian Woods","type":"artist","uri":"spotify:artist:2a9nGgopYoBxxQMwXO7bvi"}],"disc_number":1,"duration_ms":182559,"explicit":false,"external_ids":{"isrc":"SE69N2507449"},"external_urls":{"spotify":"https://open.spotify.com/track/0mJzBt2BjTqbzTHqQhqyHf"},"href":"https://api.spotify.com/v1/tracks/0mJzBt2BjTqbzTHqQhqyHf","id":"0mJzBt2BjTqbzTHqQhqyHf","is_local":false,"is_playable":true,"name":"Silverhollow","track_number":1,"type":"track","uri":"spotify:track:0mJzBt2BjTqbzTHqQhqyHf"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3SCI7sXHUZIeDKMWC5NT9C"},"href":"https://api.spotify.com/v1/artists/3SCI7sXHUZIeDKMWC5NT9C","id":"3SCI7sXHUZIeDKMWC5NT9C","name":"Armand Hammer","type":"artist","uri":"spotify:artist:3SCI7sXHUZIeDKMWC5NT9C"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0eVyjRhzZKke2KFYTcDkeu"},"href":"https://api.spotify.com/v1/artists/0eVyjRhzZKke2KFYTcDkeu","id":"0eVyjRhzZKke2KFYTcDkeu","name":"The Alchemist","type":"artist","uri":"spotify:artist:0eVyjRhzZKke2KFYTcDkeu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/39vtb2iiz3079nqfL5nfFc"},"href":"https://api.spotify.com/v1/artists/39vtb2iiz3079nqfL5nfFc","id":"39vtb2iiz3079nqfL5nfFc","name":"billy woods","type":"artist","uri":"spotify:artist:39vtb2iiz3079nqfL5nfFc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6F5n3bvrBgoyicdFT6L8IB"},"href":"https://api.spotify.com/v1/artists/6F5n3bvrBgoyicdFT6L8IB","id":"6F5n3bvrBgoyicdFT6L8IB","name":"E L U C I D","type":"artist","uri":"spotify:artist:6F5n3bvrBgoyicdFT6L8IB"}],"external_urls":{"spotify":"https://open.spotify.com/album/71RjBvPDD4U19ZeMermdUi"},"href":"https://api.spotify.com/v1/albums/71RjBvPDD4U19ZeMermdUi","id":"71RjBvPDD4U19ZeMermdUi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f94ada5696d156c286bddc6e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f94ada5696d156c286bddc6e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f94ada5696d156c286bddc6e"}],"is_playable":true,"name":"Mercy","release_date":"2025-11-07","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:71RjBvPDD4U19ZeMermdUi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3SCI7sXHUZIeDKMWC5NT9C"},"href":"https://api.spotify.com/v1/artists/3SCI7sXHUZIeDKMWC5NT9C","id":"3SCI7sXHUZIeDKMWC5NT9C","name":"Armand Hammer","type":"artist","uri":"spotify:artist:3SCI7sXHUZIeDKMWC5NT9C"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0eVyjRhzZKke2KFYTcDkeu"},"href":"https://api.spotify.com/v1/artists/0eVyjRhzZKke2KFYTcDkeu","id":"0eVyjRhzZKke2KFYTcDkeu","name":"The Alchemist","type":"artist","uri":"spotify:artist:0eVyjRhzZKke2KFYTcDkeu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/39vtb2iiz3079nqfL5nfFc"},"href":"https://api.spotify.com/v1/artists/39vtb2iiz3079nqfL5nfFc","id":"39vtb2iiz3079nqfL5nfFc","name":"billy woods","type":"artist","uri":"spotify:artist:39vtb2iiz3079nqfL5nfFc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6F5n3bvrBgoyicdFT6L8IB"},"href":"https://api.spotify.com/v1/artists/6F5n3bvrBgoyicdFT6L8IB","id":"6F5n3bvrBgoyicdFT6L8IB","name":"E L U C I D","type":"artist","uri":"spotify:artist:6F5n3bvrBgoyicdFT6L8IB"}],"disc_number":1,"duration_ms":132551,"explicit":false,"external_ids":{"isrc":"GXHAF2589305"},"external_urls":{"spotify":"https://open.spotify.com/track/580OSPk1SfbpixhkuVvcZW"},"href":"https://api.spotify.com/v1/tracks/580OSPk1SfbpixhkuVvcZW","id":"580OSPk1SfbpixhkuVvcZW","is_local":false,"is_playable":true,"name":"Peshawar","track_number":2,"type":"track","uri":"spotify:track:580OSPk1SfbpixhkuVvcZW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1xVieRWzu6IWbG1QWnP1qj"},"href":"https://api.spotify.com/v1/artists/1xVieRWzu6IWbG1QWnP1qj","id":"1xVieRWzu6IWbG1QWnP1qj","name":"ZMY","type":"artist","uri":"spotify:artist:1xVieRWzu6IWbG1QWnP1qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/5J6MDmPHRAiUROG32T8feF"},"href":"https://api.spotify.com/v1/albums/5J6MDmPHRAiUROG32T8feF","id":"5J6MDmPHRAiUROG32T8feF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cdce7963101f83feb771d761"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cdce7963101f83feb771d761"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cdce7963101f83feb771d761"}],"is_playable":true,"name":"Silver Lines, Pt. 3","release_date":"2024-12-27","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5J6MDmPHRAiUROG32T8feF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1xVieRWzu6IWbG1QWnP1qj"},"href":"https://api.spotify.com/v1/artists/1xVieRWzu6IWbG1QWnP1qj","id":"1xVieRWzu6IWbG1QWnP1qj","name":"ZMY","type":"artist","uri":"spotify:artist:1xVieRWzu6IWbG1QWnP1qj"}],"disc_number":1,"duration_ms":146756,"explicit":false,"external_ids":{"isrc":"DEH742441276"},"external_urls":{"spotify":"https://open.spotify.com/track/6yYP4beEaWg7I8PFQmDZFG"},"href":"https://api.spotify.com/v1/tracks/6yYP4beEaWg7I8PFQmDZFG","id":"6yYP4beEaWg7I8PFQmDZFG","is_local":false,"is_playable":true,"name":"Silver Lines, Pt. 3","track_number":1,"type":"track","uri":"spotify:track:6yYP4beEaWg7I8PFQmDZFG"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Silver%20Mind%20vs%20Machine&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Silver%20Mind%20vs%20Machine&type=track","offset":0,"previous":null,"total":15,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"external_urls":{"spotify":"https://open.spotify.com/album/2qZd7lp0lLRjeFe0O9Ou6S"},"href":"https://api.spotify.com/v1/albums/2qZd7lp0lLRjeFe0O9Ou6S","id":"2qZd7lp0lLRjeFe0O9Ou6S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d2e39ea289f5cdc3a2c1ae13"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d2e39ea289f5cdc3a2c1ae13"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d2e39ea289f5cdc3a2c1ae13"}],"is_playable":true,"name":"Cuts & Bruises","release_date":"2023-02-17","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:2qZd7lp0lLRjeFe0O9Ou6S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"disc_number":1,"duration_ms":225613,"explicit":false,"external_ids":{"isrc":"GBUM72203107"},"external_urls":{"spotify":"https://open.spotify.com/track/7iqQK2bzlcVePuTbfw7zEd"},"href":"https://api.spotify.com/v1/tracks/7iqQK2bzlcVePuTbfw7zEd","id":"7iqQK2bzlcVePuTbfw7zEd","is_local":false,"is_playable":true,"name":"These Are The Days","track_number":4,"type":"track","uri":"spotify:track:7iqQK2bzlcVePuTbfw7zEd"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"external_urls":{"spotify":"https://open.spotify.com/album/2cP0n7ZCTCH4MDgirIWZmz"},"href":"https://api.spotify.com/v1/albums/2cP0n7ZCTCH4MDgirIWZmz","id":"2cP0n7ZCTCH4MDgirIWZmz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273640bbff0623abe983cec1fce"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02640bbff0623abe983cec1fce"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851640bbff0623abe983cec1fce"}],"is_playable":true,"name":"These Are The Days","release_date":"2022-06-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2cP0n7ZCTCH4MDgirIWZmz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"disc_number":1,"duration_ms":222297,"explicit":false,"external_ids":{"isrc":"GBUM72203107"},"external_urls":{"spotify":"https://open.spotify.com/track/6fyCVdU5lJT9ErO9QicFWC"},"href":"https://api.spotify.com/v1/tracks/6fyCVdU5lJT9ErO9QicFWC","id":"6fyCVdU5lJT9ErO9QicFWC","is_local":false,"is_playable":true,"name":"These Are The Days","track_number":1,"type":"track","uri":"spotify:track:6fyCVdU5lJT9ErO9QicFWC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/0qzmQzJH4ZDYMHvfN1Px15"},"href":"https://api.spotify.com/v1/albums/0qzmQzJH4ZDYMHvfN1Px15","id":"0qzmQzJH4ZDYMHvfN1Px15","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736ec43a073010b82164692d91"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026ec43a073010b82164692d91"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516ec43a073010b82164692d91"}],"is_playable":true,"name":"Dig Out Your Soul","release_date":"2008-10-06","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:0qzmQzJH4ZDYMHvfN1Px15"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":1,"duration_ms":299946,"explicit":false,"external_ids":{"isrc":"GBQCP0800005"},"external_urls":{"spotify":"https://open.spotify.com/track/72pRggptACNxeYG0vG3V3Q"},"href":"https://api.spotify.com/v1/tracks/72pRggptACNxeYG0vG3V3Q","id":"72pRggptACNxeYG0vG3V3Q","is_local":false,"is_playable":true,"name":"The Shock Of The Lightning","track_number":4,"type":"track","uri":"spotify:track:72pRggptACNxeYG0vG3V3Q"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"external_urls":{"spotify":"https://open.spotify.com/album/0HINCw0Pfo7xmGaMTXS51l"},"href":"https://api.spotify.com/v1/albums/0HINCw0Pfo7xmGaMTXS51l","id":"0HINCw0Pfo7xmGaMTXS51l","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fe85f3fd9cfa7f0b3f50d134"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fe85f3fd9cfa7f0b3f50d134"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fe85f3fd9cfa7f0b3f50d134"}],"is_playable":true,"name":"If You\u2019re Gonna Break My Heart","release_date":"2023-02-01","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:0HINCw0Pfo7xmGaMTXS51l"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"disc_number":1,"duration_ms":225613,"explicit":false,"external_ids":{"isrc":"GBUM72203107"},"external_urls":{"spotify":"https://open.spotify.com/track/6uLjRv19Z3I9L3ZeICmmNW"},"href":"https://api.spotify.com/v1/tracks/6uLjRv19Z3I9L3ZeICmmNW","id":"6uLjRv19Z3I9L3ZeICmmNW","is_local":false,"is_playable":true,"name":"These Are The Days","track_number":3,"type":"track","uri":"spotify:track:6uLjRv19Z3I9L3ZeICmmNW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"external_urls":{"spotify":"https://open.spotify.com/album/4WXV0n8Gk8TlNJHyXAhyWq"},"href":"https://api.spotify.com/v1/albums/4WXV0n8Gk8TlNJHyXAhyWq","id":"4WXV0n8Gk8TlNJHyXAhyWq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bf20c4c8cccad7dd2a321ff2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bf20c4c8cccad7dd2a321ff2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bf20c4c8cccad7dd2a321ff2"}],"is_playable":true,"name":"Love Will Get You There","release_date":"2022-10-13","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:4WXV0n8Gk8TlNJHyXAhyWq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lyMYewq2SuTFIXgiv7OxH"},"href":"https://api.spotify.com/v1/artists/6lyMYewq2SuTFIXgiv7OxH","id":"6lyMYewq2SuTFIXgiv7OxH","name":"Inhaler","type":"artist","uri":"spotify:artist:6lyMYewq2SuTFIXgiv7OxH"}],"disc_number":1,"duration_ms":222297,"explicit":false,"external_ids":{"isrc":"GBUM72203107"},"external_urls":{"spotify":"https://open.spotify.com/track/1ZRqmyOwZAwBYgMcOcAlQh"},"href":"https://api.spotify.com/v1/tracks/1ZRqmyOwZAwBYgMcOcAlQh","id":"1ZRqmyOwZAwBYgMcOcAlQh","is_local":false,"is_playable":true,"name":"These Are The Days","track_number":2,"type":"track","uri":"spotify:track:1ZRqmyOwZAwBYgMcOcAlQh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3q7HBObVc0L8jNeTe5Gofh"},"href":"https://api.spotify.com/v1/artists/3q7HBObVc0L8jNeTe5Gofh","id":"3q7HBObVc0L8jNeTe5Gofh","name":"50 Cent","type":"artist","uri":"spotify:artist:3q7HBObVc0L8jNeTe5Gofh"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Sbt1eefEMSN33HqdhOM3g"},"href":"https://api.spotify.com/v1/albums/3Sbt1eefEMSN33HqdhOM3g","id":"3Sbt1eefEMSN33HqdhOM3g","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f4f2ccbae0c1905fcaf75b77"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f4f2ccbae0c1905fcaf75b77"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f4f2ccbae0c1905fcaf75b77"}],"is_playable":true,"name":"Best Of 50 Cent","release_date":"2017-03-31","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:3Sbt1eefEMSN33HqdhOM3g"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3q7HBObVc0L8jNeTe5Gofh"},"href":"https://api.spotify.com/v1/artists/3q7HBObVc0L8jNeTe5Gofh","id":"3q7HBObVc0L8jNeTe5Gofh","name":"50 Cent","type":"artist","uri":"spotify:artist:3q7HBObVc0L8jNeTe5Gofh"}],"disc_number":1,"duration_ms":237346,"explicit":true,"external_ids":{"isrc":"USUM70504263"},"external_urls":{"spotify":"https://open.spotify.com/track/0dZlON0G0od05O549PikZU"},"href":"https://api.spotify.com/v1/tracks/0dZlON0G0od05O549PikZU","id":"0dZlON0G0od05O549PikZU","is_local":false,"is_playable":true,"name":"Hustler's Ambition","track_number":2,"type":"track","uri":"spotify:track:0dZlON0G0od05O549PikZU"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2LpnVQdlKLHTJZSd68cARu"},"href":"https://api.spotify.com/v1/artists/2LpnVQdlKLHTJZSd68cARu","id":"2LpnVQdlKLHTJZSd68cARu","name":"Cael Lunor","type":"artist","uri":"spotify:artist:2LpnVQdlKLHTJZSd68cARu"}],"external_urls":{"spotify":"https://open.spotify.com/album/3KaPWa1a2R40H52NbqCcBN"},"href":"https://api.spotify.com/v1/albums/3KaPWa1a2R40H52NbqCcBN","id":"3KaPWa1a2R40H52NbqCcBN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27336fbaf0436f8ae91e18d4194"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0236fbaf0436f8ae91e18d4194"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485136fbaf0436f8ae91e18d4194"}],"is_playable":true,"name":"Silver Wakes","release_date":"2026-04-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3KaPWa1a2R40H52NbqCcBN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2LpnVQdlKLHTJZSd68cARu"},"href":"https://api.spotify.com/v1/artists/2LpnVQdlKLHTJZSd68cARu","id":"2LpnVQdlKLHTJZSd68cARu","name":"Cael Lunor","type":"artist","uri":"spotify:artist:2LpnVQdlKLHTJZSd68cARu"}],"disc_number":1,"duration_ms":144000,"explicit":false,"external_ids":{"isrc":"SE69Z2608902"},"external_urls":{"spotify":"https://open.spotify.com/track/0BIsSTUGjOy6vSPHDoRQaI"},"href":"https://api.spotify.com/v1/tracks/0BIsSTUGjOy6vSPHDoRQaI","id":"0BIsSTUGjOy6vSPHDoRQaI","is_local":false,"is_playable":true,"name":"Silver Wakes","track_number":1,"type":"track","uri":"spotify:track:0BIsSTUGjOy6vSPHDoRQaI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2a9nGgopYoBxxQMwXO7bvi"},"href":"https://api.spotify.com/v1/artists/2a9nGgopYoBxxQMwXO7bvi","id":"2a9nGgopYoBxxQMwXO7bvi","name":"Elysian Woods","type":"artist","uri":"spotify:artist:2a9nGgopYoBxxQMwXO7bvi"}],"external_urls":{"spotify":"https://open.spotify.com/album/1S69O9i42zGrY1orv8I8c9"},"href":"https://api.spotify.com/v1/albums/1S69O9i42zGrY1orv8I8c9","id":"1S69O9i42zGrY1orv8I8c9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a0a820a13052e137299b4859"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a0a820a13052e137299b4859"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a0a820a13052e137299b4859"}],"is_playable":true,"name":"Silverhollow","release_date":"2025-12-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1S69O9i42zGrY1orv8I8c9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2a9nGgopYoBxxQMwXO7bvi"},"href":"https://api.spotify.com/v1/artists/2a9nGgopYoBxxQMwXO7bvi","id":"2a9nGgopYoBxxQMwXO7bvi","name":"Elysian Woods","type":"artist","uri":"spotify:artist:2a9nGgopYoBxxQMwXO7bvi"}],"disc_number":1,"duration_ms":182559,"explicit":false,"external_ids":{"isrc":"SE69N2507449"},"external_urls":{"spotify":"https://open.spotify.com/track/0mJzBt2BjTqbzTHqQhqyHf"},"href":"https://api.spotify.com/v1/tracks/0mJzBt2BjTqbzTHqQhqyHf","id":"0mJzBt2BjTqbzTHqQhqyHf","is_local":false,"is_playable":true,"name":"Silverhollow","track_number":1,"type":"track","uri":"spotify:track:0mJzBt2BjTqbzTHqQhqyHf"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3SCI7sXHUZIeDKMWC5NT9C"},"href":"https://api.spotify.com/v1/artists/3SCI7sXHUZIeDKMWC5NT9C","id":"3SCI7sXHUZIeDKMWC5NT9C","name":"Armand Hammer","type":"artist","uri":"spotify:artist:3SCI7sXHUZIeDKMWC5NT9C"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0eVyjRhzZKke2KFYTcDkeu"},"href":"https://api.spotify.com/v1/artists/0eVyjRhzZKke2KFYTcDkeu","id":"0eVyjRhzZKke2KFYTcDkeu","name":"The Alchemist","type":"artist","uri":"spotify:artist:0eVyjRhzZKke2KFYTcDkeu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/39vtb2iiz3079nqfL5nfFc"},"href":"https://api.spotify.com/v1/artists/39vtb2iiz3079nqfL5nfFc","id":"39vtb2iiz3079nqfL5nfFc","name":"billy woods","type":"artist","uri":"spotify:artist:39vtb2iiz3079nqfL5nfFc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6F5n3bvrBgoyicdFT6L8IB"},"href":"https://api.spotify.com/v1/artists/6F5n3bvrBgoyicdFT6L8IB","id":"6F5n3bvrBgoyicdFT6L8IB","name":"E L U C I D","type":"artist","uri":"spotify:artist:6F5n3bvrBgoyicdFT6L8IB"}],"external_urls":{"spotify":"https://open.spotify.com/album/71RjBvPDD4U19ZeMermdUi"},"href":"https://api.spotify.com/v1/albums/71RjBvPDD4U19ZeMermdUi","id":"71RjBvPDD4U19ZeMermdUi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f94ada5696d156c286bddc6e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f94ada5696d156c286bddc6e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f94ada5696d156c286bddc6e"}],"is_playable":true,"name":"Mercy","release_date":"2025-11-07","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:71RjBvPDD4U19ZeMermdUi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3SCI7sXHUZIeDKMWC5NT9C"},"href":"https://api.spotify.com/v1/artists/3SCI7sXHUZIeDKMWC5NT9C","id":"3SCI7sXHUZIeDKMWC5NT9C","name":"Armand Hammer","type":"artist","uri":"spotify:artist:3SCI7sXHUZIeDKMWC5NT9C"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0eVyjRhzZKke2KFYTcDkeu"},"href":"https://api.spotify.com/v1/artists/0eVyjRhzZKke2KFYTcDkeu","id":"0eVyjRhzZKke2KFYTcDkeu","name":"The Alchemist","type":"artist","uri":"spotify:artist:0eVyjRhzZKke2KFYTcDkeu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/39vtb2iiz3079nqfL5nfFc"},"href":"https://api.spotify.com/v1/artists/39vtb2iiz3079nqfL5nfFc","id":"39vtb2iiz3079nqfL5nfFc","name":"billy woods","type":"artist","uri":"spotify:artist:39vtb2iiz3079nqfL5nfFc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6F5n3bvrBgoyicdFT6L8IB"},"href":"https://api.spotify.com/v1/artists/6F5n3bvrBgoyicdFT6L8IB","id":"6F5n3bvrBgoyicdFT6L8IB","name":"E L U C I D","type":"artist","uri":"spotify:artist:6F5n3bvrBgoyicdFT6L8IB"}],"disc_number":1,"duration_ms":132551,"explicit":false,"external_ids":{"isrc":"GXHAF2589305"},"external_urls":{"spotify":"https://open.spotify.com/track/580OSPk1SfbpixhkuVvcZW"},"href":"https://api.spotify.com/v1/tracks/580OSPk1SfbpixhkuVvcZW","id":"580OSPk1SfbpixhkuVvcZW","is_local":false,"is_playable":true,"name":"Peshawar","track_number":2,"type":"track","uri":"spotify:track:580OSPk1SfbpixhkuVvcZW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1xVieRWzu6IWbG1QWnP1qj"},"href":"https://api.spotify.com/v1/artists/1xVieRWzu6IWbG1QWnP1qj","id":"1xVieRWzu6IWbG1QWnP1qj","name":"ZMY","type":"artist","uri":"spotify:artist:1xVieRWzu6IWbG1QWnP1qj"}],"external_urls":{"spotify":"https://open.spotify.com/album/5J6MDmPHRAiUROG32T8feF"},"href":"https://api.spotify.com/v1/albums/5J6MDmPHRAiUROG32T8feF","id":"5J6MDmPHRAiUROG32T8feF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cdce7963101f83feb771d761"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cdce7963101f83feb771d761"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cdce7963101f83feb771d761"}],"is_playable":true,"name":"Silver Lines, Pt. 3","release_date":"2024-12-27","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5J6MDmPHRAiUROG32T8feF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1xVieRWzu6IWbG1QWnP1qj"},"href":"https://api.spotify.com/v1/artists/1xVieRWzu6IWbG1QWnP1qj","id":"1xVieRWzu6IWbG1QWnP1qj","name":"ZMY","type":"artist","uri":"spotify:artist:1xVieRWzu6IWbG1QWnP1qj"}],"disc_number":1,"duration_ms":146756,"explicit":false,"external_ids":{"isrc":"DEH742441276"},"external_urls":{"spotify":"https://open.spotify.com/track/6yYP4beEaWg7I8PFQmDZFG"},"href":"https://api.spotify.com/v1/tracks/6yYP4beEaWg7I8PFQmDZFG","id":"6yYP4beEaWg7I8PFQmDZFG","is_local":false,"is_playable":true,"name":"Silver Lines, Pt. 3","track_number":1,"type":"track","uri":"spotify:track:6yYP4beEaWg7I8PFQmDZFG"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Silver+Mind+vs+Machine&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Breathe%20S.P.Y&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":10,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Uv86qWpGTxf7fU7lG5X6F"},"href":"https://api.spotify.com/v1/albums/4Uv86qWpGTxf7fU7lG5X6F","id":"4Uv86qWpGTxf7fU7lG5X6F","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27325b055377757b3cdd6f26b78"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0225b055377757b3cdd6f26b78"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485125b055377757b3cdd6f26b78"}],"is_playable":true,"name":"The College Dropout","release_date":"2004-02-10","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4Uv86qWpGTxf7fU7lG5X6F"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3ipn9JLAPI5GUEo4y4jcoi"},"href":"https://api.spotify.com/v1/artists/3ipn9JLAPI5GUEo4y4jcoi","id":"3ipn9JLAPI5GUEo4y4jcoi","name":"Ludacris","type":"artist","uri":"spotify:artist:3ipn9JLAPI5GUEo4y4jcoi"}],"disc_number":1,"duration_ms":246933,"explicit":true,"external_ids":{"isrc":"USDJ20400021"},"external_urls":{"spotify":"https://open.spotify.com/track/4KFY4EEv9CN6ivrzD6vEvg"},"href":"https://api.spotify.com/v1/tracks/4KFY4EEv9CN6ivrzD6vEvg","id":"4KFY4EEv9CN6ivrzD6vEvg","is_local":false,"is_playable":true,"name":"Breathe In Breathe Out","track_number":13,"type":"track","uri":"spotify:track:4KFY4EEv9CN6ivrzD6vEvg"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/240wlM8vDrf6S4zCyzGj2W"},"href":"https://api.spotify.com/v1/artists/240wlM8vDrf6S4zCyzGj2W","id":"240wlM8vDrf6S4zCyzGj2W","name":"CamelPhat","type":"artist","uri":"spotify:artist:240wlM8vDrf6S4zCyzGj2W"},{"external_urls":{"spotify":"https://open.spotify.com/artist/532SqCIYmJyXEdEiCJLgYG"},"href":"https://api.spotify.com/v1/artists/532SqCIYmJyXEdEiCJLgYG","id":"532SqCIYmJyXEdEiCJLgYG","name":"Cristoph","type":"artist","uri":"spotify:artist:532SqCIYmJyXEdEiCJLgYG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0AkL5tzM3UsDlWak9E0OwH"},"href":"https://api.spotify.com/v1/artists/0AkL5tzM3UsDlWak9E0OwH","id":"0AkL5tzM3UsDlWak9E0OwH","name":"Jem Cooke","type":"artist","uri":"spotify:artist:0AkL5tzM3UsDlWak9E0OwH"}],"external_urls":{"spotify":"https://open.spotify.com/album/7c4A33WznTkdnqBEmLsWWF"},"href":"https://api.spotify.com/v1/albums/7c4A33WznTkdnqBEmLsWWF","id":"7c4A33WznTkdnqBEmLsWWF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27351026e598e9d2380d570d531"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0251026e598e9d2380d570d531"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485151026e598e9d2380d570d531"}],"is_playable":true,"name":"Breathe","release_date":"2018-11-16","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7c4A33WznTkdnqBEmLsWWF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/240wlM8vDrf6S4zCyzGj2W"},"href":"https://api.spotify.com/v1/artists/240wlM8vDrf6S4zCyzGj2W","id":"240wlM8vDrf6S4zCyzGj2W","name":"CamelPhat","type":"artist","uri":"spotify:artist:240wlM8vDrf6S4zCyzGj2W"},{"external_urls":{"spotify":"https://open.spotify.com/artist/532SqCIYmJyXEdEiCJLgYG"},"href":"https://api.spotify.com/v1/artists/532SqCIYmJyXEdEiCJLgYG","id":"532SqCIYmJyXEdEiCJLgYG","name":"Cristoph","type":"artist","uri":"spotify:artist:532SqCIYmJyXEdEiCJLgYG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0AkL5tzM3UsDlWak9E0OwH"},"href":"https://api.spotify.com/v1/artists/0AkL5tzM3UsDlWak9E0OwH","id":"0AkL5tzM3UsDlWak9E0OwH","name":"Jem Cooke","type":"artist","uri":"spotify:artist:0AkL5tzM3UsDlWak9E0OwH"}],"disc_number":1,"duration_ms":194232,"explicit":false,"external_ids":{"isrc":"GBCEN1800173"},"external_urls":{"spotify":"https://open.spotify.com/track/6TR0FGw4zhlGbQALN065AI"},"href":"https://api.spotify.com/v1/tracks/6TR0FGw4zhlGbQALN065AI","id":"6TR0FGw4zhlGbQALN065AI","is_local":false,"is_playable":true,"name":"Breathe","track_number":1,"type":"track","uri":"spotify:track:6TR0FGw4zhlGbQALN065AI"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/14o0qMFxqkJ4sTRcEoxXKf"},"href":"https://api.spotify.com/v1/albums/14o0qMFxqkJ4sTRcEoxXKf","id":"14o0qMFxqkJ4sTRcEoxXKf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273435c84d9c01619b70549708c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02435c84d9c01619b70549708c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851435c84d9c01619b70549708c"}],"is_playable":true,"name":"Playlist: Hip Hop","release_date":"2018-09-28","release_date_precision":"day","total_tracks":83,"type":"album","uri":"spotify:album:14o0qMFxqkJ4sTRcEoxXKf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0YWxKQj2Go9CGHCp77UOyy"},"href":"https://api.spotify.com/v1/artists/0YWxKQj2Go9CGHCp77UOyy","id":"0YWxKQj2Go9CGHCp77UOyy","name":"Fabolous","type":"artist","uri":"spotify:artist:0YWxKQj2Go9CGHCp77UOyy"}],"disc_number":1,"duration_ms":268960,"explicit":true,"external_ids":{"isrc":"USEE10413510"},"external_urls":{"spotify":"https://open.spotify.com/track/6imkXH0CdUtfLgZwYeUg7B"},"href":"https://api.spotify.com/v1/tracks/6imkXH0CdUtfLgZwYeUg7B","id":"6imkXH0CdUtfLgZwYeUg7B","is_local":false,"is_playable":true,"name":"Breathe","track_number":61,"type":"track","uri":"spotify:track:6imkXH0CdUtfLgZwYeUg7B"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5vBSrE1xujD2FXYRarbAXc"},"href":"https://api.spotify.com/v1/artists/5vBSrE1xujD2FXYRarbAXc","id":"5vBSrE1xujD2FXYRarbAXc","name":"Olly Alexander (Years & Years)","type":"artist","uri":"spotify:artist:5vBSrE1xujD2FXYRarbAXc"}],"external_urls":{"spotify":"https://open.spotify.com/album/2dzxJbiJKhQo2aqUrtjZP0"},"href":"https://api.spotify.com/v1/albums/2dzxJbiJKhQo2aqUrtjZP0","id":"2dzxJbiJKhQo2aqUrtjZP0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e98a30f3a9af0fb35771ae1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e98a30f3a9af0fb35771ae1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e98a30f3a9af0fb35771ae1"}],"is_playable":true,"name":"Take Shelter","release_date":"2014-01-01","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:2dzxJbiJKhQo2aqUrtjZP0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5vBSrE1xujD2FXYRarbAXc"},"href":"https://api.spotify.com/v1/artists/5vBSrE1xujD2FXYRarbAXc","id":"5vBSrE1xujD2FXYRarbAXc","name":"Olly Alexander (Years & Years)","type":"artist","uri":"spotify:artist:5vBSrE1xujD2FXYRarbAXc"}],"disc_number":1,"duration_ms":233228,"explicit":false,"external_ids":{"isrc":"GBUM71403184"},"external_urls":{"spotify":"https://open.spotify.com/track/267nfLfaSSDa9ivHncHynh"},"href":"https://api.spotify.com/v1/tracks/267nfLfaSSDa9ivHncHynh","id":"267nfLfaSSDa9ivHncHynh","is_local":false,"is_playable":true,"name":"Breathe","track_number":3,"type":"track","uri":"spotify:track:267nfLfaSSDa9ivHncHynh"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/01qbSocTDAe2DmKayS89A5"},"href":"https://api.spotify.com/v1/artists/01qbSocTDAe2DmKayS89A5","id":"01qbSocTDAe2DmKayS89A5","name":"pluko","type":"artist","uri":"spotify:artist:01qbSocTDAe2DmKayS89A5"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1gydLLHpbmraVz1LVZCW83"},"href":"https://api.spotify.com/v1/artists/1gydLLHpbmraVz1LVZCW83","id":"1gydLLHpbmraVz1LVZCW83","name":"pronouncedyea","type":"artist","uri":"spotify:artist:1gydLLHpbmraVz1LVZCW83"}],"external_urls":{"spotify":"https://open.spotify.com/album/55wW59sZIugEKDbbATNigk"},"href":"https://api.spotify.com/v1/albums/55wW59sZIugEKDbbATNigk","id":"55wW59sZIugEKDbbATNigk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27343481295a152a8039ab4da6d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0243481295a152a8039ab4da6d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485143481295a152a8039ab4da6d"}],"is_playable":true,"name":"Breath","release_date":"2016-09-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:55wW59sZIugEKDbbATNigk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/01qbSocTDAe2DmKayS89A5"},"href":"https://api.spotify.com/v1/artists/01qbSocTDAe2DmKayS89A5","id":"01qbSocTDAe2DmKayS89A5","name":"pluko","type":"artist","uri":"spotify:artist:01qbSocTDAe2DmKayS89A5"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1gydLLHpbmraVz1LVZCW83"},"href":"https://api.spotify.com/v1/artists/1gydLLHpbmraVz1LVZCW83","id":"1gydLLHpbmraVz1LVZCW83","name":"pronouncedyea","type":"artist","uri":"spotify:artist:1gydLLHpbmraVz1LVZCW83"}],"disc_number":1,"duration_ms":201008,"explicit":false,"external_ids":{"isrc":"CHB701600143"},"external_urls":{"spotify":"https://open.spotify.com/track/0lhcqwfMDuurywvxgELbPu"},"href":"https://api.spotify.com/v1/tracks/0lhcqwfMDuurywvxgELbPu","id":"0lhcqwfMDuurywvxgELbPu","is_local":false,"is_playable":true,"name":"Breath","track_number":1,"type":"track","uri":"spotify:track:0lhcqwfMDuurywvxgELbPu"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Pfp9mATiuKRzCMLhfs3tB"},"href":"https://api.spotify.com/v1/artists/2Pfp9mATiuKRzCMLhfs3tB","id":"2Pfp9mATiuKRzCMLhfs3tB","name":"R3SPAWN","type":"artist","uri":"spotify:artist:2Pfp9mATiuKRzCMLhfs3tB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2iJbhhJl7VJIhZPKMyvQ3b"},"href":"https://api.spotify.com/v1/albums/2iJbhhJl7VJIhZPKMyvQ3b","id":"2iJbhhJl7VJIhZPKMyvQ3b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737cd48b99979ef1209b127845"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027cd48b99979ef1209b127845"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517cd48b99979ef1209b127845"}],"is_playable":true,"name":"Breathe","release_date":"2026-02-27","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2iJbhhJl7VJIhZPKMyvQ3b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Pfp9mATiuKRzCMLhfs3tB"},"href":"https://api.spotify.com/v1/artists/2Pfp9mATiuKRzCMLhfs3tB","id":"2Pfp9mATiuKRzCMLhfs3tB","name":"R3SPAWN","type":"artist","uri":"spotify:artist:2Pfp9mATiuKRzCMLhfs3tB"}],"disc_number":1,"duration_ms":164475,"explicit":false,"external_ids":{"isrc":"GBKQU2604117"},"external_urls":{"spotify":"https://open.spotify.com/track/4vWcjY7X9vWD6FH0QPsrsp"},"href":"https://api.spotify.com/v1/tracks/4vWcjY7X9vWD6FH0QPsrsp","id":"4vWcjY7X9vWD6FH0QPsrsp","is_local":false,"is_playable":true,"name":"Breathe","track_number":1,"type":"track","uri":"spotify:track:4vWcjY7X9vWD6FH0QPsrsp"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LoM3lMauQ540MW9QiyIcR"},"href":"https://api.spotify.com/v1/artists/4LoM3lMauQ540MW9QiyIcR","id":"4LoM3lMauQ540MW9QiyIcR","name":"Anna Nalick","type":"artist","uri":"spotify:artist:4LoM3lMauQ540MW9QiyIcR"}],"external_urls":{"spotify":"https://open.spotify.com/album/30y0ZT845hhBoFNRKcZjT9"},"href":"https://api.spotify.com/v1/albums/30y0ZT845hhBoFNRKcZjT9","id":"30y0ZT845hhBoFNRKcZjT9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27377b56ca401a6c40c2079f43b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0277b56ca401a6c40c2079f43b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485177b56ca401a6c40c2079f43b"}],"is_playable":true,"name":"Wreck of the Day","release_date":"2005","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:30y0ZT845hhBoFNRKcZjT9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LoM3lMauQ540MW9QiyIcR"},"href":"https://api.spotify.com/v1/artists/4LoM3lMauQ540MW9QiyIcR","id":"4LoM3lMauQ540MW9QiyIcR","name":"Anna Nalick","type":"artist","uri":"spotify:artist:4LoM3lMauQ540MW9QiyIcR"}],"disc_number":1,"duration_ms":279826,"explicit":false,"external_ids":{"isrc":"USSM10412997"},"external_urls":{"spotify":"https://open.spotify.com/track/5auMzVHFr5Zfw6IbKarZ56"},"href":"https://api.spotify.com/v1/tracks/5auMzVHFr5Zfw6IbKarZ56","id":"5auMzVHFr5Zfw6IbKarZ56","is_local":false,"is_playable":true,"name":"Breathe (2 AM)","track_number":1,"type":"track","uri":"spotify:track:5auMzVHFr5Zfw6IbKarZ56"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/66CXWjxzNUsdJxJ2JdwvnR"},"href":"https://api.spotify.com/v1/artists/66CXWjxzNUsdJxJ2JdwvnR","id":"66CXWjxzNUsdJxJ2JdwvnR","name":"Ariana Grande","type":"artist","uri":"spotify:artist:66CXWjxzNUsdJxJ2JdwvnR"}],"external_urls":{"spotify":"https://open.spotify.com/album/3tx8gQqWbGwqIGZHqDNrGe"},"href":"https://api.spotify.com/v1/albums/3tx8gQqWbGwqIGZHqDNrGe","id":"3tx8gQqWbGwqIGZHqDNrGe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c3af0c2355c24ed7023cd394"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c3af0c2355c24ed7023cd394"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c3af0c2355c24ed7023cd394"}],"is_playable":true,"name":"Sweetener","release_date":"2018-08-17","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:3tx8gQqWbGwqIGZHqDNrGe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/66CXWjxzNUsdJxJ2JdwvnR"},"href":"https://api.spotify.com/v1/artists/66CXWjxzNUsdJxJ2JdwvnR","id":"66CXWjxzNUsdJxJ2JdwvnR","name":"Ariana Grande","type":"artist","uri":"spotify:artist:66CXWjxzNUsdJxJ2JdwvnR"}],"disc_number":1,"duration_ms":198160,"explicit":true,"external_ids":{"isrc":"USUM71808582"},"external_urls":{"spotify":"https://open.spotify.com/track/4OafepJy2teCjYJbvFE60J"},"href":"https://api.spotify.com/v1/tracks/4OafepJy2teCjYJbvFE60J","id":"4OafepJy2teCjYJbvFE60J","is_local":false,"is_playable":true,"name":"breathin","track_number":9,"type":"track","uri":"spotify:track:4OafepJy2teCjYJbvFE60J"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7ofG5BaSiQp8WeL4YCYDhF"},"href":"https://api.spotify.com/v1/artists/7ofG5BaSiQp8WeL4YCYDhF","id":"7ofG5BaSiQp8WeL4YCYDhF","name":"adore","type":"artist","uri":"spotify:artist:7ofG5BaSiQp8WeL4YCYDhF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2BjcWnk7C01aHhp59HqUED"},"href":"https://api.spotify.com/v1/artists/2BjcWnk7C01aHhp59HqUED","id":"2BjcWnk7C01aHhp59HqUED","name":"Sipper","type":"artist","uri":"spotify:artist:2BjcWnk7C01aHhp59HqUED"}],"external_urls":{"spotify":"https://open.spotify.com/album/2pYbGIlP2xK4xYLp21Rhud"},"href":"https://api.spotify.com/v1/albums/2pYbGIlP2xK4xYLp21Rhud","id":"2pYbGIlP2xK4xYLp21Rhud","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6192ec02525eb96671c6b3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6192ec02525eb96671c6b3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6192ec02525eb96671c6b3c"}],"is_playable":true,"name":"breathe u in","release_date":"2024-12-13","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2pYbGIlP2xK4xYLp21Rhud"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7ofG5BaSiQp8WeL4YCYDhF"},"href":"https://api.spotify.com/v1/artists/7ofG5BaSiQp8WeL4YCYDhF","id":"7ofG5BaSiQp8WeL4YCYDhF","name":"adore","type":"artist","uri":"spotify:artist:7ofG5BaSiQp8WeL4YCYDhF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2BjcWnk7C01aHhp59HqUED"},"href":"https://api.spotify.com/v1/artists/2BjcWnk7C01aHhp59HqUED","id":"2BjcWnk7C01aHhp59HqUED","name":"Sipper","type":"artist","uri":"spotify:artist:2BjcWnk7C01aHhp59HqUED"}],"disc_number":1,"duration_ms":163636,"explicit":true,"external_ids":{"isrc":"QZZ792414846"},"external_urls":{"spotify":"https://open.spotify.com/track/5dpiC00mcZNgT7ijBGC2PH"},"href":"https://api.spotify.com/v1/tracks/5dpiC00mcZNgT7ijBGC2PH","id":"5dpiC00mcZNgT7ijBGC2PH","is_local":false,"is_playable":true,"name":"breathe u in","track_number":1,"type":"track","uri":"spotify:track:5dpiC00mcZNgT7ijBGC2PH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6K8iDZW8jPaoiqSzFFebJA"},"href":"https://api.spotify.com/v1/albums/6K8iDZW8jPaoiqSzFFebJA","id":"6K8iDZW8jPaoiqSzFFebJA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b8f8d696810d68ce774e3a2f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b8f8d696810d68ce774e3a2f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b8f8d696810d68ce774e3a2f"}],"is_playable":true,"name":"Top Gun - Motion Picture Soundtrack (Special Expanded Edition)","release_date":"1999-01-01","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6K8iDZW8jPaoiqSzFFebJA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2aS6jYh7ysTL1ZUsHneNgM"},"href":"https://api.spotify.com/v1/artists/2aS6jYh7ysTL1ZUsHneNgM","id":"2aS6jYh7ysTL1ZUsHneNgM","name":"Berlin","type":"artist","uri":"spotify:artist:2aS6jYh7ysTL1ZUsHneNgM"}],"disc_number":1,"duration_ms":255733,"explicit":false,"external_ids":{"isrc":"USSM19801613"},"external_urls":{"spotify":"https://open.spotify.com/track/15MJ5NThPjj6xhPcts8MiY"},"href":"https://api.spotify.com/v1/tracks/15MJ5NThPjj6xhPcts8MiY","id":"15MJ5NThPjj6xhPcts8MiY","is_local":false,"is_playable":true,"name":"Take My Breath Away - Love Theme from \"Top Gun\"","track_number":5,"type":"track","uri":"spotify:track:15MJ5NThPjj6xhPcts8MiY"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1CcmVhdGhlJTIwUy5QLlkmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEwLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81SzRXNnJxQkZXRG5BTjZGUVVrUzZ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVLNFc2cnFCRldEbkFONkZRVWtTNngiLCJpZCI6IjVLNFc2cnFCRldEbkFONkZRVWtTNngiLCJuYW1lIjoiS2FueWUgV2VzdCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1SzRXNnJxQkZXRG5BTjZGUVVrUzZ4In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFV2ODZxV3BHVHhmN2ZVN2xHNVg2RiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRVdjg2cVdwR1R4ZjdmVTdsRzVYNkYiLCJpZCI6IjRVdjg2cVdwR1R4ZjdmVTdsRzVYNkYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjViMDU1Mzc3NzU3YjNjZGQ2ZjI2Yjc4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI1YjA1NTM3Nzc1N2IzY2RkNmYyNmI3OCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjViMDU1Mzc3NzU3YjNjZGQ2ZjI2Yjc4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBDb2xsZWdlIERyb3BvdXQiLCJyZWxlYXNlX2RhdGUiOiIyMDA0LTAyLTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFV2ODZxV3BHVHhmN2ZVN2xHNVg2RiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVLNFc2cnFCRldEbkFONkZRVWtTNngifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUs0VzZycUJGV0RuQU42RlFVa1M2eCIsImlkIjoiNUs0VzZycUJGV0RuQU42RlFVa1M2eCIsIm5hbWUiOiJLYW55ZSBXZXN0IiwidHlwZQ==", + "IjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NUs0VzZycUJGV0RuQU42RlFVa1M2eCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zaXBuOUpMQVBJNUdVRW80eTRqY29pIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNpcG45SkxBUEk1R1VFbzR5NGpjb2kiLCJpZCI6IjNpcG45SkxBUEk1R1VFbzR5NGpjb2kiLCJuYW1lIjoiTHVkYWNyaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2lwbjlKTEFQSTVHVUVvNHk0amNvaSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDY5MzMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTREoyMDQwMDAyMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNEtGWTRFRXY5Q042aXZyekQ2dkV2ZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRLRlk0RUV2OUNONml2cnpENnZFdmciLCJpZCI6IjRLRlk0RUV2OUNONml2cnpENnZFdmciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQnJlYXRoZSBJbiBCcmVhdGhlIE91dCIsInRyYWNrX251bWJlciI6MTMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NEtGWTRFRXY5Q042aXZyekQ2dkV2ZyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjQwd2xNOHZEcmY2UzR6Q3l6R2oyVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNDB3bE04dkRyZjZTNHpDeXpHajJXIiwiaWQiOiIyNDB3bE04dkRyZjZTNHpDeXpHajJXIiwibmFtZSI6IkNhbWVsUGhhdCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDB3bE04dkRyZjZTNHpDeXpHajJXIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzUzMlNxQ0lZbUp5WEVkRWlDSkxnWUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTMyU3FDSVltSnlYRWRFaUNKTGdZRyIsImlkIjoiNTMyU3FDSVltSnlYRWRFaUNKTGdZRyIsIm5hbWUiOiJDcmlzdG9waCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1MzJTcUNJWW1KeVhFZEVpQ0pMZ1lHIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBBaw==", + "TDV0ek0zVXNEbFdhazlFME93SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wQWtMNXR6TTNVc0RsV2FrOUUwT3dIIiwiaWQiOiIwQWtMNXR6TTNVc0RsV2FrOUUwT3dIIiwibmFtZSI6IkplbSBDb29rZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowQWtMNXR6TTNVc0RsV2FrOUUwT3dIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN2M0QTMzV3puVGtkbnFCRW1Mc1dXRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdjNEEzM1d6blRrZG5xQkVtTHNXV0YiLCJpZCI6IjdjNEEzM1d6blRrZG5xQkVtTHNXV0YiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTEwMjZlNTk4ZTlkMjM4MGQ1NzBkNTMxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUxMDI2ZTU5OGU5ZDIzODBkNTcwZDUzMSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTEwMjZlNTk4ZTlkMjM4MGQ1NzBkNTMxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJyZWF0aGUiLCJyZWxlYXNlX2RhdGUiOiIyMDE4LTExLTE2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3YzRBMzNXem5Ua2RucUJFbUxzV1dGIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjQwd2xNOHZEcmY2UzR6Q3l6R2oyVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNDB3bE04dkRyZjZTNHpDeXpHajJXIiwiaWQiOiIyNDB3bE04dkRyZjZTNHpDeXpHajJXIiwibmFtZSI6IkNhbWVsUGhhdCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDB3bE04dkRyZjZTNHpDeXpHajJXIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzUzMlNxQ0lZbUp5WEVkRWlDSkxnWUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTMyU3FDSVltSnlYRWRFaUNKTGdZRyIsImlkIjoiNTMyU3FDSVltSnlYRWRFaUNKTGdZRyIsIm5hbWUiOiJDcmlzdG9waCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdA==", + "OjUzMlNxQ0lZbUp5WEVkRWlDSkxnWUcifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEFrTDV0ek0zVXNEbFdhazlFME93SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wQWtMNXR6TTNVc0RsV2FrOUUwT3dIIiwiaWQiOiIwQWtMNXR6TTNVc0RsV2FrOUUwT3dIIiwibmFtZSI6IkplbSBDb29rZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowQWtMNXR6TTNVc0RsV2FrOUUwT3dIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NDIzMiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQ0VOMTgwMDE3MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNlRSMEZHdzR6aGxHYlFBTE4wNjVBSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZUUjBGR3c0emhsR2JRQUxOMDY1QUkiLCJpZCI6IjZUUjBGR3c0emhsR2JRQUxOMDY1QUkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQnJlYXRoZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2VFIwRkd3NHpobEdiUUFMTjA2NUFJIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzE0bzBxTUZ4cWtKNHNUUmNFb3hYS2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xNG8wcU1GeHFrSjRzVFJjRW94WEtmIiwiaWQiOiIxNG8wcU1GeHFrSjRzVFJjRW94WEtmIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQzNWM4NGQ5YzAxNjE5YjcwNTQ5NzA4YyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMA==", + "MjQzNWM4NGQ5YzAxNjE5YjcwNTQ5NzA4YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDM1Yzg0ZDljMDE2MTliNzA1NDk3MDhjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBsYXlsaXN0OiBIaXAgSG9wIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0wOS0yOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjgzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjE0bzBxTUZ4cWtKNHNUUmNFb3hYS2YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wWVd4S1FqMkdvOUNHSENwNzdVT3l5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBZV3hLUWoyR285Q0dIQ3A3N1VPeXkiLCJpZCI6IjBZV3hLUWoyR285Q0dIQ3A3N1VPeXkiLCJuYW1lIjoiRmFib2xvdXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFlXeEtRajJHbzlDR0hDcDc3VU95eSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjg5NjAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRUUxMDQxMzUxMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNmlta1hIMENkVXRmTGdad1llVWc3QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZpbWtYSDBDZFV0ZkxnWndZZVVnN0IiLCJpZCI6IjZpbWtYSDBDZFV0ZkxnWndZZVVnN0IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQnJlYXRoZSIsInRyYWNrX251bWJlciI6NjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Nmlta1hIMENkVXRmTGdad1llVWc3QiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXZCU3JFMXh1akQyRlhZUmFyYkFYYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81dkJTckUxeHVqRDJGWFlSYXJiQVhjIiwiaWQiOiI1dkJTckUxeHVqRDJGWFlSYXJiQVhjIiwibmFtZSI6Ik9sbHkgQWxleGFuZGVyIChZZWFycyAmIFllYXJzKSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1dkJTckUxeHVqRDJGWFlSYXJiQVhjIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidQ==", + "bS8yZHp4SmJpSktoUW8yYXFVcnRqWlAwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMmR6eEpiaUpLaFFvMmFxVXJ0alpQMCIsImlkIjoiMmR6eEpiaUpLaFFvMmFxVXJ0alpQMCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3ZTk4YTMwZjNhOWFmMGZiMzU3NzFhZTEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyN2U5OGEzMGYzYTlhZjBmYjM1NzcxYWUxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3ZTk4YTMwZjNhOWFmMGZiMzU3NzFhZTEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGFrZSBTaGVsdGVyIiwicmVsZWFzZV9kYXRlIjoiMjAxNC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MmR6eEpiaUpLaFFvMmFxVXJ0alpQMCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV2QlNyRTF4dWpEMkZYWVJhcmJBWGMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXZCU3JFMXh1akQyRlhZUmFyYkFYYyIsImlkIjoiNXZCU3JFMXh1akQyRlhZUmFyYkFYYyIsIm5hbWUiOiJPbGx5IEFsZXhhbmRlciAoWWVhcnMgJiBZZWFycykiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXZCU3JFMXh1akQyRlhZUmFyYkFYYyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzMyMjgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlVNNzE0MDMxODQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzI2N25mTGZhU1NEYTlpdkhuY0h5bmgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yNjduZkxmYVNTRGE5aXZIbmNIeW5oIiwiaWQiOiIyNjduZkxmYVNTRGE5aXZIbmNIeW5oIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJyZWF0aGUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MjY3bmZMZmFTU0RhOWl2SG5jSHluaCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdA==", + "aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wMXFiU29jVERBZTJEbUtheVM4OUE1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzAxcWJTb2NUREFlMkRtS2F5Uzg5QTUiLCJpZCI6IjAxcWJTb2NUREFlMkRtS2F5Uzg5QTUiLCJuYW1lIjoicGx1a28iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDFxYlNvY1REQWUyRG1LYXlTODlBNSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xZ3lkTExIcGJtcmFWejFMVlpDVzgzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFneWRMTEhwYm1yYVZ6MUxWWkNXODMiLCJpZCI6IjFneWRMTEhwYm1yYVZ6MUxWWkNXODMiLCJuYW1lIjoicHJvbm91bmNlZHllYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxZ3lkTExIcGJtcmFWejFMVlpDVzgzIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNTV3VzU5c1pJdWdFS0RiYkFUTmlnayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzU1d1c1OXNaSXVnRUtEYmJBVE5pZ2siLCJpZCI6IjU1d1c1OXNaSXVnRUtEYmJBVE5pZ2siLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDM0ODEyOTVhMTUyYTgwMzlhYjRkYTZkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQzNDgxMjk1YTE1MmE4MDM5YWI0ZGE2ZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDM0ODEyOTVhMTUyYTgwMzlhYjRkYTZkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJyZWF0aCIsInJlbGVhc2VfZGF0ZSI6IjIwMTYtMDktMzAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjU1d1c1OXNaSXVnRUtEYmJBVE5pZ2sifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wMXFiU29jVERBZTJEbUtheVM4OUE1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzAxcWJTb2NUREFlMkRtS2F5Uzg5QTUiLCJpZCI6IjAxcWJTb2NUREFlMkRtS2F5Uzg5QTUiLCJuYW1lIjoicGx1a28iLA==", + "InR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowMXFiU29jVERBZTJEbUtheVM4OUE1In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFneWRMTEhwYm1yYVZ6MUxWWkNXODMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMWd5ZExMSHBibXJhVnoxTFZaQ1c4MyIsImlkIjoiMWd5ZExMSHBibXJhVnoxTFZaQ1c4MyIsIm5hbWUiOiJwcm9ub3VuY2VkeWVhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFneWRMTEhwYm1yYVZ6MUxWWkNXODMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjAxMDA4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiQ0hCNzAxNjAwMTQzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wbGhjcXdmTUR1dXJ5d3Z4Z0VMYlB1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGxoY3F3Zk1EdXVyeXd2eGdFTGJQdSIsImlkIjoiMGxoY3F3Zk1EdXVyeXd2eGdFTGJQdSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCcmVhdGgiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGxoY3F3Zk1EdXVyeXd2eGdFTGJQdSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlBmcDltQVRpdUtSekNNTGhmczN0QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yUGZwOW1BVGl1S1J6Q01MaGZzM3RCIiwiaWQiOiIyUGZwOW1BVGl1S1J6Q01MaGZzM3RCIiwibmFtZSI6IlIzU1BBV04iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlBmcDltQVRpdUtSekNNTGhmczN0QiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJpSmJoaEpsN1ZKSWhaUEtNeXZRM2IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yaUpiaGhKbDdWSkloWlBLTXl2UTNiIiwiaWQiOiIyaUpiaGhKbDdWSkloWlBLTXl2UTNiIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzdjZDQ4Yjk5OTc5ZWYxMjA5YjEyNzg0NSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zYw==", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdjZDQ4Yjk5OTc5ZWYxMjA5YjEyNzg0NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2NkNDhiOTk5NzllZjEyMDliMTI3ODQ1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJyZWF0aGUiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTAyLTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyaUpiaGhKbDdWSkloWlBLTXl2UTNiIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlBmcDltQVRpdUtSekNNTGhmczN0QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yUGZwOW1BVGl1S1J6Q01MaGZzM3RCIiwiaWQiOiIyUGZwOW1BVGl1S1J6Q01MaGZzM3RCIiwibmFtZSI6IlIzU1BBV04iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlBmcDltQVRpdUtSekNNTGhmczN0QiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjQ0NzUsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQktRVTI2MDQxMTcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzR2V2NqWTdYOXZXRDZGSDBRUHNyc3AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80dldjalk3WDl2V0Q2RkgwUVBzcnNwIiwiaWQiOiI0dldjalk3WDl2V0Q2RkgwUVBzcnNwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJyZWF0aGUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NHZXY2pZN1g5dldENkZIMFFQc3JzcCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80TG9NM2xNYXVRNTQwTVc5UWl5SWNSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRMb00zbE1hdVE1NDBNVzlRaXlJY1IiLCJpZCI6IjRMb00zbE1hdVE1NDBNVzlRaXlJY1IiLCJuYW1lIjoiQW5uYSBOYWxpY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExvTTNsTWF1UTU0ME1XOVFpeUljUiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzMweQ==", + "MFpUODQ1aGhCb0ZOUktjWmpUOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzMweTBaVDg0NWhoQm9GTlJLY1pqVDkiLCJpZCI6IjMweTBaVDg0NWhoQm9GTlJLY1pqVDkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzdiNTZjYTQwMWE2YzQwYzIwNzlmNDNiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjc3YjU2Y2E0MDFhNmM0MGMyMDc5ZjQzYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzdiNTZjYTQwMWE2YzQwYzIwNzlmNDNiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldyZWNrIG9mIHRoZSBEYXkiLCJyZWxlYXNlX2RhdGUiOiIyMDA1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjMweTBaVDg0NWhoQm9GTlJLY1pqVDkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80TG9NM2xNYXVRNTQwTVc5UWl5SWNSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRMb00zbE1hdVE1NDBNVzlRaXlJY1IiLCJpZCI6IjRMb00zbE1hdVE1NDBNVzlRaXlJY1IiLCJuYW1lIjoiQW5uYSBOYWxpY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExvTTNsTWF1UTU0ME1XOVFpeUljUiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNzk4MjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTA0MTI5OTcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVhdU16VkhGcjVaZnc2SWJLYXJaNTYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81YXVNelZIRnI1WmZ3NkliS2FyWjU2IiwiaWQiOiI1YXVNelZIRnI1WmZ3NkliS2FyWjU2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJyZWF0aGUgKDIgQU0pIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVhdU16VkhGcjVaZnc2SWJLYXJaNTYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbg==", + "LnNwb3RpZnkuY29tL2FydGlzdC82NkNYV2p4ek5Vc2RKeEoySmR3dm5SIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY2Q1hXanh6TlVzZEp4SjJKZHd2blIiLCJpZCI6IjY2Q1hXanh6TlVzZEp4SjJKZHd2blIiLCJuYW1lIjoiQXJpYW5hIEdyYW5kZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2NkNYV2p4ek5Vc2RKeEoySmR3dm5SIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM3R4OGdRcVdiR3dxSUdaSHFETnJHZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzN0eDhnUXFXYkd3cUlHWkhxRE5yR2UiLCJpZCI6IjN0eDhnUXFXYkd3cUlHWkhxRE5yR2UiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzNhZjBjMjM1NWMyNGVkNzAyM2NkMzk0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmMzYWYwYzIzNTVjMjRlZDcwMjNjZDM5NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzNhZjBjMjM1NWMyNGVkNzAyM2NkMzk0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN3ZWV0ZW5lciIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDgtMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozdHg4Z1FxV2JHd3FJR1pIcUROckdlIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNjZDWFdqeHpOVXNkSnhKMkpkd3ZuUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82NkNYV2p4ek5Vc2RKeEoySmR3dm5SIiwiaWQiOiI2NkNYV2p4ek5Vc2RKeEoySmR3dm5SIiwibmFtZSI6IkFyaWFuYSBHcmFuZGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjZDWFdqeHpOVXNkSnhKMkpkd3ZuUiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTgxNjAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTgwODU4MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNE9hZmVwSnkydGVDallKYnZGRTYwSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeQ==", + "LmNvbS92MS90cmFja3MvNE9hZmVwSnkydGVDallKYnZGRTYwSiIsImlkIjoiNE9hZmVwSnkydGVDallKYnZGRTYwSiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJicmVhdGhpbiIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0T2FmZXBKeTJ0ZUNqWUpidkZFNjBKIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83b2ZHNUJhU2lRcDhXZUw0WUNZRGhGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdvZkc1QmFTaVFwOFdlTDRZQ1lEaEYiLCJpZCI6IjdvZkc1QmFTaVFwOFdlTDRZQ1lEaEYiLCJuYW1lIjoiYWRvcmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N29mRzVCYVNpUXA4V2VMNFlDWURoRiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQmpjV25rN0MwMWFIaHA1OUhxVUVEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJCamNXbms3QzAxYUhocDU5SHFVRUQiLCJpZCI6IjJCamNXbms3QzAxYUhocDU5SHFVRUQiLCJuYW1lIjoiU2lwcGVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJCamNXbms3QzAxYUhocDU5SHFVRUQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8ycFliR0lsUDJ4SzR4WUxwMjFSaHVkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMnBZYkdJbFAyeEs0eFlMcDIxUmh1ZCIsImlkIjoiMnBZYkdJbFAyeEs0eFlMcDIxUmh1ZCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiNjE5MmVjMDI1MjVlYjk2NjcxYzZiM2MifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjYxOTJlYzAyNTI1ZWI5NjY3MWM2YjNjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8v", + "aS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiNjE5MmVjMDI1MjVlYjk2NjcxYzZiM2MifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiYnJlYXRoZSB1IGluIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0xMi0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MnBZYkdJbFAyeEs0eFlMcDIxUmh1ZCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdvZkc1QmFTaVFwOFdlTDRZQ1lEaEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN29mRzVCYVNpUXA4V2VMNFlDWURoRiIsImlkIjoiN29mRzVCYVNpUXA4V2VMNFlDWURoRiIsIm5hbWUiOiJhZG9yZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3b2ZHNUJhU2lRcDhXZUw0WUNZRGhGIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJCamNXbms3QzAxYUhocDU5SHFVRUQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkJqY1duazdDMDFhSGhwNTlIcVVFRCIsImlkIjoiMkJqY1duazdDMDFhSGhwNTlIcVVFRCIsIm5hbWUiOiJTaXBwZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkJqY1duazdDMDFhSGhwNTlIcVVFRCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjM2MzYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaWjc5MjQxNDg0NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWRwaUMwMG1jWk5nVDdpakJHQzJQSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVkcGlDMDBtY1pOZ1Q3aWpCR0MyUEgiLCJpZCI6IjVkcGlDMDBtY1pOZ1Q3aWpCR0MyUEgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiYnJlYXRoZSB1IGluIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVkcGlDMDBtY1pOZ1Q3aWpCR0MyUEgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOQ==", + "T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82SzhpRFpXOGpQYW9pcVN6RkZlYkpBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNks4aURaVzhqUGFvaXFTekZGZWJKQSIsImlkIjoiNks4aURaVzhqUGFvaXFTekZGZWJKQSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiOGY4ZDY5NjgxMGQ2OGNlNzc0ZTNhMmYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjhmOGQ2OTY4MTBkNjhjZTc3NGUzYTJmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiOGY4ZDY5NjgxMGQ2OGNlNzc0ZTNhMmYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVG9wIEd1biAtIE1vdGlvbiBQaWN0dXJlIFNvdW5kdHJhY2sgKFNwZWNpYWwgRXhwYW5kZWQgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIxOTk5LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nks4aURaVzhqUGFvaXFTekZGZWJKQSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJhUzZqWWg3eXNUTDFaVXNIbmVOZ00ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmFTNmpZaDd5c1RMMVpVc0huZU5nTSIsImlkIjoiMmFTNmpZaDd5c1RMMVpVc0huZU5nTSIsIm5hbWUiOiJCZXJsaW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmFTNmpZaDd5c1RMMVpVc0huZU5nTSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTU3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTk4MDE2MTMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzE1TUo1TlRoUGpqNnhoUGN0czhNaVkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xNU1KNU5UaFBqajZ4aFBjdHM4TWlZIiwiaWQiOiIxNU1KNU5UaFBqajZ4aA==", + "UGN0czhNaVkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGFrZSBNeSBCcmVhdGggQXdheSAtIExvdmUgVGhlbWUgZnJvbSBcIlRvcCBHdW5cIiIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxNU1KNU5UaFBqajZ4aFBjdHM4TWlZIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Breathe+S.P.Y&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Awake%20Nu%3ALogic&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Awake%20Nu%3ALogic&type=track","offset":0,"previous":null,"total":17,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WX2uTcsvV5OnS0inACecP"},"href":"https://api.spotify.com/v1/artists/2WX2uTcsvV5OnS0inACecP","id":"2WX2uTcsvV5OnS0inACecP","name":"Birdy","type":"artist","uri":"spotify:artist:2WX2uTcsvV5OnS0inACecP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5pL8Q5xbDLEDE6JvYMXX9u"},"href":"https://api.spotify.com/v1/artists/5pL8Q5xbDLEDE6JvYMXX9u","id":"5pL8Q5xbDLEDE6JvYMXX9u","name":"Nu:Logic","type":"artist","uri":"spotify:artist:5pL8Q5xbDLEDE6JvYMXX9u"}],"external_urls":{"spotify":"https://open.spotify.com/album/3nL0jTQOLnirEaWC5ngDFX"},"href":"https://api.spotify.com/v1/albums/3nL0jTQOLnirEaWC5ngDFX","id":"3nL0jTQOLnirEaWC5ngDFX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733d5d9dd11a52a6f6168a20fc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023d5d9dd11a52a6f6168a20fc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513d5d9dd11a52a6f6168a20fc"}],"is_playable":true,"name":"Wings (Nu:Logic Remix; Edit)","release_date":"2023-11-03","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:3nL0jTQOLnirEaWC5ngDFX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WX2uTcsvV5OnS0inACecP"},"href":"https://api.spotify.com/v1/artists/2WX2uTcsvV5OnS0inACecP","id":"2WX2uTcsvV5OnS0inACecP","name":"Birdy","type":"artist","uri":"spotify:artist:2WX2uTcsvV5OnS0inACecP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5pL8Q5xbDLEDE6JvYMXX9u"},"href":"https://api.spotify.com/v1/artists/5pL8Q5xbDLEDE6JvYMXX9u","id":"5pL8Q5xbDLEDE6JvYMXX9u","name":"Nu:Logic","type":"artist","uri":"spotify:artist:5pL8Q5xbDLEDE6JvYMXX9u"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7pDBRy9uWy1zq5b0uXIABQ"},"href":"https://api.spotify.com/v1/artists/7pDBRy9uWy1zq5b0uXIABQ","id":"7pDBRy9uWy1zq5b0uXIABQ","name":"Nu:Tone","type":"artist","uri":"spotify:artist:7pDBRy9uWy1zq5b0uXIABQ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/01K8GEMGGxtrQ4xjDmNLPs"},"href":"https://api.spotify.com/v1/artists/01K8GEMGGxtrQ4xjDmNLPs","id":"01K8GEMGGxtrQ4xjDmNLPs","name":"Logistics","type":"artist","uri":"spotify:artist:01K8GEMGGxtrQ4xjDmNLPs"}],"disc_number":1,"duration_ms":383448,"explicit":false,"external_ids":{"isrc":"GBAHT2301067"},"external_urls":{"spotify":"https://open.spotify.com/track/0l9aqnEwV2h2m3EpLsJINW"},"href":"https://api.spotify.com/v1/tracks/0l9aqnEwV2h2m3EpLsJINW","id":"0l9aqnEwV2h2m3EpLsJINW","is_local":false,"is_playable":true,"name":"Wings - Nu:Logic Remix","track_number":2,"type":"track","uri":"spotify:track:0l9aqnEwV2h2m3EpLsJINW"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5pL8Q5xbDLEDE6JvYMXX9u"},"href":"https://api.spotify.com/v1/artists/5pL8Q5xbDLEDE6JvYMXX9u","id":"5pL8Q5xbDLEDE6JvYMXX9u","name":"Nu:Logic","type":"artist","uri":"spotify:artist:5pL8Q5xbDLEDE6JvYMXX9u"}],"external_urls":{"spotify":"https://open.spotify.com/album/3bTCZVtDGIqNinssbvTQqA"},"href":"https://api.spotify.com/v1/albums/3bTCZVtDGIqNinssbvTQqA","id":"3bTCZVtDGIqNinssbvTQqA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273702952e1b8b5ef0c4c0f8f54"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02702952e1b8b5ef0c4c0f8f54"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851702952e1b8b5ef0c4c0f8f54"}],"is_playable":true,"name":"Somewhere Between The Light","release_date":"2017-06-30","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3bTCZVtDGIqNinssbvTQqA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5pL8Q5xbDLEDE6JvYMXX9u"},"href":"https://api.spotify.com/v1/artists/5pL8Q5xbDLEDE6JvYMXX9u","id":"5pL8Q5xbDLEDE6JvYMXX9u","name":"Nu:Logic","type":"artist","uri":"spotify:artist:5pL8Q5xbDLEDE6JvYMXX9u"}],"disc_number":1,"duration_ms":249547,"explicit":false,"external_ids":{"isrc":"GBCJY1700084"},"external_urls":{"spotify":"https://open.spotify.com/track/0MdsyLtr9uGXiVmUGmqsXt"},"href":"https://api.spotify.com/v1/tracks/0MdsyLtr9uGXiVmUGmqsXt","id":"0MdsyLtr9uGXiVmUGmqsXt","is_local":false,"is_playable":true,"name":"Nova","track_number":7,"type":"track","uri":"spotify:track:0MdsyLtr9uGXiVmUGmqsXt"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3cmexxbeYMiLNj9VEmB451"},"href":"https://api.spotify.com/v1/artists/3cmexxbeYMiLNj9VEmB451","id":"3cmexxbeYMiLNj9VEmB451","name":"Euology","type":"artist","uri":"spotify:artist:3cmexxbeYMiLNj9VEmB451"}],"external_urls":{"spotify":"https://open.spotify.com/album/5IWkP59iw83ldzWoklY2QA"},"href":"https://api.spotify.com/v1/albums/5IWkP59iw83ldzWoklY2QA","id":"5IWkP59iw83ldzWoklY2QA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27382a5fcf562d64870780dd7d2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0282a5fcf562d64870780dd7d2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485182a5fcf562d64870780dd7d2"}],"is_playable":true,"name":"Logic","release_date":"2024-06-14","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5IWkP59iw83ldzWoklY2QA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3cmexxbeYMiLNj9VEmB451"},"href":"https://api.spotify.com/v1/artists/3cmexxbeYMiLNj9VEmB451","id":"3cmexxbeYMiLNj9VEmB451","name":"Euology","type":"artist","uri":"spotify:artist:3cmexxbeYMiLNj9VEmB451"}],"disc_number":1,"duration_ms":221538,"explicit":false,"external_ids":{"isrc":"QZMEN2498748"},"external_urls":{"spotify":"https://open.spotify.com/track/4egwGq65exfjAIb1UKPGMw"},"href":"https://api.spotify.com/v1/tracks/4egwGq65exfjAIb1UKPGMw","id":"4egwGq65exfjAIb1UKPGMw","is_local":false,"is_playable":true,"name":"Logic","track_number":1,"type":"track","uri":"spotify:track:4egwGq65exfjAIb1UKPGMw"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5VKvqCyBxqbaXUp8eK0aUy"},"href":"https://api.spotify.com/v1/artists/5VKvqCyBxqbaXUp8eK0aUy","id":"5VKvqCyBxqbaXUp8eK0aUy","name":"Scrim","type":"artist","uri":"spotify:artist:5VKvqCyBxqbaXUp8eK0aUy"}],"external_urls":{"spotify":"https://open.spotify.com/album/77a2uhKK8cLvTS0FMyutU7"},"href":"https://api.spotify.com/v1/albums/77a2uhKK8cLvTS0FMyutU7","id":"77a2uhKK8cLvTS0FMyutU7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735d56193825a898f740cecdf6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025d56193825a898f740cecdf6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515d56193825a898f740cecdf6"}],"is_playable":true,"name":"runaway","release_date":"2026-05-29","release_date_precision":"day","total_tracks":59,"type":"album","uri":"spotify:album:77a2uhKK8cLvTS0FMyutU7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5VKvqCyBxqbaXUp8eK0aUy"},"href":"https://api.spotify.com/v1/artists/5VKvqCyBxqbaXUp8eK0aUy","id":"5VKvqCyBxqbaXUp8eK0aUy","name":"Scrim","type":"artist","uri":"spotify:artist:5VKvqCyBxqbaXUp8eK0aUy"}],"disc_number":1,"duration_ms":116342,"explicit":true,"external_ids":{"isrc":"QZAPK2000806"},"external_urls":{"spotify":"https://open.spotify.com/track/36et2SK8SqeSRdZESNf69C"},"href":"https://api.spotify.com/v1/tracks/36et2SK8SqeSRdZESNf69C","id":"36et2SK8SqeSRdZESNf69C","is_local":false,"is_playable":true,"name":"wojak","track_number":42,"type":"track","uri":"spotify:track:36et2SK8SqeSRdZESNf69C"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2mOAog2mKiF5RaOV2eAinZ"},"href":"https://api.spotify.com/v1/artists/2mOAog2mKiF5RaOV2eAinZ","id":"2mOAog2mKiF5RaOV2eAinZ","name":"Logicsoul","type":"artist","uri":"spotify:artist:2mOAog2mKiF5RaOV2eAinZ"}],"external_urls":{"spotify":"https://open.spotify.com/album/4h1w9HtGlfosMNZo4d2opI"},"href":"https://api.spotify.com/v1/albums/4h1w9HtGlfosMNZo4d2opI","id":"4h1w9HtGlfosMNZo4d2opI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273feb636f12617ef70c4d3616f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02feb636f12617ef70c4d3616f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851feb636f12617ef70c4d3616f"}],"is_playable":true,"name":"Nu Town Express EP","release_date":"2018-10-27","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:4h1w9HtGlfosMNZo4d2opI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2mOAog2mKiF5RaOV2eAinZ"},"href":"https://api.spotify.com/v1/artists/2mOAog2mKiF5RaOV2eAinZ","id":"2mOAog2mKiF5RaOV2eAinZ","name":"Logicsoul","type":"artist","uri":"spotify:artist:2mOAog2mKiF5RaOV2eAinZ"}],"disc_number":1,"duration_ms":383686,"explicit":false,"external_ids":{"isrc":"USLZJ1877661"},"external_urls":{"spotify":"https://open.spotify.com/track/1NurhhCC756Df4rpZwAH0O"},"href":"https://api.spotify.com/v1/tracks/1NurhhCC756Df4rpZwAH0O","id":"1NurhhCC756Df4rpZwAH0O","is_local":false,"is_playable":true,"name":"The Forest Awakes - Original Mix","track_number":4,"type":"track","uri":"spotify:track:1NurhhCC756Df4rpZwAH0O"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4np3dM8CSvjKhToa0Epfs9"},"href":"https://api.spotify.com/v1/artists/4np3dM8CSvjKhToa0Epfs9","id":"4np3dM8CSvjKhToa0Epfs9","name":"Koyo","type":"artist","uri":"spotify:artist:4np3dM8CSvjKhToa0Epfs9"}],"external_urls":{"spotify":"https://open.spotify.com/album/15At5fBHrNsaLtWA7dNWIA"},"href":"https://api.spotify.com/v1/albums/15At5fBHrNsaLtWA7dNWIA","id":"15At5fBHrNsaLtWA7dNWIA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b361501a6665814b30650d08"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b361501a6665814b30650d08"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b361501a6665814b30650d08"}],"is_playable":true,"name":"Would You Miss It?","release_date":"2023-09-29","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:15At5fBHrNsaLtWA7dNWIA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4np3dM8CSvjKhToa0Epfs9"},"href":"https://api.spotify.com/v1/artists/4np3dM8CSvjKhToa0Epfs9","id":"4np3dM8CSvjKhToa0Epfs9","name":"Koyo","type":"artist","uri":"spotify:artist:4np3dM8CSvjKhToa0Epfs9"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5l93whap9W6kk2wl9spGm2"},"href":"https://api.spotify.com/v1/artists/5l93whap9W6kk2wl9spGm2","id":"5l93whap9W6kk2wl9spGm2","name":"Vinnie Caruana","type":"artist","uri":"spotify:artist:5l93whap9W6kk2wl9spGm2"}],"disc_number":1,"duration_ms":187623,"explicit":false,"external_ids":{"isrc":"USSTT2300166"},"external_urls":{"spotify":"https://open.spotify.com/track/0jBGl4JIIWeyIIFLrxuq8l"},"href":"https://api.spotify.com/v1/tracks/0jBGl4JIIWeyIIFLrxuq8l","id":"0jBGl4JIIWeyIIFLrxuq8l","is_local":false,"is_playable":true,"name":"What's Left To Say","track_number":9,"type":"track","uri":"spotify:track:0jBGl4JIIWeyIIFLrxuq8l"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0V9n6LOQxTf3kNl4pZLZ05"},"href":"https://api.spotify.com/v1/artists/0V9n6LOQxTf3kNl4pZLZ05","id":"0V9n6LOQxTf3kNl4pZLZ05","name":"Lana Ayres","type":"artist","uri":"spotify:artist:0V9n6LOQxTf3kNl4pZLZ05"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QU2fMnqhYtwmLAiBgLLlG"},"href":"https://api.spotify.com/v1/albums/3QU2fMnqhYtwmLAiBgLLlG","id":"3QU2fMnqhYtwmLAiBgLLlG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738ee4aa02384234a56c417f31"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028ee4aa02384234a56c417f31"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518ee4aa02384234a56c417f31"}],"is_playable":true,"name":"Painkiller Rhymes","release_date":"2021-08-25","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:3QU2fMnqhYtwmLAiBgLLlG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0V9n6LOQxTf3kNl4pZLZ05"},"href":"https://api.spotify.com/v1/artists/0V9n6LOQxTf3kNl4pZLZ05","id":"0V9n6LOQxTf3kNl4pZLZ05","name":"Lana Ayres","type":"artist","uri":"spotify:artist:0V9n6LOQxTf3kNl4pZLZ05"}],"disc_number":1,"duration_ms":223225,"explicit":true,"external_ids":{"isrc":"QZ8252101377"},"external_urls":{"spotify":"https://open.spotify.com/track/4Qck5rNKDPHUTwZ9a1AEl5"},"href":"https://api.spotify.com/v1/tracks/4Qck5rNKDPHUTwZ9a1AEl5","id":"4Qck5rNKDPHUTwZ9a1AEl5","is_local":false,"is_playable":true,"name":"Free Verse","track_number":9,"type":"track","uri":"spotify:track:4Qck5rNKDPHUTwZ9a1AEl5"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0V9n6LOQxTf3kNl4pZLZ05"},"href":"https://api.spotify.com/v1/artists/0V9n6LOQxTf3kNl4pZLZ05","id":"0V9n6LOQxTf3kNl4pZLZ05","name":"Lana Ayres","type":"artist","uri":"spotify:artist:0V9n6LOQxTf3kNl4pZLZ05"}],"external_urls":{"spotify":"https://open.spotify.com/album/3hl4sxNyeWQ4O0lIrNVc1k"},"href":"https://api.spotify.com/v1/albums/3hl4sxNyeWQ4O0lIrNVc1k","id":"3hl4sxNyeWQ4O0lIrNVc1k","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dd1dcea48922b3aa9f2b078b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dd1dcea48922b3aa9f2b078b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dd1dcea48922b3aa9f2b078b"}],"is_playable":true,"name":"Free Verse","release_date":"2020-12-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3hl4sxNyeWQ4O0lIrNVc1k"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0V9n6LOQxTf3kNl4pZLZ05"},"href":"https://api.spotify.com/v1/artists/0V9n6LOQxTf3kNl4pZLZ05","id":"0V9n6LOQxTf3kNl4pZLZ05","name":"Lana Ayres","type":"artist","uri":"spotify:artist:0V9n6LOQxTf3kNl4pZLZ05"}],"disc_number":1,"duration_ms":223225,"explicit":true,"external_ids":{"isrc":"QZ8252101377"},"external_urls":{"spotify":"https://open.spotify.com/track/35G6R0HpdPc5TGsFDK3KFw"},"href":"https://api.spotify.com/v1/tracks/35G6R0HpdPc5TGsFDK3KFw","id":"35G6R0HpdPc5TGsFDK3KFw","is_local":false,"is_playable":true,"name":"Free Verse","track_number":1,"type":"track","uri":"spotify:track:35G6R0HpdPc5TGsFDK3KFw"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pfy05cNNTacuOQ6SiSu4v"},"href":"https://api.spotify.com/v1/artists/4pfy05cNNTacuOQ6SiSu4v","id":"4pfy05cNNTacuOQ6SiSu4v","name":"Lyn Lapid","type":"artist","uri":"spotify:artist:4pfy05cNNTacuOQ6SiSu4v"}],"external_urls":{"spotify":"https://open.spotify.com/album/18pzJc8GyrVQmunRXrY3ch"},"href":"https://api.spotify.com/v1/albums/18pzJc8GyrVQmunRXrY3ch","id":"18pzJc8GyrVQmunRXrY3ch","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c6497369a38af8968e93168e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c6497369a38af8968e93168e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c6497369a38af8968e93168e"}],"is_playable":true,"name":"to love in the 21st century","release_date":"2023-06-23","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:18pzJc8GyrVQmunRXrY3ch"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pfy05cNNTacuOQ6SiSu4v"},"href":"https://api.spotify.com/v1/artists/4pfy05cNNTacuOQ6SiSu4v","id":"4pfy05cNNTacuOQ6SiSu4v","name":"Lyn Lapid","type":"artist","uri":"spotify:artist:4pfy05cNNTacuOQ6SiSu4v"}],"disc_number":1,"duration_ms":219800,"explicit":false,"external_ids":{"isrc":"USUM72308546"},"external_urls":{"spotify":"https://open.spotify.com/track/30TMiaI1TpsUzJAI8ZIduk"},"href":"https://api.spotify.com/v1/tracks/30TMiaI1TpsUzJAI8ZIduk","id":"30TMiaI1TpsUzJAI8ZIduk","is_local":false,"is_playable":true,"name":"pick your brain","track_number":4,"type":"track","uri":"spotify:track:30TMiaI1TpsUzJAI8ZIduk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5brlhAzWsccu61AiDYQS6O"},"href":"https://api.spotify.com/v1/artists/5brlhAzWsccu61AiDYQS6O","id":"5brlhAzWsccu61AiDYQS6O","name":"Tilden Dexter","type":"artist","uri":"spotify:artist:5brlhAzWsccu61AiDYQS6O"}],"external_urls":{"spotify":"https://open.spotify.com/album/06qoIfu5OqnkeHzMfG6S0f"},"href":"https://api.spotify.com/v1/albums/06qoIfu5OqnkeHzMfG6S0f","id":"06qoIfu5OqnkeHzMfG6S0f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e871108bfe11117e4796c6bf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e871108bfe11117e4796c6bf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e871108bfe11117e4796c6bf"}],"is_playable":true,"name":"Rap Game Cornered","release_date":"2026-05-06","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:06qoIfu5OqnkeHzMfG6S0f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5brlhAzWsccu61AiDYQS6O"},"href":"https://api.spotify.com/v1/artists/5brlhAzWsccu61AiDYQS6O","id":"5brlhAzWsccu61AiDYQS6O","name":"Tilden Dexter","type":"artist","uri":"spotify:artist:5brlhAzWsccu61AiDYQS6O"}],"disc_number":1,"duration_ms":280840,"explicit":false,"external_ids":{"isrc":"QZZ782619301"},"external_urls":{"spotify":"https://open.spotify.com/track/1DvMoeysL7TDrQI6bfMMzr"},"href":"https://api.spotify.com/v1/tracks/1DvMoeysL7TDrQI6bfMMzr","id":"1DvMoeysL7TDrQI6bfMMzr","is_local":false,"is_playable":true,"name":"Please Wake Up Bro","track_number":5,"type":"track","uri":"spotify:track:1DvMoeysL7TDrQI6bfMMzr"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1Bd2FrZSUyME51JTNBTG9naWMmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MTAmbGltaXQ9MTAmcXVlcnk9QXdha2UlMjBOdSUzQUxvZ2ljJnR5cGU9dHJhY2siLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MTcsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yV1gydVRjc3ZWNU9uUzBpbkFDZWNQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJXWDJ1VGNzdlY1T25TMGluQUNlY1AiLCJpZCI6IjJXWDJ1VGNzdlY1T25TMGluQUNlY1AiLCJuYW1lIjoiQmlyZHkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MldYMnVUY3N2VjVPblMwaW5BQ2VjUCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81cEw4UTV4YkRMRURFNkp2WU1YWDl1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVwTDhRNXhiRExFREU2SnZZTVhYOXUiLCJpZCI6IjVwTDhRNXhiRExFREU2SnZZTVhYOXUiLCJuYW1lIjoiTnU6TG9n", + "aWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXBMOFE1eGJETEVERTZKdllNWFg5dSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNuTDBqVFFPTG5pckVhV0M1bmdERlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zbkwwalRRT0xuaXJFYVdDNW5nREZYIiwiaWQiOiIzbkwwalRRT0xuaXJFYVdDNW5nREZYIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzNkNWQ5ZGQxMWE1MmE2ZjYxNjhhMjBmYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzZDVkOWRkMTFhNTJhNmY2MTY4YTIwZmMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTNkNWQ5ZGQxMWE1MmE2ZjYxNjhhMjBmYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXaW5ncyAoTnU6TG9naWMgUmVtaXg7IEVkaXQpIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0xMS0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M25MMGpUUU9MbmlyRWFXQzVuZ0RGWCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJXWDJ1VGNzdlY1T25TMGluQUNlY1AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMldYMnVUY3N2VjVPblMwaW5BQ2VjUCIsImlkIjoiMldYMnVUY3N2VjVPblMwaW5BQ2VjUCIsIm5hbWUiOiJCaXJkeSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyV1gydVRjc3ZWNU9uUzBpbkFDZWNQIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVwTDhRNXhiRExFREU2SnZZTVhYOXUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXBMOFE1eGJETEVERTZKdllNWFg5dSIsImlkIjoiNXBMOFE1eGJETEVERTZKdllNWFg5dSIsIm5hbWUiOiJOdTpMb2dpYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1cEw4UTV4YkRMRURFNkp2WU1YWDl1In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdwREJSeTl1V3kxenE1YjB1WElBQlEifSwiaHJlZg==", + "IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83cERCUnk5dVd5MXpxNWIwdVhJQUJRIiwiaWQiOiI3cERCUnk5dVd5MXpxNWIwdVhJQUJRIiwibmFtZSI6Ik51OlRvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3BEQlJ5OXVXeTF6cTViMHVYSUFCUSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wMUs4R0VNR0d4dHJRNHhqRG1OTFBzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzAxSzhHRU1HR3h0clE0eGpEbU5MUHMiLCJpZCI6IjAxSzhHRU1HR3h0clE0eGpEbU5MUHMiLCJuYW1lIjoiTG9naXN0aWNzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjAxSzhHRU1HR3h0clE0eGpEbU5MUHMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzgzNDQ4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFQyMzAxMDY3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wbDlhcW5Fd1YyaDJtM0VwTHNKSU5XIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGw5YXFuRXdWMmgybTNFcExzSklOVyIsImlkIjoiMGw5YXFuRXdWMmgybTNFcExzSklOVyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXaW5ncyAtIE51OkxvZ2ljIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBsOWFxbkV3VjJoMm0zRXBMc0pJTlcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXBMOFE1eGJETEVERTZKdllNWFg5dSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81cEw4UTV4YkRMRURFNkp2WU1YWDl1IiwiaWQiOiI1cEw4UTV4YkRMRURFNkp2WU1YWDl1IiwibmFtZSI6Ik51OkxvZ2ljIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVwTDhRNXhiRExFREU2SnZZTVhYOXUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zYlRDWlZ0REdJcU5pbnNzYnZUUXFBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2JUQ1pWdERHSXFOaW5zc2J2VFFxQSIsImlkIjoiM2JUQ1pWdERHSXFOaW5zc2J2VFFxQSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NA==", + "MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzcwMjk1MmUxYjhiNWVmMGM0YzBmOGY1NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3MDI5NTJlMWI4YjVlZjBjNGMwZjhmNTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTcwMjk1MmUxYjhiNWVmMGM0YzBmOGY1NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb21ld2hlcmUgQmV0d2VlbiBUaGUgTGlnaHQiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA2LTMwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2JUQ1pWdERHSXFOaW5zc2J2VFFxQSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVwTDhRNXhiRExFREU2SnZZTVhYOXUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXBMOFE1eGJETEVERTZKdllNWFg5dSIsImlkIjoiNXBMOFE1eGJETEVERTZKdllNWFg5dSIsIm5hbWUiOiJOdTpMb2dpYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1cEw4UTV4YkRMRURFNkp2WU1YWDl1In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0OTU0NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQ0pZMTcwMDA4NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svME1kc3lMdHI5dUdYaVZtVUdtcXNYdCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBNZHN5THRyOXVHWGlWbVVHbXFzWHQiLCJpZCI6IjBNZHN5THRyOXVHWGlWbVVHbXFzWHQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTm92YSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowTWRzeUx0cjl1R1hpVm1VR21xc1h0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zY21leHhiZVlNaUxOajlWRW1CNDUxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNjbWV4eGJlWU1pTE5qOVZFbUI0NTEiLCJpZCI6IjNjbWV4eGJlWU1pTE5qOVZFbUI0NTEiLCJuYW1lIg==", + "OiJFdW9sb2d5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNjbWV4eGJlWU1pTE5qOVZFbUI0NTEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81SVdrUDU5aXc4M2xkeldva2xZMlFBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUlXa1A1OWl3ODNsZHpXb2tsWTJRQSIsImlkIjoiNUlXa1A1OWl3ODNsZHpXb2tsWTJRQSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4MmE1ZmNmNTYyZDY0ODcwNzgwZGQ3ZDIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODJhNWZjZjU2MmQ2NDg3MDc4MGRkN2QyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4MmE1ZmNmNTYyZDY0ODcwNzgwZGQ3ZDIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTG9naWMiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTA2LTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1SVdrUDU5aXc4M2xkeldva2xZMlFBIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2NtZXh4YmVZTWlMTmo5VkVtQjQ1MSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zY21leHhiZVlNaUxOajlWRW1CNDUxIiwiaWQiOiIzY21leHhiZVlNaUxOajlWRW1CNDUxIiwibmFtZSI6IkV1b2xvZ3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2NtZXh4YmVZTWlMTmo5VkVtQjQ1MSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjE1MzgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWk1FTjI0OTg3NDgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRlZ3dHcTY1ZXhmakFJYjFVS1BHTXcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80ZWd3R3E2NWV4ZmpBSWIxVUtQR013IiwiaWQiOiI0ZWd3R3E2NWV4ZmpBSWIxVUtQR013IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxvZ2ljIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aQ==", + "Znk6dHJhY2s6NGVnd0dxNjVleGZqQUliMVVLUEdNdyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81Vkt2cUN5QnhxYmFYVXA4ZUswYVV5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVWS3ZxQ3lCeHFiYVhVcDhlSzBhVXkiLCJpZCI6IjVWS3ZxQ3lCeHFiYVhVcDhlSzBhVXkiLCJuYW1lIjoiU2NyaW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVZLdnFDeUJ4cWJhWFVwOGVLMGFVeSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc3YTJ1aEtLOGNMdlRTMEZNeXV0VTcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83N2EydWhLSzhjTHZUUzBGTXl1dFU3IiwiaWQiOiI3N2EydWhLSzhjTHZUUzBGTXl1dFU3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzVkNTYxOTM4MjVhODk4Zjc0MGNlY2RmNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1ZDU2MTkzODI1YTg5OGY3NDBjZWNkZjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTVkNTYxOTM4MjVhODk4Zjc0MGNlY2RmNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJydW5hd2F5IiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNS0yOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjU5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc3YTJ1aEtLOGNMdlRTMEZNeXV0VTcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81Vkt2cUN5QnhxYmFYVXA4ZUswYVV5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVWS3ZxQ3lCeHFiYVhVcDhlSzBhVXkiLCJpZCI6IjVWS3ZxQ3lCeHFiYVhVcDhlSzBhVXkiLCJuYW1lIjoiU2NyaW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVZLdnFDeUJ4cWJhWFVwOGVLMGFVeSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxMTYzNDIsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaQVBLMjAwMDgwNiJ9LCJleHRlcm5hbF91cg==", + "bHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zNmV0MlNLOFNxZVNSZFpFU05mNjlDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzZldDJTSzhTcWVTUmRaRVNOZjY5QyIsImlkIjoiMzZldDJTSzhTcWVTUmRaRVNOZjY5QyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJ3b2phayIsInRyYWNrX251bWJlciI6NDIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MzZldDJTSzhTcWVTUmRaRVNOZjY5QyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMm1PQW9nMm1LaUY1UmFPVjJlQWluWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8ybU9Bb2cybUtpRjVSYU9WMmVBaW5aIiwiaWQiOiIybU9Bb2cybUtpRjVSYU9WMmVBaW5aIiwibmFtZSI6IkxvZ2ljc291bCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoybU9Bb2cybUtpRjVSYU9WMmVBaW5aIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNGgxdzlIdEdsZm9zTU5abzRkMm9wSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRoMXc5SHRHbGZvc01OWm80ZDJvcEkiLCJpZCI6IjRoMXc5SHRHbGZvc01OWm80ZDJvcEkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmViNjM2ZjEyNjE3ZWY3MGM0ZDM2MTZmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZlYjYzNmYxMjYxN2VmNzBjNGQzNjE2ZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmViNjM2ZjEyNjE3ZWY3MGM0ZDM2MTZmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik51IFRvd24gRXhwcmVzcyBFUCIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMTAtMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRoMXc5SHRHbGZvc01OWm80ZDJvcEkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8ybU9Bb2cybUtpRjVSYU9WMmVBaW5aIn0sIg==", + "aHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMm1PQW9nMm1LaUY1UmFPVjJlQWluWiIsImlkIjoiMm1PQW9nMm1LaUY1UmFPVjJlQWluWiIsIm5hbWUiOiJMb2dpY3NvdWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mm1PQW9nMm1LaUY1UmFPVjJlQWluWiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozODM2ODYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0xaSjE4Nzc2NjEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFOdXJoaENDNzU2RGY0cnBad0FIME8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xTnVyaGhDQzc1NkRmNHJwWndBSDBPIiwiaWQiOiIxTnVyaGhDQzc1NkRmNHJwWndBSDBPIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBGb3Jlc3QgQXdha2VzIC0gT3JpZ2luYWwgTWl4IiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFOdXJoaENDNzU2RGY0cnBad0FIME8ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG5wM2RNOENTdmpLaFRvYTBFcGZzOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80bnAzZE04Q1N2aktoVG9hMEVwZnM5IiwiaWQiOiI0bnAzZE04Q1N2aktoVG9hMEVwZnM5IiwibmFtZSI6IktveW8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NG5wM2RNOENTdmpLaFRvYTBFcGZzOSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzE1QXQ1ZkJIck5zYUx0V0E3ZE5XSUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xNUF0NWZCSHJOc2FMdFdBN2ROV0lBIiwiaWQiOiIxNUF0NWZCSHJOc2FMdFdBN2ROV0lBIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2IzNjE1MDFhNjY2NTgxNGIzMDY1MGQwOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiMzYxNTAxYTY2NjU4MTRiMzA2NTBkMDgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWIzNjE1MA==", + "MWE2NjY1ODE0YjMwNjUwZDA4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldvdWxkIFlvdSBNaXNzIEl0PyIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDktMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxNUF0NWZCSHJOc2FMdFdBN2ROV0lBIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG5wM2RNOENTdmpLaFRvYTBFcGZzOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80bnAzZE04Q1N2aktoVG9hMEVwZnM5IiwiaWQiOiI0bnAzZE04Q1N2aktoVG9hMEVwZnM5IiwibmFtZSI6IktveW8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NG5wM2RNOENTdmpLaFRvYTBFcGZzOSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81bDkzd2hhcDlXNmtrMndsOXNwR20yIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVsOTN3aGFwOVc2a2syd2w5c3BHbTIiLCJpZCI6IjVsOTN3aGFwOVc2a2syd2w5c3BHbTIiLCJuYW1lIjoiVmlubmllIENhcnVhbmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWw5M3doYXA5VzZrazJ3bDlzcEdtMiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODc2MjMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NUVDIzMDAxNjYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBqQkdsNEpJSVdleUlJRkxyeHVxOGwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wakJHbDRKSUlXZXlJSUZMcnh1cThsIiwiaWQiOiIwakJHbDRKSUlXZXlJSUZMcnh1cThsIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldoYXQncyBMZWZ0IFRvIFNheSIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowakJHbDRKSUlXZXlJSUZMcnh1cThsIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBWOW42TE9ReFRmM2tObDRwWkxaMDUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFY5bjZMT1F4VGYza05sNHBaTFowNSIsImlkIjoiMFY5bjZMT1F4VGYzaw==", + "Tmw0cFpMWjA1IiwibmFtZSI6IkxhbmEgQXlyZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFY5bjZMT1F4VGYza05sNHBaTFowNSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNRVTJmTW5xaFl0d21MQWlCZ0xMbEcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zUVUyZk1ucWhZdHdtTEFpQmdMTGxHIiwiaWQiOiIzUVUyZk1ucWhZdHdtTEFpQmdMTGxHIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzhlZTRhYTAyMzg0MjM0YTU2YzQxN2YzMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4ZWU0YWEwMjM4NDIzNGE1NmM0MTdmMzEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MThlZTRhYTAyMzg0MjM0YTU2YzQxN2YzMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQYWlua2lsbGVyIFJoeW1lcyIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDgtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozUVUyZk1ucWhZdHdtTEFpQmdMTGxHIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFY5bjZMT1F4VGYza05sNHBaTFowNSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wVjluNkxPUXhUZjNrTmw0cFpMWjA1IiwiaWQiOiIwVjluNkxPUXhUZjNrTmw0cFpMWjA1IiwibmFtZSI6IkxhbmEgQXlyZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFY5bjZMT1F4VGYza05sNHBaTFowNSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjMyMjUsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaODI1MjEwMTM3NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFFjazVyTktEUEhVVHdaOWExQUVsNSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRRY2s1ck5LRFBIVVR3WjlhMUFFbDUiLCJpZCI6IjRRY2s1ck5LRFBIVVR3WjlhMUFFbDUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRnJlZSBWZXJzZSIsInRyYQ==", + "Y2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRRY2s1ck5LRFBIVVR3WjlhMUFFbDUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBWOW42TE9ReFRmM2tObDRwWkxaMDUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFY5bjZMT1F4VGYza05sNHBaTFowNSIsImlkIjoiMFY5bjZMT1F4VGYza05sNHBaTFowNSIsIm5hbWUiOiJMYW5hIEF5cmVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBWOW42TE9ReFRmM2tObDRwWkxaMDUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zaGw0c3hOeWVXUTRPMGxJck5WYzFrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2hsNHN4TnllV1E0TzBsSXJOVmMxayIsImlkIjoiM2hsNHN4TnllV1E0TzBsSXJOVmMxayIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkZDFkY2VhNDg5MjJiM2FhOWYyYjA3OGIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZGQxZGNlYTQ4OTIyYjNhYTlmMmIwNzhiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkZDFkY2VhNDg5MjJiM2FhOWYyYjA3OGIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRnJlZSBWZXJzZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTItMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNobDRzeE55ZVdRNE8wbElyTlZjMWsifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wVjluNkxPUXhUZjNrTmw0cFpMWjA1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBWOW42TE9ReFRmM2tObDRwWkxaMDUiLCJpZCI6IjBWOW42TE9ReFRmM2tObDRwWkxaMDUiLCJuYW1lIjoiTGFuYSBBeXJlcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowVjluNkxPUXhUZjNrTmw0cFpMWjA1In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMzIyNSwiZXhwbGljaXQiOnRydQ==", + "ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWjgyNTIxMDEzNzcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzM1RzZSMEhwZFBjNVRHc0ZESzNLRncifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zNUc2UjBIcGRQYzVUR3NGREszS0Z3IiwiaWQiOiIzNUc2UjBIcGRQYzVUR3NGREszS0Z3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZyZWUgVmVyc2UiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MzVHNlIwSHBkUGM1VEdzRkRLM0tGdyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80cGZ5MDVjTk5UYWN1T1E2U2lTdTR2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRwZnkwNWNOTlRhY3VPUTZTaVN1NHYiLCJpZCI6IjRwZnkwNWNOTlRhY3VPUTZTaVN1NHYiLCJuYW1lIjoiTHluIExhcGlkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRwZnkwNWNOTlRhY3VPUTZTaVN1NHYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xOHB6SmM4R3lyVlFtdW5SWHJZM2NoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMThwekpjOEd5clZRbXVuUlhyWTNjaCIsImlkIjoiMThwekpjOEd5clZRbXVuUlhyWTNjaCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjNjQ5NzM2OWEzOGFmODk2OGU5MzE2OGUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzY0OTczNjlhMzhhZjg5NjhlOTMxNjhlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNjQ5NzM2OWEzOGFmODk=", + "NjhlOTMxNjhlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6InRvIGxvdmUgaW4gdGhlIDIxc3QgY2VudHVyeSIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDYtMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxOHB6SmM4R3lyVlFtdW5SWHJZM2NoIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHBmeTA1Y05OVGFjdU9RNlNpU3U0diJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80cGZ5MDVjTk5UYWN1T1E2U2lTdTR2IiwiaWQiOiI0cGZ5MDVjTk5UYWN1T1E2U2lTdTR2IiwibmFtZSI6Ikx5biBMYXBpZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0cGZ5MDVjTk5UYWN1T1E2U2lTdTR2In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxOTgwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MjMwODU0NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMzBUTWlhSTFUcHNVekpBSThaSWR1ayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzMwVE1pYUkxVHBzVXpKQUk4WklkdWsiLCJpZCI6IjMwVE1pYUkxVHBzVXpKQUk4WklkdWsiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoicGljayB5b3VyIGJyYWluIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjMwVE1pYUkxVHBzVXpKQUk4WklkdWsifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVicmxoQXpXc2NjdTYxQWlEWVFTNk8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNWJybGhBeldzY2N1NjFBaURZUVM2TyIsImlkIjoiNWJybGhBeldzY2N1NjFBaURZUVM2TyIsIm5hbWUiOiJUaWxkZW4gRGV4dGVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVicmxoQXpXc2NjdTYxQWlEWVFTNk8ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wNnFvSWZ1NU9xbmtlSHpNZkc2UzBmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDZxb0lmdTVPcW5rZUh6TWZHNlMwZiIsImlkIjoiMDZxb0lmdTVPcW5rZQ==", + "SHpNZkc2UzBmIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2U4NzExMDhiZmUxMTExN2U0Nzk2YzZiZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlODcxMTA4YmZlMTExMTdlNDc5NmM2YmYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWU4NzExMDhiZmUxMTExN2U0Nzk2YzZiZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSYXAgR2FtZSBDb3JuZXJlZCIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDUtMDYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjA2cW9JZnU1T3Fua2VIek1mRzZTMGYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81YnJsaEF6V3NjY3U2MUFpRFlRUzZPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVicmxoQXpXc2NjdTYxQWlEWVFTNk8iLCJpZCI6IjVicmxoQXpXc2NjdTYxQWlEWVFTNk8iLCJuYW1lIjoiVGlsZGVuIERleHRlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1YnJsaEF6V3NjY3U2MUFpRFlRUzZPIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI4MDg0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaWjc4MjYxOTMwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUR2TW9leXNMN1REclFJNmJmTU16ciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFEdk1vZXlzTDdURHJRSTZiZk1NenIiLCJpZCI6IjFEdk1vZXlzTDdURHJRSTZiZk1NenIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUGxlYXNlIFdha2UgVXAgQnJvIiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFEdk1vZXlzTDdURHJRSTZiZk1NenIifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Awake+Nu%3ALogic&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Home%22%20artist%3A%22Lens%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/196dcuwJrobm0Rb6KYRFfw"},"href":"https://api.spotify.com/v1/artists/196dcuwJrobm0Rb6KYRFfw","id":"196dcuwJrobm0Rb6KYRFfw","name":"Alex Stonebay","type":"artist","uri":"spotify:artist:196dcuwJrobm0Rb6KYRFfw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cEBwBPqIxz8CKy3lTtfHw"},"href":"https://api.spotify.com/v1/artists/3cEBwBPqIxz8CKy3lTtfHw","id":"3cEBwBPqIxz8CKy3lTtfHw","name":"Lenso","type":"artist","uri":"spotify:artist:3cEBwBPqIxz8CKy3lTtfHw"}],"external_urls":{"spotify":"https://open.spotify.com/album/4IbeyyFgdFK71edAyoAQpm"},"href":"https://api.spotify.com/v1/albums/4IbeyyFgdFK71edAyoAQpm","id":"4IbeyyFgdFK71edAyoAQpm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273caf7750971d2d5bb6c3095d2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02caf7750971d2d5bb6c3095d2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851caf7750971d2d5bb6c3095d2"}],"is_playable":true,"name":"Take Me Home (Lenso Remix)","release_date":"2026-03-13","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4IbeyyFgdFK71edAyoAQpm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/196dcuwJrobm0Rb6KYRFfw"},"href":"https://api.spotify.com/v1/artists/196dcuwJrobm0Rb6KYRFfw","id":"196dcuwJrobm0Rb6KYRFfw","name":"Alex Stonebay","type":"artist","uri":"spotify:artist:196dcuwJrobm0Rb6KYRFfw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cEBwBPqIxz8CKy3lTtfHw"},"href":"https://api.spotify.com/v1/artists/3cEBwBPqIxz8CKy3lTtfHw","id":"3cEBwBPqIxz8CKy3lTtfHw","name":"Lenso","type":"artist","uri":"spotify:artist:3cEBwBPqIxz8CKy3lTtfHw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/04DhPedaqUbTclK69WosXR"},"href":"https://api.spotify.com/v1/artists/04DhPedaqUbTclK69WosXR","id":"04DhPedaqUbTclK69WosXR","name":"serephina skyrs\u00e5n","type":"artist","uri":"spotify:artist:04DhPedaqUbTclK69WosXR"}],"disc_number":1,"duration_ms":250909,"explicit":false,"external_ids":{"isrc":"QZMEQ2605138"},"external_urls":{"spotify":"https://open.spotify.com/track/6CE6l0wkAr8c7rbWdrltmL"},"href":"https://api.spotify.com/v1/tracks/6CE6l0wkAr8c7rbWdrltmL","id":"6CE6l0wkAr8c7rbWdrltmL","is_local":false,"is_playable":true,"name":"Take Me Home - Lenso Remix","track_number":1,"type":"track","uri":"spotify:track:6CE6l0wkAr8c7rbWdrltmL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/1LVW28IlO55Nnle5lYq1FF"},"href":"https://api.spotify.com/v1/albums/1LVW28IlO55Nnle5lYq1FF","id":"1LVW28IlO55Nnle5lYq1FF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27304d86609d9f70815a2c30870"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0204d86609d9f70815a2c30870"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485104d86609d9f70815a2c30870"}],"is_playable":true,"name":"Dreamy coffee and floral vibes","release_date":"2024-10-13","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:1LVW28IlO55Nnle5lYq1FF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":239999,"explicit":false,"external_ids":{"isrc":"QZWFQ2496639"},"external_urls":{"spotify":"https://open.spotify.com/track/2RikB98n4JlAMXC2VsnJp1"},"href":"https://api.spotify.com/v1/tracks/2RikB98n4JlAMXC2VsnJp1","id":"2RikB98n4JlAMXC2VsnJp1","is_local":false,"is_playable":true,"name":"Home sweet vibes","track_number":4,"type":"track","uri":"spotify:track:2RikB98n4JlAMXC2VsnJp1"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tohVJC9TjZdlve56ttA6Y"},"href":"https://api.spotify.com/v1/albums/5tohVJC9TjZdlve56ttA6Y","id":"5tohVJC9TjZdlve56ttA6Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733002d315a39759f2f3418fbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023002d315a39759f2f3418fbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513002d315a39759f2f3418fbc"}],"is_playable":true,"name":"Cozy Fall Days","release_date":"2025-10-09","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5tohVJC9TjZdlve56ttA6Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":190000,"explicit":false,"external_ids":{"isrc":"QT3FA2534518"},"external_urls":{"spotify":"https://open.spotify.com/track/22yiPgN12r54urDH6SXNb0"},"href":"https://api.spotify.com/v1/tracks/22yiPgN12r54urDH6SXNb0","id":"22yiPgN12r54urDH6SXNb0","is_local":false,"is_playable":true,"name":"Homeward Glow","track_number":5,"type":"track","uri":"spotify:track:22yiPgN12r54urDH6SXNb0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tohVJC9TjZdlve56ttA6Y"},"href":"https://api.spotify.com/v1/albums/5tohVJC9TjZdlve56ttA6Y","id":"5tohVJC9TjZdlve56ttA6Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733002d315a39759f2f3418fbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023002d315a39759f2f3418fbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513002d315a39759f2f3418fbc"}],"is_playable":true,"name":"Cozy Fall Days","release_date":"2025-10-09","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5tohVJC9TjZdlve56ttA6Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":202679,"explicit":false,"external_ids":{"isrc":"QT3FA2534520"},"external_urls":{"spotify":"https://open.spotify.com/track/5Tb2ggSJ8UyerdxwIyZEV2"},"href":"https://api.spotify.com/v1/tracks/5Tb2ggSJ8UyerdxwIyZEV2","id":"5Tb2ggSJ8UyerdxwIyZEV2","is_local":false,"is_playable":true,"name":"Home in the Rain","track_number":7,"type":"track","uri":"spotify:track:5Tb2ggSJ8UyerdxwIyZEV2"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Q0tsXC2u6geWS9yydLdhM"},"href":"https://api.spotify.com/v1/artists/4Q0tsXC2u6geWS9yydLdhM","id":"4Q0tsXC2u6geWS9yydLdhM","name":"Theo Lens","type":"artist","uri":"spotify:artist:4Q0tsXC2u6geWS9yydLdhM"}],"external_urls":{"spotify":"https://open.spotify.com/album/58OKMDOKoIi3NZpxSVeKx9"},"href":"https://api.spotify.com/v1/albums/58OKMDOKoIi3NZpxSVeKx9","id":"58OKMDOKoIi3NZpxSVeKx9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27396fc5e3da6420f96cc44e3fa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0296fc5e3da6420f96cc44e3fa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485196fc5e3da6420f96cc44e3fa"}],"is_playable":true,"name":"Come Home","release_date":"2018-09-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:58OKMDOKoIi3NZpxSVeKx9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Q0tsXC2u6geWS9yydLdhM"},"href":"https://api.spotify.com/v1/artists/4Q0tsXC2u6geWS9yydLdhM","id":"4Q0tsXC2u6geWS9yydLdhM","name":"Theo Lens","type":"artist","uri":"spotify:artist:4Q0tsXC2u6geWS9yydLdhM"}],"disc_number":1,"duration_ms":245179,"explicit":false,"external_ids":{"isrc":"NLQM71100021"},"external_urls":{"spotify":"https://open.spotify.com/track/5MgN569Q9zmPH3g0rDdsd0"},"href":"https://api.spotify.com/v1/tracks/5MgN569Q9zmPH3g0rDdsd0","id":"5MgN569Q9zmPH3g0rDdsd0","is_local":false,"is_playable":true,"name":"Come Home","track_number":1,"type":"track","uri":"spotify:track:5MgN569Q9zmPH3g0rDdsd0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SL7qzFJXBTB8v0jCLqSPj"},"href":"https://api.spotify.com/v1/artists/0SL7qzFJXBTB8v0jCLqSPj","id":"0SL7qzFJXBTB8v0jCLqSPj","name":"Lenseye","type":"artist","uri":"spotify:artist:0SL7qzFJXBTB8v0jCLqSPj"}],"external_urls":{"spotify":"https://open.spotify.com/album/29zeJnRfGQadmfDsvDvum7"},"href":"https://api.spotify.com/v1/albums/29zeJnRfGQadmfDsvDvum7","id":"29zeJnRfGQadmfDsvDvum7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273045bd40fabb28e2bc12fd15b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02045bd40fabb28e2bc12fd15b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851045bd40fabb28e2bc12fd15b"}],"is_playable":true,"name":"September's Child","release_date":"2020-09-18","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:29zeJnRfGQadmfDsvDvum7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SL7qzFJXBTB8v0jCLqSPj"},"href":"https://api.spotify.com/v1/artists/0SL7qzFJXBTB8v0jCLqSPj","id":"0SL7qzFJXBTB8v0jCLqSPj","name":"Lenseye","type":"artist","uri":"spotify:artist:0SL7qzFJXBTB8v0jCLqSPj"}],"disc_number":1,"duration_ms":190052,"explicit":false,"external_ids":{"isrc":"QZHNB2066466"},"external_urls":{"spotify":"https://open.spotify.com/track/4ssnuvZhH7m78KIRcInzU4"},"href":"https://api.spotify.com/v1/tracks/4ssnuvZhH7m78KIRcInzU4","id":"4ssnuvZhH7m78KIRcInzU4","is_local":false,"is_playable":true,"name":"Homesick Atlantic Reverie","track_number":6,"type":"track","uri":"spotify:track:4ssnuvZhH7m78KIRcInzU4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lMM4E33eJTCESTA5DxAbo"},"href":"https://api.spotify.com/v1/artists/6lMM4E33eJTCESTA5DxAbo","id":"6lMM4E33eJTCESTA5DxAbo","name":"Dreamer Lens","type":"artist","uri":"spotify:artist:6lMM4E33eJTCESTA5DxAbo"}],"external_urls":{"spotify":"https://open.spotify.com/album/1ik8T9Rm8Vkr24Nx0jfTxe"},"href":"https://api.spotify.com/v1/albums/1ik8T9Rm8Vkr24Nx0jfTxe","id":"1ik8T9Rm8Vkr24Nx0jfTxe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e21c1f7740c79506ae78cd8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e21c1f7740c79506ae78cd8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e21c1f7740c79506ae78cd8"}],"is_playable":true,"name":"66 (inspired by true events)","release_date":"2026-06-27","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1ik8T9Rm8Vkr24Nx0jfTxe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lMM4E33eJTCESTA5DxAbo"},"href":"https://api.spotify.com/v1/artists/6lMM4E33eJTCESTA5DxAbo","id":"6lMM4E33eJTCESTA5DxAbo","name":"Dreamer Lens","type":"artist","uri":"spotify:artist:6lMM4E33eJTCESTA5DxAbo"}],"disc_number":1,"duration_ms":111719,"explicit":false,"external_ids":{"isrc":"CAENV2674840"},"external_urls":{"spotify":"https://open.spotify.com/track/3MiTAmlaA2cHfWuyjaVIzW"},"href":"https://api.spotify.com/v1/tracks/3MiTAmlaA2cHfWuyjaVIzW","id":"3MiTAmlaA2cHfWuyjaVIzW","is_local":false,"is_playable":true,"name":"Home (Reprise)","track_number":14,"type":"track","uri":"spotify:track:3MiTAmlaA2cHfWuyjaVIzW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5Jl09T3op2vhK2lk9aTt2D"},"href":"https://api.spotify.com/v1/artists/5Jl09T3op2vhK2lk9aTt2D","id":"5Jl09T3op2vhK2lk9aTt2D","name":"lensky","type":"artist","uri":"spotify:artist:5Jl09T3op2vhK2lk9aTt2D"}],"external_urls":{"spotify":"https://open.spotify.com/album/1LP2XJHfAsDU0vxFHsBeH1"},"href":"https://api.spotify.com/v1/albums/1LP2XJHfAsDU0vxFHsBeH1","id":"1LP2XJHfAsDU0vxFHsBeH1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730d9d0a92bd6523d6a45a3860"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020d9d0a92bd6523d6a45a3860"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510d9d0a92bd6523d6a45a3860"}],"is_playable":true,"name":"Demo Songs, Vol 1","release_date":"2022-09-04","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:1LP2XJHfAsDU0vxFHsBeH1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5Jl09T3op2vhK2lk9aTt2D"},"href":"https://api.spotify.com/v1/artists/5Jl09T3op2vhK2lk9aTt2D","id":"5Jl09T3op2vhK2lk9aTt2D","name":"lensky","type":"artist","uri":"spotify:artist:5Jl09T3op2vhK2lk9aTt2D"}],"disc_number":1,"duration_ms":208000,"explicit":false,"external_ids":{"isrc":"TCAGL2238557"},"external_urls":{"spotify":"https://open.spotify.com/track/2hafWXwcUvgtcxPliIprov"},"href":"https://api.spotify.com/v1/tracks/2hafWXwcUvgtcxPliIprov","id":"2hafWXwcUvgtcxPliIprov","is_local":false,"is_playable":true,"name":"Home Alone","track_number":5,"type":"track","uri":"spotify:track:2hafWXwcUvgtcxPliIprov"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Yi5cQGz7kDdjbioSPLy3N"},"href":"https://api.spotify.com/v1/artists/4Yi5cQGz7kDdjbioSPLy3N","id":"4Yi5cQGz7kDdjbioSPLy3N","name":"Lensoppa","type":"artist","uri":"spotify:artist:4Yi5cQGz7kDdjbioSPLy3N"}],"external_urls":{"spotify":"https://open.spotify.com/album/2RkWXPcpSJCB7qm6jWgXqM"},"href":"https://api.spotify.com/v1/albums/2RkWXPcpSJCB7qm6jWgXqM","id":"2RkWXPcpSJCB7qm6jWgXqM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736243f37008ab616e1ed8e074"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026243f37008ab616e1ed8e074"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516243f37008ab616e1ed8e074"}],"is_playable":true,"name":"Home Sweet Home","release_date":"2025-10-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2RkWXPcpSJCB7qm6jWgXqM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Yi5cQGz7kDdjbioSPLy3N"},"href":"https://api.spotify.com/v1/artists/4Yi5cQGz7kDdjbioSPLy3N","id":"4Yi5cQGz7kDdjbioSPLy3N","name":"Lensoppa","type":"artist","uri":"spotify:artist:4Yi5cQGz7kDdjbioSPLy3N"}],"disc_number":1,"duration_ms":219839,"explicit":false,"external_ids":{"isrc":"GX53U2687062"},"external_urls":{"spotify":"https://open.spotify.com/track/4IL7ZbMJlOCd67sWhfZrvR"},"href":"https://api.spotify.com/v1/tracks/4IL7ZbMJlOCd67sWhfZrvR","id":"4IL7ZbMJlOCd67sWhfZrvR","is_local":false,"is_playable":true,"name":"Home Sweet Home","track_number":1,"type":"track","uri":"spotify:track:4IL7ZbMJlOCd67sWhfZrvR"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Home%22%20artist%3A%22Lens%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/196dcuwJrobm0Rb6KYRFfw"},"href":"https://api.spotify.com/v1/artists/196dcuwJrobm0Rb6KYRFfw","id":"196dcuwJrobm0Rb6KYRFfw","name":"Alex Stonebay","type":"artist","uri":"spotify:artist:196dcuwJrobm0Rb6KYRFfw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cEBwBPqIxz8CKy3lTtfHw"},"href":"https://api.spotify.com/v1/artists/3cEBwBPqIxz8CKy3lTtfHw","id":"3cEBwBPqIxz8CKy3lTtfHw","name":"Lenso","type":"artist","uri":"spotify:artist:3cEBwBPqIxz8CKy3lTtfHw"}],"external_urls":{"spotify":"https://open.spotify.com/album/4IbeyyFgdFK71edAyoAQpm"},"href":"https://api.spotify.com/v1/albums/4IbeyyFgdFK71edAyoAQpm","id":"4IbeyyFgdFK71edAyoAQpm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273caf7750971d2d5bb6c3095d2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02caf7750971d2d5bb6c3095d2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851caf7750971d2d5bb6c3095d2"}],"is_playable":true,"name":"Take Me Home (Lenso Remix)","release_date":"2026-03-13","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4IbeyyFgdFK71edAyoAQpm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/196dcuwJrobm0Rb6KYRFfw"},"href":"https://api.spotify.com/v1/artists/196dcuwJrobm0Rb6KYRFfw","id":"196dcuwJrobm0Rb6KYRFfw","name":"Alex Stonebay","type":"artist","uri":"spotify:artist:196dcuwJrobm0Rb6KYRFfw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cEBwBPqIxz8CKy3lTtfHw"},"href":"https://api.spotify.com/v1/artists/3cEBwBPqIxz8CKy3lTtfHw","id":"3cEBwBPqIxz8CKy3lTtfHw","name":"Lenso","type":"artist","uri":"spotify:artist:3cEBwBPqIxz8CKy3lTtfHw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/04DhPedaqUbTclK69WosXR"},"href":"https://api.spotify.com/v1/artists/04DhPedaqUbTclK69WosXR","id":"04DhPedaqUbTclK69WosXR","name":"serephina skyrs\u00e5n","type":"artist","uri":"spotify:artist:04DhPedaqUbTclK69WosXR"}],"disc_number":1,"duration_ms":250909,"explicit":false,"external_ids":{"isrc":"QZMEQ2605138"},"external_urls":{"spotify":"https://open.spotify.com/track/6CE6l0wkAr8c7rbWdrltmL"},"href":"https://api.spotify.com/v1/tracks/6CE6l0wkAr8c7rbWdrltmL","id":"6CE6l0wkAr8c7rbWdrltmL","is_local":false,"is_playable":true,"name":"Take Me Home - Lenso Remix","track_number":1,"type":"track","uri":"spotify:track:6CE6l0wkAr8c7rbWdrltmL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/1LVW28IlO55Nnle5lYq1FF"},"href":"https://api.spotify.com/v1/albums/1LVW28IlO55Nnle5lYq1FF","id":"1LVW28IlO55Nnle5lYq1FF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27304d86609d9f70815a2c30870"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0204d86609d9f70815a2c30870"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485104d86609d9f70815a2c30870"}],"is_playable":true,"name":"Dreamy coffee and floral vibes","release_date":"2024-10-13","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:1LVW28IlO55Nnle5lYq1FF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":239999,"explicit":false,"external_ids":{"isrc":"QZWFQ2496639"},"external_urls":{"spotify":"https://open.spotify.com/track/2RikB98n4JlAMXC2VsnJp1"},"href":"https://api.spotify.com/v1/tracks/2RikB98n4JlAMXC2VsnJp1","id":"2RikB98n4JlAMXC2VsnJp1","is_local":false,"is_playable":true,"name":"Home sweet vibes","track_number":4,"type":"track","uri":"spotify:track:2RikB98n4JlAMXC2VsnJp1"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tohVJC9TjZdlve56ttA6Y"},"href":"https://api.spotify.com/v1/albums/5tohVJC9TjZdlve56ttA6Y","id":"5tohVJC9TjZdlve56ttA6Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733002d315a39759f2f3418fbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023002d315a39759f2f3418fbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513002d315a39759f2f3418fbc"}],"is_playable":true,"name":"Cozy Fall Days","release_date":"2025-10-09","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5tohVJC9TjZdlve56ttA6Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":190000,"explicit":false,"external_ids":{"isrc":"QT3FA2534518"},"external_urls":{"spotify":"https://open.spotify.com/track/22yiPgN12r54urDH6SXNb0"},"href":"https://api.spotify.com/v1/tracks/22yiPgN12r54urDH6SXNb0","id":"22yiPgN12r54urDH6SXNb0","is_local":false,"is_playable":true,"name":"Homeward Glow","track_number":5,"type":"track","uri":"spotify:track:22yiPgN12r54urDH6SXNb0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tohVJC9TjZdlve56ttA6Y"},"href":"https://api.spotify.com/v1/albums/5tohVJC9TjZdlve56ttA6Y","id":"5tohVJC9TjZdlve56ttA6Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733002d315a39759f2f3418fbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023002d315a39759f2f3418fbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513002d315a39759f2f3418fbc"}],"is_playable":true,"name":"Cozy Fall Days","release_date":"2025-10-09","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5tohVJC9TjZdlve56ttA6Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":202679,"explicit":false,"external_ids":{"isrc":"QT3FA2534520"},"external_urls":{"spotify":"https://open.spotify.com/track/5Tb2ggSJ8UyerdxwIyZEV2"},"href":"https://api.spotify.com/v1/tracks/5Tb2ggSJ8UyerdxwIyZEV2","id":"5Tb2ggSJ8UyerdxwIyZEV2","is_local":false,"is_playable":true,"name":"Home in the Rain","track_number":7,"type":"track","uri":"spotify:track:5Tb2ggSJ8UyerdxwIyZEV2"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Q0tsXC2u6geWS9yydLdhM"},"href":"https://api.spotify.com/v1/artists/4Q0tsXC2u6geWS9yydLdhM","id":"4Q0tsXC2u6geWS9yydLdhM","name":"Theo Lens","type":"artist","uri":"spotify:artist:4Q0tsXC2u6geWS9yydLdhM"}],"external_urls":{"spotify":"https://open.spotify.com/album/58OKMDOKoIi3NZpxSVeKx9"},"href":"https://api.spotify.com/v1/albums/58OKMDOKoIi3NZpxSVeKx9","id":"58OKMDOKoIi3NZpxSVeKx9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27396fc5e3da6420f96cc44e3fa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0296fc5e3da6420f96cc44e3fa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485196fc5e3da6420f96cc44e3fa"}],"is_playable":true,"name":"Come Home","release_date":"2018-09-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:58OKMDOKoIi3NZpxSVeKx9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Q0tsXC2u6geWS9yydLdhM"},"href":"https://api.spotify.com/v1/artists/4Q0tsXC2u6geWS9yydLdhM","id":"4Q0tsXC2u6geWS9yydLdhM","name":"Theo Lens","type":"artist","uri":"spotify:artist:4Q0tsXC2u6geWS9yydLdhM"}],"disc_number":1,"duration_ms":245179,"explicit":false,"external_ids":{"isrc":"NLQM71100021"},"external_urls":{"spotify":"https://open.spotify.com/track/5MgN569Q9zmPH3g0rDdsd0"},"href":"https://api.spotify.com/v1/tracks/5MgN569Q9zmPH3g0rDdsd0","id":"5MgN569Q9zmPH3g0rDdsd0","is_local":false,"is_playable":true,"name":"Come Home","track_number":1,"type":"track","uri":"spotify:track:5MgN569Q9zmPH3g0rDdsd0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SL7qzFJXBTB8v0jCLqSPj"},"href":"https://api.spotify.com/v1/artists/0SL7qzFJXBTB8v0jCLqSPj","id":"0SL7qzFJXBTB8v0jCLqSPj","name":"Lenseye","type":"artist","uri":"spotify:artist:0SL7qzFJXBTB8v0jCLqSPj"}],"external_urls":{"spotify":"https://open.spotify.com/album/29zeJnRfGQadmfDsvDvum7"},"href":"https://api.spotify.com/v1/albums/29zeJnRfGQadmfDsvDvum7","id":"29zeJnRfGQadmfDsvDvum7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273045bd40fabb28e2bc12fd15b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02045bd40fabb28e2bc12fd15b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851045bd40fabb28e2bc12fd15b"}],"is_playable":true,"name":"September's Child","release_date":"2020-09-18","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:29zeJnRfGQadmfDsvDvum7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SL7qzFJXBTB8v0jCLqSPj"},"href":"https://api.spotify.com/v1/artists/0SL7qzFJXBTB8v0jCLqSPj","id":"0SL7qzFJXBTB8v0jCLqSPj","name":"Lenseye","type":"artist","uri":"spotify:artist:0SL7qzFJXBTB8v0jCLqSPj"}],"disc_number":1,"duration_ms":190052,"explicit":false,"external_ids":{"isrc":"QZHNB2066466"},"external_urls":{"spotify":"https://open.spotify.com/track/4ssnuvZhH7m78KIRcInzU4"},"href":"https://api.spotify.com/v1/tracks/4ssnuvZhH7m78KIRcInzU4","id":"4ssnuvZhH7m78KIRcInzU4","is_local":false,"is_playable":true,"name":"Homesick Atlantic Reverie","track_number":6,"type":"track","uri":"spotify:track:4ssnuvZhH7m78KIRcInzU4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lMM4E33eJTCESTA5DxAbo"},"href":"https://api.spotify.com/v1/artists/6lMM4E33eJTCESTA5DxAbo","id":"6lMM4E33eJTCESTA5DxAbo","name":"Dreamer Lens","type":"artist","uri":"spotify:artist:6lMM4E33eJTCESTA5DxAbo"}],"external_urls":{"spotify":"https://open.spotify.com/album/1ik8T9Rm8Vkr24Nx0jfTxe"},"href":"https://api.spotify.com/v1/albums/1ik8T9Rm8Vkr24Nx0jfTxe","id":"1ik8T9Rm8Vkr24Nx0jfTxe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e21c1f7740c79506ae78cd8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e21c1f7740c79506ae78cd8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e21c1f7740c79506ae78cd8"}],"is_playable":true,"name":"66 (inspired by true events)","release_date":"2026-06-27","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1ik8T9Rm8Vkr24Nx0jfTxe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lMM4E33eJTCESTA5DxAbo"},"href":"https://api.spotify.com/v1/artists/6lMM4E33eJTCESTA5DxAbo","id":"6lMM4E33eJTCESTA5DxAbo","name":"Dreamer Lens","type":"artist","uri":"spotify:artist:6lMM4E33eJTCESTA5DxAbo"}],"disc_number":1,"duration_ms":111719,"explicit":false,"external_ids":{"isrc":"CAENV2674840"},"external_urls":{"spotify":"https://open.spotify.com/track/3MiTAmlaA2cHfWuyjaVIzW"},"href":"https://api.spotify.com/v1/tracks/3MiTAmlaA2cHfWuyjaVIzW","id":"3MiTAmlaA2cHfWuyjaVIzW","is_local":false,"is_playable":true,"name":"Home (Reprise)","track_number":14,"type":"track","uri":"spotify:track:3MiTAmlaA2cHfWuyjaVIzW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5Jl09T3op2vhK2lk9aTt2D"},"href":"https://api.spotify.com/v1/artists/5Jl09T3op2vhK2lk9aTt2D","id":"5Jl09T3op2vhK2lk9aTt2D","name":"lensky","type":"artist","uri":"spotify:artist:5Jl09T3op2vhK2lk9aTt2D"}],"external_urls":{"spotify":"https://open.spotify.com/album/1LP2XJHfAsDU0vxFHsBeH1"},"href":"https://api.spotify.com/v1/albums/1LP2XJHfAsDU0vxFHsBeH1","id":"1LP2XJHfAsDU0vxFHsBeH1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730d9d0a92bd6523d6a45a3860"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020d9d0a92bd6523d6a45a3860"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510d9d0a92bd6523d6a45a3860"}],"is_playable":true,"name":"Demo Songs, Vol 1","release_date":"2022-09-04","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:1LP2XJHfAsDU0vxFHsBeH1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5Jl09T3op2vhK2lk9aTt2D"},"href":"https://api.spotify.com/v1/artists/5Jl09T3op2vhK2lk9aTt2D","id":"5Jl09T3op2vhK2lk9aTt2D","name":"lensky","type":"artist","uri":"spotify:artist:5Jl09T3op2vhK2lk9aTt2D"}],"disc_number":1,"duration_ms":208000,"explicit":false,"external_ids":{"isrc":"TCAGL2238557"},"external_urls":{"spotify":"https://open.spotify.com/track/2hafWXwcUvgtcxPliIprov"},"href":"https://api.spotify.com/v1/tracks/2hafWXwcUvgtcxPliIprov","id":"2hafWXwcUvgtcxPliIprov","is_local":false,"is_playable":true,"name":"Home Alone","track_number":5,"type":"track","uri":"spotify:track:2hafWXwcUvgtcxPliIprov"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Yi5cQGz7kDdjbioSPLy3N"},"href":"https://api.spotify.com/v1/artists/4Yi5cQGz7kDdjbioSPLy3N","id":"4Yi5cQGz7kDdjbioSPLy3N","name":"Lensoppa","type":"artist","uri":"spotify:artist:4Yi5cQGz7kDdjbioSPLy3N"}],"external_urls":{"spotify":"https://open.spotify.com/album/2RkWXPcpSJCB7qm6jWgXqM"},"href":"https://api.spotify.com/v1/albums/2RkWXPcpSJCB7qm6jWgXqM","id":"2RkWXPcpSJCB7qm6jWgXqM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736243f37008ab616e1ed8e074"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026243f37008ab616e1ed8e074"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516243f37008ab616e1ed8e074"}],"is_playable":true,"name":"Home Sweet Home","release_date":"2025-10-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2RkWXPcpSJCB7qm6jWgXqM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Yi5cQGz7kDdjbioSPLy3N"},"href":"https://api.spotify.com/v1/artists/4Yi5cQGz7kDdjbioSPLy3N","id":"4Yi5cQGz7kDdjbioSPLy3N","name":"Lensoppa","type":"artist","uri":"spotify:artist:4Yi5cQGz7kDdjbioSPLy3N"}],"disc_number":1,"duration_ms":219839,"explicit":false,"external_ids":{"isrc":"GX53U2687062"},"external_urls":{"spotify":"https://open.spotify.com/track/4IL7ZbMJlOCd67sWhfZrvR"},"href":"https://api.spotify.com/v1/tracks/4IL7ZbMJlOCd67sWhfZrvR","id":"4IL7ZbMJlOCd67sWhfZrvR","is_local":false,"is_playable":true,"name":"Home Sweet Home","track_number":1,"type":"track","uri":"spotify:track:4IL7ZbMJlOCd67sWhfZrvR"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Home%22+artist%3A%22Lens%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Slow%20Down%22%20artist%3A%22Sabre%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"}],"external_urls":{"spotify":"https://open.spotify.com/album/3AvjrWwSEgfZs0Ic7Srt8b"},"href":"https://api.spotify.com/v1/albums/3AvjrWwSEgfZs0Ic7Srt8b","id":"3AvjrWwSEgfZs0Ic7Srt8b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb6906ff39ee5ec9f230e05d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb6906ff39ee5ec9f230e05d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb6906ff39ee5ec9f230e05d"}],"is_playable":true,"name":"Slow Down (feat. Jorja Smith) [Vintage Culture & Slow Motion Remix]","release_date":"2020-04-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3AvjrWwSEgfZs0Ic7Srt8b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6jmHuLfbWlq34KedQ7mA5I"},"href":"https://api.spotify.com/v1/artists/6jmHuLfbWlq34KedQ7mA5I","id":"6jmHuLfbWlq34KedQ7mA5I","name":"Slow Motion","type":"artist","uri":"spotify:artist:6jmHuLfbWlq34KedQ7mA5I"}],"disc_number":1,"duration_ms":181306,"explicit":false,"external_ids":{"isrc":"NLZ542000356"},"external_urls":{"spotify":"https://open.spotify.com/track/5PNvgiKSwMdjBsDsgFCFLX"},"href":"https://api.spotify.com/v1/tracks/5PNvgiKSwMdjBsDsgFCFLX","id":"5PNvgiKSwMdjBsDsgFCFLX","is_local":false,"is_playable":true,"name":"Slow Down (feat. Jorja Smith) - Vintage Culture & Slow Motion Remix","track_number":1,"type":"track","uri":"spotify:track:5PNvgiKSwMdjBsDsgFCFLX"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4uRl0LZUcciuN8tfRQ3LRM"},"href":"https://api.spotify.com/v1/artists/4uRl0LZUcciuN8tfRQ3LRM","id":"4uRl0LZUcciuN8tfRQ3LRM","name":"James Cole","type":"artist","uri":"spotify:artist:4uRl0LZUcciuN8tfRQ3LRM"}],"external_urls":{"spotify":"https://open.spotify.com/album/3zrP0lDAbH8sF4219tbsX4"},"href":"https://api.spotify.com/v1/albums/3zrP0lDAbH8sF4219tbsX4","id":"3zrP0lDAbH8sF4219tbsX4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27372f04b49a8c224b162dd2ec1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0272f04b49a8c224b162dd2ec1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485172f04b49a8c224b162dd2ec1"}],"is_playable":true,"name":"Slow Down (James Cole Remix)","release_date":"2022-06-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3zrP0lDAbH8sF4219tbsX4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4uRl0LZUcciuN8tfRQ3LRM"},"href":"https://api.spotify.com/v1/artists/4uRl0LZUcciuN8tfRQ3LRM","id":"4uRl0LZUcciuN8tfRQ3LRM","name":"James Cole","type":"artist","uri":"spotify:artist:4uRl0LZUcciuN8tfRQ3LRM"}],"disc_number":1,"duration_ms":417999,"explicit":false,"external_ids":{"isrc":"QM6MZ2296397"},"external_urls":{"spotify":"https://open.spotify.com/track/7IasAOphluLSAmgMtg9jYA"},"href":"https://api.spotify.com/v1/tracks/7IasAOphluLSAmgMtg9jYA","id":"7IasAOphluLSAmgMtg9jYA","is_local":false,"is_playable":true,"name":"Slow Down - James Cole Remix","track_number":1,"type":"track","uri":"spotify:track:7IasAOphluLSAmgMtg9jYA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"}],"external_urls":{"spotify":"https://open.spotify.com/album/7fTeO9yatW5oHOJKKg6FfD"},"href":"https://api.spotify.com/v1/albums/7fTeO9yatW5oHOJKKg6FfD","id":"7fTeO9yatW5oHOJKKg6FfD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739624a6317434fea738b30a59"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029624a6317434fea738b30a59"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519624a6317434fea738b30a59"}],"is_playable":true,"name":"When I Wake Up","release_date":"2019-03-22","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7fTeO9yatW5oHOJKKg6FfD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"}],"disc_number":1,"duration_ms":211064,"explicit":false,"external_ids":{"isrc":"QM7281831525"},"external_urls":{"spotify":"https://open.spotify.com/track/3acsDG4uqWOGPidRAZkrqk"},"href":"https://api.spotify.com/v1/tracks/3acsDG4uqWOGPidRAZkrqk","id":"3acsDG4uqWOGPidRAZkrqk","is_local":false,"is_playable":true,"name":"Slow Down","track_number":6,"type":"track","uri":"spotify:track:3acsDG4uqWOGPidRAZkrqk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"}],"external_urls":{"spotify":"https://open.spotify.com/album/7CxbZH0zXsRFsGZJpvWdWT"},"href":"https://api.spotify.com/v1/albums/7CxbZH0zXsRFsGZJpvWdWT","id":"7CxbZH0zXsRFsGZJpvWdWT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273af43e92ed1f314d1cb103e28"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02af43e92ed1f314d1cb103e28"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851af43e92ed1f314d1cb103e28"}],"is_playable":true,"name":"Slow Down","release_date":"2019-02-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7CxbZH0zXsRFsGZJpvWdWT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"}],"disc_number":1,"duration_ms":211064,"explicit":false,"external_ids":{"isrc":"QM7281831525"},"external_urls":{"spotify":"https://open.spotify.com/track/0AqMAXSzkIRMV0alAddJK8"},"href":"https://api.spotify.com/v1/tracks/0AqMAXSzkIRMV0alAddJK8","id":"0AqMAXSzkIRMV0alAddJK8","is_local":false,"is_playable":true,"name":"Slow Down","track_number":1,"type":"track","uri":"spotify:track:0AqMAXSzkIRMV0alAddJK8"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"}],"external_urls":{"spotify":"https://open.spotify.com/album/7HiIZJHO9SNjFqorG8EzdK"},"href":"https://api.spotify.com/v1/albums/7HiIZJHO9SNjFqorG8EzdK","id":"7HiIZJHO9SNjFqorG8EzdK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dd7b0ab98825a71353610f1e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dd7b0ab98825a71353610f1e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dd7b0ab98825a71353610f1e"}],"is_playable":true,"name":"When I Wake up - Acoustic EP","release_date":"2019-11-15","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:7HiIZJHO9SNjFqorG8EzdK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"}],"disc_number":1,"duration_ms":156540,"explicit":false,"external_ids":{"isrc":"QMBZ91946473"},"external_urls":{"spotify":"https://open.spotify.com/track/4o905HLa1RQPXYBfxeCF16"},"href":"https://api.spotify.com/v1/tracks/4o905HLa1RQPXYBfxeCF16","id":"4o905HLa1RQPXYBfxeCF16","is_local":false,"is_playable":true,"name":"Slow Down (Acoustic)","track_number":5,"type":"track","uri":"spotify:track:4o905HLa1RQPXYBfxeCF16"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"}],"external_urls":{"spotify":"https://open.spotify.com/album/20ibOM2js2nQDPH9HdvX8z"},"href":"https://api.spotify.com/v1/albums/20ibOM2js2nQDPH9HdvX8z","id":"20ibOM2js2nQDPH9HdvX8z","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273193c67c717308ad598558667"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02193c67c717308ad598558667"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851193c67c717308ad598558667"}],"is_playable":true,"name":"Slow Down (feat. Jorja Smith) [Vintage Culture & Slow Motion Extended Remix]","release_date":"2020-04-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:20ibOM2js2nQDPH9HdvX8z"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6jmHuLfbWlq34KedQ7mA5I"},"href":"https://api.spotify.com/v1/artists/6jmHuLfbWlq34KedQ7mA5I","id":"6jmHuLfbWlq34KedQ7mA5I","name":"Slow Motion","type":"artist","uri":"spotify:artist:6jmHuLfbWlq34KedQ7mA5I"}],"disc_number":1,"duration_ms":315918,"explicit":false,"external_ids":{"isrc":"NLZ542000355"},"external_urls":{"spotify":"https://open.spotify.com/track/2WezsIqLHVPRcAEj2LzJyH"},"href":"https://api.spotify.com/v1/tracks/2WezsIqLHVPRcAEj2LzJyH","id":"2WezsIqLHVPRcAEj2LzJyH","is_local":false,"is_playable":true,"name":"Slow Down (feat. Jorja Smith) - Vintage Culture & Slow Motion Extended Remix","track_number":1,"type":"track","uri":"spotify:track:2WezsIqLHVPRcAEj2LzJyH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1YHgmpWhi4KfAPsVaxlHPJ"},"href":"https://api.spotify.com/v1/albums/1YHgmpWhi4KfAPsVaxlHPJ","id":"1YHgmpWhi4KfAPsVaxlHPJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734500df4b9fdfeedbe0be2986"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024500df4b9fdfeedbe0be2986"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514500df4b9fdfeedbe0be2986"}],"is_playable":true,"name":"club bangerz 20's edition","release_date":"2025-08-30","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:1YHgmpWhi4KfAPsVaxlHPJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6jmHuLfbWlq34KedQ7mA5I"},"href":"https://api.spotify.com/v1/artists/6jmHuLfbWlq34KedQ7mA5I","id":"6jmHuLfbWlq34KedQ7mA5I","name":"Slow Motion","type":"artist","uri":"spotify:artist:6jmHuLfbWlq34KedQ7mA5I"}],"disc_number":1,"duration_ms":181306,"explicit":false,"external_ids":{"isrc":"NLZ542000356"},"external_urls":{"spotify":"https://open.spotify.com/track/0P8AWSZgbjH1JS3ajwEizT"},"href":"https://api.spotify.com/v1/tracks/0P8AWSZgbjH1JS3ajwEizT","id":"0P8AWSZgbjH1JS3ajwEizT","is_local":false,"is_playable":true,"name":"Slow Down (feat. Jorja Smith) - Vintage Culture & Slow Motion Remix","track_number":7,"type":"track","uri":"spotify:track:0P8AWSZgbjH1JS3ajwEizT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TxnVP3YmFrUqFrUuEPzJ4"},"href":"https://api.spotify.com/v1/artists/6TxnVP3YmFrUqFrUuEPzJ4","id":"6TxnVP3YmFrUqFrUuEPzJ4","name":"SABRE","type":"artist","uri":"spotify:artist:6TxnVP3YmFrUqFrUuEPzJ4"}],"external_urls":{"spotify":"https://open.spotify.com/album/6TQw1M1Bk9uvuSQCJbWsPa"},"href":"https://api.spotify.com/v1/albums/6TQw1M1Bk9uvuSQCJbWsPa","id":"6TQw1M1Bk9uvuSQCJbWsPa","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27344362a70f896804092f37a6a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0244362a70f896804092f37a6a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485144362a70f896804092f37a6a"}],"is_playable":true,"name":"Energy","release_date":"2024-11-09","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:6TQw1M1Bk9uvuSQCJbWsPa"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TxnVP3YmFrUqFrUuEPzJ4"},"href":"https://api.spotify.com/v1/artists/6TxnVP3YmFrUqFrUuEPzJ4","id":"6TxnVP3YmFrUqFrUuEPzJ4","name":"SABRE","type":"artist","uri":"spotify:artist:6TxnVP3YmFrUqFrUuEPzJ4"}],"disc_number":1,"duration_ms":144585,"explicit":false,"external_ids":{"isrc":"QZZ792418372"},"external_urls":{"spotify":"https://open.spotify.com/track/4VnV74ynXxjh7HKvAOHuYx"},"href":"https://api.spotify.com/v1/tracks/4VnV74ynXxjh7HKvAOHuYx","id":"4VnV74ynXxjh7HKvAOHuYx","is_local":false,"is_playable":true,"name":"Energy - Slowed Down","track_number":3,"type":"track","uri":"spotify:track:4VnV74ynXxjh7HKvAOHuYx"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6qIEGNEtCXXssFHoLemxVh"},"href":"https://api.spotify.com/v1/albums/6qIEGNEtCXXssFHoLemxVh","id":"6qIEGNEtCXXssFHoLemxVh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27367121862e4c4232cbd61552d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0267121862e4c4232cbd61552d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485167121862e4c4232cbd61552d"}],"is_playable":true,"name":"Afro House Ultra","release_date":"2026-05-03","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6qIEGNEtCXXssFHoLemxVh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6jmHuLfbWlq34KedQ7mA5I"},"href":"https://api.spotify.com/v1/artists/6jmHuLfbWlq34KedQ7mA5I","id":"6jmHuLfbWlq34KedQ7mA5I","name":"Slow Motion","type":"artist","uri":"spotify:artist:6jmHuLfbWlq34KedQ7mA5I"}],"disc_number":1,"duration_ms":181306,"explicit":false,"external_ids":{"isrc":"NLZ542000356"},"external_urls":{"spotify":"https://open.spotify.com/track/5EE1ogMfKGMLL4HhUGqBPF"},"href":"https://api.spotify.com/v1/tracks/5EE1ogMfKGMLL4HhUGqBPF","id":"5EE1ogMfKGMLL4HhUGqBPF","is_local":false,"is_playable":true,"name":"Slow Down (feat. Jorja Smith) - Vintage Culture & Slow Motion Remix","track_number":10,"type":"track","uri":"spotify:track:5EE1ogMfKGMLL4HhUGqBPF"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNsb3clMjBEb3duJTIyJTIwYXJ0aXN0JTNBJTIyU2FicmUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjksIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJpZCI6IjB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJuYW1lIjoiTWF2ZXJpY2sgU2FicmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xQ29aeUl4N1V2ZHhUNWM4VWtNekhkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFDb1p5SXg3VXZkeFQ1YzhVa016SGQiLCJpZCI6IjFDb1p5SXg3VXZkeFQ1YzhVa016SGQiLCJuYW1lIjoiSm9yamEgU21pdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUNvWnlJeDdVdmR4VDVjOFVrTXpIZCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yOHVKbnU1RXNyR21sMnRCZDd5OHRzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI4dUpudTVFc3JHbWwydEJkN3k4dHMiLCJpZCI6IjI4dUpudTVFc3JHbWwydEJkN3k4dHMiLCJuYW1lIjoiVmludGFnZSBDdWx0dXJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI4dUpudTVFc3JHbWwydEJkN3k4dHMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zQXZqcld3U0VnZlpzMEljN1NydDhiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0F2anJXd1NFZ2ZaczBJYzdTcnQ4YiIsImlkIjoiM0F2anJXd1NFZ2ZaczBJYzdTcnQ4YiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmYjY5MDZmZjM5ZWU1ZWM5ZjIzMGUwNWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cg==", + "bCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmYjY5MDZmZjM5ZWU1ZWM5ZjIzMGUwNWQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWZiNjkwNmZmMzllZTVlYzlmMjMwZTA1ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbG93IERvd24gKGZlYXQuIEpvcmphIFNtaXRoKSBbVmludGFnZSBDdWx0dXJlICYgU2xvdyBNb3Rpb24gUmVtaXhdIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wNC0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0F2anJXd1NFZ2ZaczBJYzdTcnQ4YiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzB1a2dyTllrNTFUa01RcjBmMkJyNFEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USIsImlkIjoiMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USIsIm5hbWUiOiJNYXZlcmljayBTYWJyZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowdWtnck5ZazUxVGtNUXIwZjJCcjRRIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFDb1p5SXg3VXZkeFQ1YzhVa016SGQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUNvWnlJeDdVdmR4VDVjOFVrTXpIZCIsImlkIjoiMUNvWnlJeDdVdmR4VDVjOFVrTXpIZCIsIm5hbWUiOiJKb3JqYSBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxQ29aeUl4N1V2ZHhUNWM4VWtNekhkIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI4dUpudTVFc3JHbWwydEJkN3k4dHMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjh1Sm51NUVzckdtbDJ0QmQ3eTh0cyIsImlkIjoiMjh1Sm51NUVzckdtbDJ0QmQ3eTh0cyIsIm5hbWUiOiJWaW50YWdlIEN1bHR1cmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mjh1Sm51NUVzckdtbDJ0QmQ3eTh0cyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82am1IdUxmYldscTM0S2VkUTdtQTVJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZqbUh1TGZiV2xxMzRLZWRRN21BNUkiLCJpZA==", + "IjoiNmptSHVMZmJXbHEzNEtlZFE3bUE1SSIsIm5hbWUiOiJTbG93IE1vdGlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2am1IdUxmYldscTM0S2VkUTdtQTVJIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4MTMwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MWjU0MjAwMDM1NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVBOdmdpS1N3TWRqQnNEc2dGQ0ZMWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVQTnZnaUtTd01kakJzRHNnRkNGTFgiLCJpZCI6IjVQTnZnaUtTd01kakJzRHNnRkNGTFgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2xvdyBEb3duIChmZWF0LiBKb3JqYSBTbWl0aCkgLSBWaW50YWdlIEN1bHR1cmUgJiBTbG93IE1vdGlvbiBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1UE52Z2lLU3dNZGpCc0RzZ0ZDRkxYIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJpZCI6IjB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJuYW1lIjoiTWF2ZXJpY2sgU2FicmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xQ29aeUl4N1V2ZHhUNWM4VWtNekhkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFDb1p5SXg3VXZkeFQ1YzhVa016SGQiLCJpZCI6IjFDb1p5SXg3VXZkeFQ1YzhVa016SGQiLCJuYW1lIjoiSm9yamEgU21pdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUNvWnlJeDdVdmR4VDVjOFVrTXpIZCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80dVJsMExaVWNjaXVOOHRmUlEzTFJNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzR1UmwwTFpVY2NpdU44dGZSUTNMUk0iLCJpZCI6IjR1UmwwTFpVY2NpdU44dGZSUTNMUk0iLCJuYW1lIjoiSmFtZXMgQ29sZSIsInR5cGUiOiJhcnRpc3QiLCJ1cg==", + "aSI6InNwb3RpZnk6YXJ0aXN0OjR1UmwwTFpVY2NpdU44dGZSUTNMUk0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zenJQMGxEQWJIOHNGNDIxOXRic1g0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM3pyUDBsREFiSDhzRjQyMTl0YnNYNCIsImlkIjoiM3pyUDBsREFiSDhzRjQyMTl0YnNYNCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3MmYwNGI0OWE4YzIyNGIxNjJkZDJlYzEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzJmMDRiNDlhOGMyMjRiMTYyZGQyZWMxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3MmYwNGI0OWE4YzIyNGIxNjJkZDJlYzEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2xvdyBEb3duIChKYW1lcyBDb2xlIFJlbWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMjItMDYtMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjN6clAwbERBYkg4c0Y0MjE5dGJzWDQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJpZCI6IjB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJuYW1lIjoiTWF2ZXJpY2sgU2FicmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xQ29aeUl4N1V2ZHhUNWM4VWtNekhkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFDb1p5SXg3VXZkeFQ1YzhVa016SGQiLCJpZCI6IjFDb1p5SXg3VXZkeFQ1YzhVa016SGQiLCJuYW1lIjoiSm9yamEgU21pdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUNvWnlJeDdVdmR4VDVjOFVrTXpIZCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80dVJsMExaVWNjaXVOOHRmUlEzTFJNIn0sImhyZWYiOiJodHRwczovLw==", + "YXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHVSbDBMWlVjY2l1Tjh0ZlJRM0xSTSIsImlkIjoiNHVSbDBMWlVjY2l1Tjh0ZlJRM0xSTSIsIm5hbWUiOiJKYW1lcyBDb2xlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjR1UmwwTFpVY2NpdU44dGZSUTNMUk0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDE3OTk5LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU02TVoyMjk2Mzk3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83SWFzQU9waGx1TFNBbWdNdGc5allBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN0lhc0FPcGhsdUxTQW1nTXRnOWpZQSIsImlkIjoiN0lhc0FPcGhsdUxTQW1nTXRnOWpZQSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbG93IERvd24gLSBKYW1lcyBDb2xlIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdJYXNBT3BobHVMU0FtZ010ZzlqWUEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwiaWQiOiIwdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwibmFtZSI6Ik1hdmVyaWNrIFNhYnJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjB1a2dyTllrNTFUa01RcjBmMkJyNFEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83ZlRlTzl5YXRXNW9IT0pLS2c2RmZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN2ZUZU85eWF0VzVvSE9KS0tnNkZmRCIsImlkIjoiN2ZUZU85eWF0VzVvSE9KS0tnNkZmRCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5NjI0YTYzMTc0MzRmZWE3MzhiMzBhNTkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTYyNGE2MzE3NDM0ZmVhNzM4YjMwYTU5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5NjI0YTYzMTc0MzRmZQ==", + "YTczOGIzMGE1OSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXaGVuIEkgV2FrZSBVcCIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDMtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3ZlRlTzl5YXRXNW9IT0pLS2c2RmZEIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwiaWQiOiIwdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwibmFtZSI6Ik1hdmVyaWNrIFNhYnJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjB1a2dyTllrNTFUa01RcjBmMkJyNFEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMUNvWnlJeDdVdmR4VDVjOFVrTXpIZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xQ29aeUl4N1V2ZHhUNWM4VWtNekhkIiwiaWQiOiIxQ29aeUl4N1V2ZHhUNWM4VWtNekhkIiwibmFtZSI6IkpvcmphIFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFDb1p5SXg3VXZkeFQ1YzhVa016SGQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjExMDY0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU03MjgxODMxNTI1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zYWNzREc0dXFXT0dQaWRSQVprcnFrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM2Fjc0RHNHVxV09HUGlkUkFaa3JxayIsImlkIjoiM2Fjc0RHNHVxV09HUGlkUkFaa3JxayIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbG93IERvd24iLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2Fjc0RHNHVxV09HUGlkUkFaa3JxayJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwiaWQiOiIwdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwibg==", + "YW1lIjoiTWF2ZXJpY2sgU2FicmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdDeGJaSDB6WHNSRnNHWkpwdldkV1QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83Q3hiWkgwelhzUkZzR1pKcHZXZFdUIiwiaWQiOiI3Q3hiWkgwelhzUkZzR1pKcHZXZFdUIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FmNDNlOTJlZDFmMzE0ZDFjYjEwM2UyOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhZjQzZTkyZWQxZjMxNGQxY2IxMDNlMjgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFmNDNlOTJlZDFmMzE0ZDFjYjEwM2UyOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbG93IERvd24iLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTAyLTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3Q3hiWkgwelhzUkZzR1pKcHZXZFdUIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwiaWQiOiIwdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwibmFtZSI6Ik1hdmVyaWNrIFNhYnJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjB1a2dyTllrNTFUa01RcjBmMkJyNFEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMUNvWnlJeDdVdmR4VDVjOFVrTXpIZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xQ29aeUl4N1V2ZHhUNWM4VWtNekhkIiwiaWQiOiIxQ29aeUl4N1V2ZHhUNWM4VWtNekhkIiwibmFtZSI6IkpvcmphIFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFDb1p5SXg3VXZkeFQ1YzhVa016SGQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjExMDY0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUQ==", + "TTcyODE4MzE1MjUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBBcU1BWFN6a0lSTVYwYWxBZGRKSzgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wQXFNQVhTemtJUk1WMGFsQWRkSks4IiwiaWQiOiIwQXFNQVhTemtJUk1WMGFsQWRkSks4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNsb3cgRG93biIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowQXFNQVhTemtJUk1WMGFsQWRkSks4In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJpZCI6IjB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJuYW1lIjoiTWF2ZXJpY2sgU2FicmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdIaUlaSkhPOVNOakZxb3JHOEV6ZEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83SGlJWkpITzlTTmpGcW9yRzhFemRLIiwiaWQiOiI3SGlJWkpITzlTTmpGcW9yRzhFemRLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2RkN2IwYWI5ODgyNWE3MTM1MzYxMGYxZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkZDdiMGFiOTg4MjVhNzEzNTM2MTBmMWUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWRkN2IwYWI5ODgyNWE3MTM1MzYxMGYxZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXaGVuIEkgV2FrZSB1cCAtIEFjb3VzdGljIEVQIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0xMS0xNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0hpSVpKSE85U05qRnFvckc4RXpkSyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4ucw==", + "cG90aWZ5LmNvbS9hcnRpc3QvMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwiaWQiOiIwdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwibmFtZSI6Ik1hdmVyaWNrIFNhYnJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjB1a2dyTllrNTFUa01RcjBmMkJyNFEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTU2NTQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU1CWjkxOTQ2NDczIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80bzkwNUhMYTFSUVBYWUJmeGVDRjE2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNG85MDVITGExUlFQWFlCZnhlQ0YxNiIsImlkIjoiNG85MDVITGExUlFQWFlCZnhlQ0YxNiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbG93IERvd24gKEFjb3VzdGljKSIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0bzkwNUhMYTFSUVBYWUJmeGVDRjE2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJpZCI6IjB1a2dyTllrNTFUa01RcjBmMkJyNFEiLCJuYW1lIjoiTWF2ZXJpY2sgU2FicmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yOHVKbnU1RXNyR21sMnRCZDd5OHRzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI4dUpudTVFc3JHbWwydEJkN3k4dHMiLCJpZCI6IjI4dUpudTVFc3JHbWwydEJkN3k4dHMiLCJuYW1lIjoiVmludGFnZSBDdWx0dXJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI4dUpudTVFc3JHbWwydEJkN3k4dHMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yMGliT00yanMyblFEUEg5SGR2WDh6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMjBpYk9NMmpzMm5RRFBIOUhkdlg4eg==", + "IiwiaWQiOiIyMGliT00yanMyblFEUEg5SGR2WDh6IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE5M2M2N2M3MTczMDhhZDU5ODU1ODY2NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxOTNjNjdjNzE3MzA4YWQ1OTg1NTg2NjcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE5M2M2N2M3MTczMDhhZDU5ODU1ODY2NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbG93IERvd24gKGZlYXQuIEpvcmphIFNtaXRoKSBbVmludGFnZSBDdWx0dXJlICYgU2xvdyBNb3Rpb24gRXh0ZW5kZWQgUmVtaXhdIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wNC0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MjBpYk9NMmpzMm5RRFBIOUhkdlg4eiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzB1a2dyTllrNTFUa01RcjBmMkJyNFEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USIsImlkIjoiMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USIsIm5hbWUiOiJNYXZlcmljayBTYWJyZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowdWtnck5ZazUxVGtNUXIwZjJCcjRRIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFDb1p5SXg3VXZkeFQ1YzhVa016SGQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUNvWnlJeDdVdmR4VDVjOFVrTXpIZCIsImlkIjoiMUNvWnlJeDdVdmR4VDVjOFVrTXpIZCIsIm5hbWUiOiJKb3JqYSBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxQ29aeUl4N1V2ZHhUNWM4VWtNekhkIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI4dUpudTVFc3JHbWwydEJkN3k4dHMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjh1Sm51NUVzckdtbDJ0QmQ3eTh0cyIsImlkIjoiMjh1Sm51NUVzckdtbDJ0QmQ3eTh0cyIsIm5hbWUiOiJWaW50YWdlIEN1bHR1cmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mg==", + "OHVKbnU1RXNyR21sMnRCZDd5OHRzIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZqbUh1TGZiV2xxMzRLZWRRN21BNUkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmptSHVMZmJXbHEzNEtlZFE3bUE1SSIsImlkIjoiNmptSHVMZmJXbHEzNEtlZFE3bUE1SSIsIm5hbWUiOiJTbG93IE1vdGlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2am1IdUxmYldscTM0S2VkUTdtQTVJIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMxNTkxOCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MWjU0MjAwMDM1NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMldlenNJcUxIVlBSY0FFajJMekp5SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJXZXpzSXFMSFZQUmNBRWoyTHpKeUgiLCJpZCI6IjJXZXpzSXFMSFZQUmNBRWoyTHpKeUgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2xvdyBEb3duIChmZWF0LiBKb3JqYSBTbWl0aCkgLSBWaW50YWdlIEN1bHR1cmUgJiBTbG93IE1vdGlvbiBFeHRlbmRlZCBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyV2V6c0lxTEhWUFJjQUVqMkx6SnlIIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFZSGdtcFdoaTRLZkFQc1ZheGxIUEoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xWUhnbXBXaGk0S2ZBUHNWYXhsSFBKIiwiaWQiOiIxWUhnbXBXaGk0S2ZBUHNWYXhsSFBKIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQ1MDBkZjRiOWZkZmVlZGJlMGJlMjk4NiJ9LHsiaA==", + "ZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQ1MDBkZjRiOWZkZmVlZGJlMGJlMjk4NiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDUwMGRmNGI5ZmRmZWVkYmUwYmUyOTg2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6ImNsdWIgYmFuZ2VyeiAyMCdzIGVkaXRpb24iLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA4LTMwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVlIZ21wV2hpNEtmQVBzVmF4bEhQSiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzB1a2dyTllrNTFUa01RcjBmMkJyNFEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USIsImlkIjoiMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USIsIm5hbWUiOiJNYXZlcmljayBTYWJyZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowdWtnck5ZazUxVGtNUXIwZjJCcjRRIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFDb1p5SXg3VXZkeFQ1YzhVa016SGQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUNvWnlJeDdVdmR4VDVjOFVrTXpIZCIsImlkIjoiMUNvWnlJeDdVdmR4VDVjOFVrTXpIZCIsIm5hbWUiOiJKb3JqYSBTbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxQ29aeUl4N1V2ZHhUNWM4VWtNekhkIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI4dUpudTVFc3JHbWwydEJkN3k4dHMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjh1Sm51NUVzckdtbDJ0QmQ3eTh0cyIsImlkIjoiMjh1Sm51NUVzckdtbDJ0QmQ3eTh0cyIsIm5hbWUiOiJWaW50YWdlIEN1bHR1cmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mjh1Sm51NUVzckdtbDJ0QmQ3eTh0cyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82am1IdUxmYldscTM0S2VkUTdtQTVJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZqbUh1TGZiV2xxMzRLZWRRN21BNUkiLCJpZCI6IjZqbUh1TGZiV2xxMw==", + "NEtlZFE3bUE1SSIsIm5hbWUiOiJTbG93IE1vdGlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2am1IdUxmYldscTM0S2VkUTdtQTVJIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4MTMwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MWjU0MjAwMDM1NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMFA4QVdTWmdiakgxSlMzYWp3RWl6VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBQOEFXU1pnYmpIMUpTM2Fqd0VpelQiLCJpZCI6IjBQOEFXU1pnYmpIMUpTM2Fqd0VpelQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2xvdyBEb3duIChmZWF0LiBKb3JqYSBTbWl0aCkgLSBWaW50YWdlIEN1bHR1cmUgJiBTbG93IE1vdGlvbiBSZW1peCIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowUDhBV1NaZ2JqSDFKUzNhandFaXpUIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82VHhuVlAzWW1GclVxRnJVdUVQeko0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZUeG5WUDNZbUZyVXFGclV1RVB6SjQiLCJpZCI6IjZUeG5WUDNZbUZyVXFGclV1RVB6SjQiLCJuYW1lIjoiU0FCUkUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlR4blZQM1ltRnJVcUZyVXVFUHpKNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZUUXcxTTFCazl1dnVTUUNKYldzUGEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82VFF3MU0xQms5dXZ1U1FDSmJXc1BhIiwiaWQiOiI2VFF3MU0xQms5dXZ1U1FDSmJXc1BhIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQ0MzYyYTcwZjg5NjgwNDA5MmYzN2E2YSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0NDM2MmE3MGY4OTY4MDQwOTJmMzdhNmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQ0MzYyYTcwZjg5NjgwNDA5MmYzN2E2YSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbQ==", + "ZSI6IkVuZXJneSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMTEtMDkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZUUXcxTTFCazl1dnVTUUNKYldzUGEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82VHhuVlAzWW1GclVxRnJVdUVQeko0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZUeG5WUDNZbUZyVXFGclV1RVB6SjQiLCJpZCI6IjZUeG5WUDNZbUZyVXFGclV1RVB6SjQiLCJuYW1lIjoiU0FCUkUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlR4blZQM1ltRnJVcUZyVXVFUHpKNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDQ1ODUsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWlo3OTI0MTgzNzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRWblY3NHluWHhqaDdIS3ZBT0h1WXgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80Vm5WNzR5blh4amg3SEt2QU9IdVl4IiwiaWQiOiI0Vm5WNzR5blh4amg3SEt2QU9IdVl4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVuZXJneSAtIFNsb3dlZCBEb3duIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRWblY3NHluWHhqaDdIS3ZBT0h1WXgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNnFJRUdORXRDWFhzc0ZIb0xlbXhWaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZxSUVHTkV0Q1hYc3NGSG9MZW14VmgiLCJpZCI6IjZxSUVHTkV0Q1hYc3NGSG9MZW14VmgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cg==", + "bCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2NzEyMTg2MmU0YzQyMzJjYmQ2MTU1MmQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNjcxMjE4NjJlNGM0MjMyY2JkNjE1NTJkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2NzEyMTg2MmU0YzQyMzJjYmQ2MTU1MmQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWZybyBIb3VzZSBVbHRyYSIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDUtMDMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2cUlFR05FdENYWHNzRkhvTGVteFZoIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMHVrZ3JOWWs1MVRrTVFyMGYyQnI0USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwiaWQiOiIwdWtnck5ZazUxVGtNUXIwZjJCcjRRIiwibmFtZSI6Ik1hdmVyaWNrIFNhYnJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjB1a2dyTllrNTFUa01RcjBmMkJyNFEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMUNvWnlJeDdVdmR4VDVjOFVrTXpIZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xQ29aeUl4N1V2ZHhUNWM4VWtNekhkIiwiaWQiOiIxQ29aeUl4N1V2ZHhUNWM4VWtNekhkIiwibmFtZSI6IkpvcmphIFNtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFDb1p5SXg3VXZkeFQ1YzhVa016SGQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjh1Sm51NUVzckdtbDJ0QmQ3eTh0cyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yOHVKbnU1RXNyR21sMnRCZDd5OHRzIiwiaWQiOiIyOHVKbnU1RXNyR21sMnRCZDd5OHRzIiwibmFtZSI6IlZpbnRhZ2UgQ3VsdHVyZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyOHVKbnU1RXNyR21sMnRCZDd5OHRzIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZqbUh1TGZiV2xxMzRLZWRRN21BNUkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLg==", + "c3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82am1IdUxmYldscTM0S2VkUTdtQTVJIiwiaWQiOiI2am1IdUxmYldscTM0S2VkUTdtQTVJIiwibmFtZSI6IlNsb3cgTW90aW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZqbUh1TGZiV2xxMzRLZWRRN21BNUkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTgxMzA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxaNTQyMDAwMzU2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81RUUxb2dNZktHTUxMNEhoVUdxQlBGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUVFMW9nTWZLR01MTDRIaFVHcUJQRiIsImlkIjoiNUVFMW9nTWZLR01MTDRIaFVHcUJQRiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbG93IERvd24gKGZlYXQuIEpvcmphIFNtaXRoKSAtIFZpbnRhZ2UgQ3VsdHVyZSAmIFNsb3cgTW90aW9uIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1RUUxb2dNZktHTUxMNEhoVUdxQlBGIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Slow+Down%22+artist%3A%22Sabre%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1NaXNzaW5nJTIwRmxvd2lkdXMmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81cUM5N1VUY3MzQXhhRTAyYnpmeVNYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVxQzk3VVRjczNBeGFFMDJiemZ5U1giLCJpZCI6IjVxQzk3VVRjczNBeGFFMDJiemZ5U1giLCJuYW1lIjoiSE9SVVMgU0FNTSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1cUM5N1VUY3MzQXhhRTAyYnpmeVNYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFpBS0lPN1cxMmI2cmtPWmdoR3FMMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRaQUtJTzdXMTJiNnJrT1pnaEdxTDAiLCJpZCI6IjRaQUtJTzdXMTJiNnJrT1pnaEdxTDAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTMzZDlkNGRhZjE4Y2MzMg==", + "YmQ1ZGYzNDUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTMzZDlkNGRhZjE4Y2MzMmJkNWRmMzQ1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5MzNkOWQ0ZGFmMThjYzMyYmQ1ZGYzNDUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWlzc2luZyIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMTItMzEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRaQUtJTzdXMTJiNnJrT1pnaEdxTDAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81cUM5N1VUY3MzQXhhRTAyYnpmeVNYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVxQzk3VVRjczNBeGFFMDJiemZ5U1giLCJpZCI6IjVxQzk3VVRjczNBeGFFMDJiemZ5U1giLCJuYW1lIjoiSE9SVVMgU0FNTSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1cUM5N1VUY3MzQXhhRTAyYnpmeVNYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEyNDUwNCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaRllYMjY0NzY3NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMERhY3l1TzRQZmFPREFMWU5DOVhpVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBEYWN5dU80UGZhT0RBTFlOQzlYaVciLCJpZCI6IjBEYWN5dU80UGZhT0RBTFlOQzlYaVciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWlzc2luZyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowRGFjeXVPNFBmYU9EQUxZTkM5WGlXIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yWDNJbnZ0OGxZR203Y3padkZVUENqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJYM0ludnQ4bFlHbTdjelp2RlVQQ2oiLCJpZCI6IjJYM0ludnQ4bFlHbTdjelp2RlVQQ2oiLCJuYW1lIjoiTWl5a2xvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJYM0ludnQ4bFlHbTdjelp2RlVQQ2oifV0sImV4dGVybg==", + "YWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZwbzFSbXJ4RUYxR3ZCakNrVmdQeU8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82cG8xUm1yeEVGMUd2QmpDa1ZnUHlPIiwiaWQiOiI2cG8xUm1yeEVGMUd2QmpDa1ZnUHlPIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2RmMTc1YTI3ZGRmYTYzMzgzZDM0MWM5YiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkZjE3NWEyN2RkZmE2MzM4M2QzNDFjOWIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWRmMTc1YTI3ZGRmYTYzMzgzZDM0MWM5YiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGbG93aW5nIExpbmVzIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMi0xNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NnBvMVJtcnhFRjFHdkJqQ2tWZ1B5TyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJYM0ludnQ4bFlHbTdjelp2RlVQQ2oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlgzSW52dDhsWUdtN2N6WnZGVVBDaiIsImlkIjoiMlgzSW52dDhsWUdtN2N6WnZGVVBDaiIsIm5hbWUiOiJNaXlrbG8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlgzSW52dDhsWUdtN2N6WnZGVVBDaiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTUzNjQsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWkFLQjI0NTY0ODUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFKSE52eTNCNlA2WURjVnlObkdMN24ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xSkhOdnkzQjZQNllEY1Z5Tm5HTDduIiwiaWQiOiIxSkhOdnkzQjZQNllEY1Z5Tm5HTDduIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZsb3dpbmcgTGluZXMiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUpITnZ5M0I2UDZZRGNWeU5uR0w3biJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Missing+Flowidus&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Redbone%22%20artist%3A%22Childish%20Gambino%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"external_urls":{"spotify":"https://open.spotify.com/album/4JCybsNZUXWrK2Jpyn12Ni"},"href":"https://api.spotify.com/v1/albums/4JCybsNZUXWrK2Jpyn12Ni","id":"4JCybsNZUXWrK2Jpyn12Ni","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c29562d6e8c1f55bb1311d5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c29562d6e8c1f55bb1311d5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c29562d6e8c1f55bb1311d5"}],"is_playable":true,"name":"\"Awaken, My Love!\"","release_date":"2016-12-02","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4JCybsNZUXWrK2Jpyn12Ni"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326933,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/3vQ4T78TTMOjQXGfXVKQJo"},"href":"https://api.spotify.com/v1/tracks/3vQ4T78TTMOjQXGfXVKQJo","id":"3vQ4T78TTMOjQXGfXVKQJo","is_local":false,"is_playable":true,"name":"Redbone","track_number":6,"type":"track","uri":"spotify:track:3vQ4T78TTMOjQXGfXVKQJo"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4zudhmy5HSHVZ1y3gPfbAB"},"href":"https://api.spotify.com/v1/albums/4zudhmy5HSHVZ1y3gPfbAB","id":"4zudhmy5HSHVZ1y3gPfbAB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27372c666e8feebbb65253e4fba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0272c666e8feebbb65253e4fba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485172c666e8feebbb65253e4fba"}],"is_playable":true,"name":"Catch Feels","release_date":"2017-08-25","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:4zudhmy5HSHVZ1y3gPfbAB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":325272,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/1DFKBDsyc5eZKp7rhzMeNL"},"href":"https://api.spotify.com/v1/tracks/1DFKBDsyc5eZKp7rhzMeNL","id":"1DFKBDsyc5eZKp7rhzMeNL","is_local":false,"is_playable":true,"name":"Redbone","track_number":4,"type":"track","uri":"spotify:track:1DFKBDsyc5eZKp7rhzMeNL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7039WzytxariZTo4tsLUQF"},"href":"https://api.spotify.com/v1/albums/7039WzytxariZTo4tsLUQF","id":"7039WzytxariZTo4tsLUQF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27352bc5b49e2100091d225f95d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0252bc5b49e2100091d225f95d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485152bc5b49e2100091d225f95d"}],"is_playable":true,"name":"Nova Tunes 3.5","release_date":"2017-03-17","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7039WzytxariZTo4tsLUQF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":324226,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/3aXo6nJjexSdb6wCpN7Ysy"},"href":"https://api.spotify.com/v1/tracks/3aXo6nJjexSdb6wCpN7Ysy","id":"3aXo6nJjexSdb6wCpN7Ysy","is_local":false,"is_playable":true,"name":"Redbone","track_number":8,"type":"track","uri":"spotify:track:3aXo6nJjexSdb6wCpN7Ysy"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/37vQAfEaacxeV4MGN31e9D"},"href":"https://api.spotify.com/v1/albums/37vQAfEaacxeV4MGN31e9D","id":"37vQAfEaacxeV4MGN31e9D","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b230fc4671b83d89951dd23f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b230fc4671b83d89951dd23f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b230fc4671b83d89951dd23f"}],"is_playable":true,"name":"R&Bae","release_date":"2017-07-07","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:37vQAfEaacxeV4MGN31e9D"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":325960,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/41OPM65MGwtCT0D4iAJ6qP"},"href":"https://api.spotify.com/v1/tracks/41OPM65MGwtCT0D4iAJ6qP","id":"41OPM65MGwtCT0D4iAJ6qP","is_local":false,"is_playable":true,"name":"Redbone","track_number":1,"type":"track","uri":"spotify:track:41OPM65MGwtCT0D4iAJ6qP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5TszsWpms1lnB7c6EJ4Ux2"},"href":"https://api.spotify.com/v1/albums/5TszsWpms1lnB7c6EJ4Ux2","id":"5TszsWpms1lnB7c6EJ4Ux2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c05d415d1a371eadd2c4023"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c05d415d1a371eadd2c4023"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c05d415d1a371eadd2c4023"}],"is_playable":true,"name":"Hip Hop Love Songs","release_date":"2017-11-17","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:5TszsWpms1lnB7c6EJ4Ux2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326933,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/6u29Or89nZ784Mhgp1cuz4"},"href":"https://api.spotify.com/v1/tracks/6u29Or89nZ784Mhgp1cuz4","id":"6u29Or89nZ784Mhgp1cuz4","is_local":false,"is_playable":true,"name":"Redbone","track_number":2,"type":"track","uri":"spotify:track:6u29Or89nZ784Mhgp1cuz4"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/770DSqP3I7AwvIcd5pI6Od"},"href":"https://api.spotify.com/v1/albums/770DSqP3I7AwvIcd5pI6Od","id":"770DSqP3I7AwvIcd5pI6Od","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e4938ab9d8b5d085a3c0dfab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e4938ab9d8b5d085a3c0dfab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e4938ab9d8b5d085a3c0dfab"}],"is_playable":true,"name":"21st Century Funk","release_date":"2017-08-11","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:770DSqP3I7AwvIcd5pI6Od"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326229,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/3Bo79uipvzIBiOAG4zJPcm"},"href":"https://api.spotify.com/v1/tracks/3Bo79uipvzIBiOAG4zJPcm","id":"3Bo79uipvzIBiOAG4zJPcm","is_local":false,"is_playable":true,"name":"Redbone","track_number":3,"type":"track","uri":"spotify:track:3Bo79uipvzIBiOAG4zJPcm"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/197YY02cK93Yjrtpa1FrMY"},"href":"https://api.spotify.com/v1/albums/197YY02cK93Yjrtpa1FrMY","id":"197YY02cK93Yjrtpa1FrMY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b11ac9a6b727e6e367a4dcd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b11ac9a6b727e6e367a4dcd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b11ac9a6b727e6e367a4dcd"}],"is_playable":true,"name":"Best Of 2017","release_date":"2017-12-08","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:197YY02cK93Yjrtpa1FrMY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326933,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/1QQIwEMJ5ftWNWapBfNbt7"},"href":"https://api.spotify.com/v1/tracks/1QQIwEMJ5ftWNWapBfNbt7","id":"1QQIwEMJ5ftWNWapBfNbt7","is_local":false,"is_playable":true,"name":"Redbone","track_number":15,"type":"track","uri":"spotify:track:1QQIwEMJ5ftWNWapBfNbt7"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/12JrzzPK17E7V4kArOJJ32"},"href":"https://api.spotify.com/v1/albums/12JrzzPK17E7V4kArOJJ32","id":"12JrzzPK17E7V4kArOJJ32","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a2cc66882283cfb2cb576a19"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a2cc66882283cfb2cb576a19"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a2cc66882283cfb2cb576a19"}],"is_playable":true,"name":"Best Of 2017 Pop","release_date":"2017-12-15","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:12JrzzPK17E7V4kArOJJ32"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326880,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/6wGbDxvg8wLWnk1HxcFTTO"},"href":"https://api.spotify.com/v1/tracks/6wGbDxvg8wLWnk1HxcFTTO","id":"6wGbDxvg8wLWnk1HxcFTTO","is_local":false,"is_playable":true,"name":"Redbone","track_number":7,"type":"track","uri":"spotify:track:6wGbDxvg8wLWnk1HxcFTTO"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJlZGJvbmUlMjIlMjBhcnRpc3QlM0ElMjJDaGlsZGlzaCUyMEdhbWJpbm8lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80SkN5YnNOWlVYV3JLMkpweW4xMk5pIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNEpDeWJzTlpVWFdySzJKcHluMTJOaSIsImlkIjoiNEpDeWJzTlpVWFdySzJKcHluMTJOaSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5z", + "Y2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYzI5NTYyZDZlOGMxZjU1YmIxMzExZDUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWMyOTU2MmQ2ZThjMWY1NWJiMTMxMWQ1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYzI5NTYyZDZlOGMxZjU1YmIxMzExZDUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiXCJBd2FrZW4sIE15IExvdmUhXCIiLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTEyLTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEpDeWJzTlpVWFdySzJKcHluMTJOaSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI2OTMzLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1lBSDE2MDAxMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzN2UTRUNzhUVE1PalFYR2ZYVktRSm8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zdlE0VDc4VFRNT2pRWEdmWFZLUUpvIiwiaWQiOiIzdlE0VDc4VFRNT2pRWEdmWFZLUUpvIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlZGJvbmUiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M3ZRNFQ3OFRUTU9qUVhHZlhWS1FKbyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcg==", + "dGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzR6dWRobXk1SFNIVloxeTNnUGZiQUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80enVkaG15NUhTSFZaMXkzZ1BmYkFCIiwiaWQiOiI0enVkaG15NUhTSFZaMXkzZ1BmYkFCIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzcyYzY2NmU4ZmVlYmJiNjUyNTNlNGZiYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3MmM2NjZlOGZlZWJiYjY1MjUzZTRmYmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTcyYzY2NmU4ZmVlYmJiNjUyNTNlNGZiYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYXRjaCBGZWVscyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDgtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0enVkaG15NUhTSFZaMXkzZ1BmYkFCIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjUyNzIsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMURGS0JEc3ljNWVaS3A3cmh6TWVOTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFERktCRHN5YzVlWktwN3Joek1lTkwiLCJpZCI6IjFERktCRHN5YzVlWktwN3Joek1lTkwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIg==", + "LCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFERktCRHN5YzVlWktwN3Joek1lTkwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzAzOVd6eXR4YXJpWlRvNHRzTFVRRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzcwMzlXenl0eGFyaVpUbzR0c0xVUUYiLCJpZCI6IjcwMzlXenl0eGFyaVpUbzR0c0xVUUYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTJiYzViNDllMjEwMDA5MWQyMjVmOTVkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUyYmM1YjQ5ZTIxMDAwOTFkMjI1Zjk1ZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTJiYzViNDllMjEwMDA5MWQyMjVmOTVkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vdmEgVHVuZXMgMy41IiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wMy0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjcwMzlXenl0eGFyaVpUbzR0c0xVUUYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNDIyNiwiZXhwbGljaXQiOnRydWUsImV4dA==", + "ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1lBSDE2MDAxMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNhWG82bkpqZXhTZGI2d0NwTjdZc3kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zYVhvNm5KamV4U2RiNndDcE43WXN5IiwiaWQiOiIzYVhvNm5KamV4U2RiNndDcE43WXN5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlZGJvbmUiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2FYbzZuSmpleFNkYjZ3Q3BON1lzeSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zN3ZRQWZFYWFjeGVWNE1HTjMxZTlEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMzd2UUFmRWFhY3hlVjRNR04zMWU5RCIsImlkIjoiMzd2UUFmRWFhY3hlVjRNR04zMWU5RCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiMjMwZmM0NjcxYjgzZDg5OTUxZGQyM2YifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjIzMGZjNDY3MWI4M2Q4OTk1MWRkMjNmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiMjMwZmM0NjcxYjgzZDg5OTUxZGQyM2YifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUiZCYWUiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA3LTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Mzd2UUFmRWFhY3hlVjRNR04zMWU5RCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZQ==", + "bi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjU5NjAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDFPUE02NU1Hd3RDVDBENGlBSjZxUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQxT1BNNjVNR3d0Q1QwRDRpQUo2cVAiLCJpZCI6IjQxT1BNNjVNR3d0Q1QwRDRpQUo2cVAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0MU9QTTY1TUd3dENUMEQ0aUFKNnFQIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVUc3pzV3BtczFsbkI3YzZFSjRVeDIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81VHN6c1dwbXMxbG5CN2M2RUo0VXgyIiwiaWQiOiI1VHN6c1dwbXMxbG5CN2M2RUo0VXgyIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZjMDVkNDE1ZDFhMzcxZWFkZDJjNDAyMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2YzA1ZDQxNWQxYTM3MWVhZGQyYzQwMjMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaA==", + "dHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmMwNWQ0MTVkMWEzNzFlYWRkMmM0MDIzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhpcCBIb3AgTG92ZSBTb25ncyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMTEtMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1VHN6c1dwbXMxbG5CN2M2RUo0VXgyIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjY5MzMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnUyOU9yODluWjc4NE1oZ3AxY3V6NCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ1MjlPcjg5blo3ODRNaGdwMWN1ejQiLCJpZCI6IjZ1MjlPcjg5blo3ODRNaGdwMWN1ejQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2dTI5T3I4OW5aNzg0TWhncDFjdXo0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxLw==", + "YWxidW1zLzc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QiLCJpZCI6Ijc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZTQ5MzhhYjlkOGI1ZDA4NWEzYzBkZmFiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmU0OTM4YWI5ZDhiNWQwODVhM2MwZGZhYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZTQ5MzhhYjlkOGI1ZDA4NWEzYzBkZmFiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjIxc3QgQ2VudHVyeSBGdW5rIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wOC0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNjIyOSwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNZQUgxNjAwMTA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zQm83OXVpcHZ6SUJpT0FHNHpKUGNtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0JvNzl1aXB2eklCaU9BRzR6SlBjbSIsImlkIjoiM0JvNzl1aXB2eklCaU9BRzR6SlBjbSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWRib25lIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNCbzc5dWlwdnpJQmlPQUc0ekpQY20ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocg==", + "ZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xOTdZWTAyY0s5M1lqcnRwYTFGck1ZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTk3WVkwMmNLOTNZanJ0cGExRnJNWSIsImlkIjoiMTk3WVkwMmNLOTNZanJ0cGExRnJNWSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1YjExYWM5YTZiNzI3ZTZlMzY3YTRkY2QifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWIxMWFjOWE2YjcyN2U2ZTM2N2E0ZGNkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1YjExYWM5YTZiNzI3ZTZlMzY3YTRkY2QifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmVzdCBPZiAyMDE3IiwicmVsZWFzZV9kYXRlIjoiMjAxNy0xMi0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjE5N1lZMDJjSzkzWWpydHBhMUZyTVkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNjkzMywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNZQUgxNjAwMTA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xUVFJd0VNSjVmdFdOV2FwQmZOYnQ3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVFRSXdFTUo1ZnRXTldhcEJmTmJ0NyIsIg==", + "aWQiOiIxUVFJd0VNSjVmdFdOV2FwQmZOYnQ3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlZGJvbmUiLCJ0cmFja19udW1iZXIiOjE1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFRUUl3RU1KNWZ0V05XYXBCZk5idDcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMTJKcnp6UEsxN0U3VjRrQXJPSkozMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzEySnJ6elBLMTdFN1Y0a0FyT0pKMzIiLCJpZCI6IjEySnJ6elBLMTdFN1Y0a0FyT0pKMzIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTJjYzY2ODgyMjgzY2ZiMmNiNTc2YTE5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEyY2M2Njg4MjI4M2NmYjJjYjU3NmExOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTJjYzY2ODgyMjgzY2ZiMmNiNTc2YTE5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlc3QgT2YgMjAxNyBQb3AiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTEyLTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MTJKcnp6UEsxN0U3VjRrQXJPSkozMiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZQ==", + "IjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjY4ODAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNndHYkR4dmc4d0xXbmsxSHhjRlRUTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ3R2JEeHZnOHdMV25rMUh4Y0ZUVE8iLCJpZCI6IjZ3R2JEeHZnOHdMV25rMUh4Y0ZUVE8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2d0diRHh2Zzh3TFduazFIeGNGVFRPIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Redbone%22+artist%3A%22Childish+Gambino%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNhc2lvJTIyJTIwYXJ0aXN0JTNBJTIySnVuZ2xlJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81OW9BNVdiYlF2b21KejJCdVJHMDcxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU5b0E1V2JiUXZvbUp6MkJ1UkcwNzEiLCJpZCI6IjU5b0E1V2JiUXZvbUp6MkJ1UkcwNzEiLCJuYW1lIjoiSnVuZ2xlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU5b0E1V2JiUXZvbUp6MkJ1UkcwNzEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81Z1lDWmdtWHp6V1h4T0NiOWZNZkJtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWdZQ1pnbVh6eldYeE9DYjlmTWZCbSIsImlkIjoiNWdZQ1pnbVh6eldYeE9DYjlmTWZCbSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMA==", + "YjI3MzAxMGI4MGQ2Njc1YWY3YzljNjBjNGQ5OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwMTBiODBkNjY3NWFmN2M5YzYwYzRkOTgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAxMGI4MGQ2Njc1YWY3YzljNjBjNGQ5OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGb3IgRXZlciIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDktMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1Z1lDWmdtWHp6V1h4T0NiOWZNZkJtIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTlvQTVXYmJRdm9tSnoyQnVSRzA3MSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81OW9BNVdiYlF2b21KejJCdVJHMDcxIiwiaWQiOiI1OW9BNVdiYlF2b21KejJCdVJHMDcxIiwibmFtZSI6Ikp1bmdsZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OW9BNVdiYlF2b21KejJCdVJHMDcxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNDM2OSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQktTMTgwMDEwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDRaS25mV0VrcDd3UHMwMzVqNFR1YSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQ0WktuZldFa3A3d1BzMDM1ajRUdWEiLCJpZCI6IjQ0WktuZldFa3A3d1BzMDM1ajRUdWEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2FzaW8iLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NDRaS25mV0VrcDd3UHMwMzVqNFR1YSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZ1ZDNjh4Rm9nQ1hTNUFlU0JuTFNQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNnVkM2OHhGb2dDWFM1QWVTQm5MU1AiLCJpZCI6IjNnVkM2OHhGb2dDWFM1QWVTQm5MU1AiLCJuYW1lIjoiUmV0cm8gSnVuZ2xlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNnVkM2OHhGb2dDWA==", + "UzVBZVNCbkxTUCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRURlp3djFEOG9aVjA0T0FNQmV3S2MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80VEZad3YxRDhvWlYwNE9BTUJld0tjIiwiaWQiOiI0VEZad3YxRDhvWlYwNE9BTUJld0tjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2M3MGVjNjY5ZTQ0Zjc1M2Y5ZjA2NzY5MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjNzBlYzY2OWU0NGY3NTNmOWYwNjc2OTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM3MGVjNjY5ZTQ0Zjc1M2Y5ZjA2NzY5MSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW1tZXIgVmliZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA3LTE3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFRGWnd2MUQ4b1pWMDRPQU1CZXdLYyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNnVkM2OHhGb2dDWFM1QWVTQm5MU1AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2dWQzY4eEZvZ0NYUzVBZVNCbkxTUCIsImlkIjoiM2dWQzY4eEZvZ0NYUzVBZVNCbkxTUCIsIm5hbWUiOiJSZXRybyBKdW5nbGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2dWQzY4eEZvZ0NYUzVBZVNCbkxTUCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zbDJ4c1E2OWFqbThyN0taRVJqcDZ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNsMnhzUTY5YWptOHI3S1pFUmpwNngiLCJpZCI6IjNsMnhzUTY5YWptOHI3S1pFUmpwNngiLCJuYW1lIjoiRmxhbmRycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozbDJ4c1E2OWFqbThyN0taRVJqcDZ4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEzODAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkNINjU0MTk0MTI5NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNA==", + "RHFla3ZHUVcyekhOTVZoMGdNM3FwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNERxZWt2R1FXMnpITk1WaDBnTTNxcCIsImlkIjoiNERxZWt2R1FXMnpITk1WaDBnTTNxcCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYXNpbyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0RHFla3ZHUVcyekhOTVZoMGdNM3FwIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Casio%22+artist%3A%22Jungle%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1vb24lMjBTb25nJTIyJTIwYXJ0aXN0JTNBJTIyUGhvZWJlJTIwQnJpZGdlcnMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsImlkIjoiMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsIm5hbWUiOiJQaG9lYmUgQnJpZGdlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZQcDZxR0V5d0Rkb2ZnRkMxb0ZiU0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82UHA2cUdFeXdEZG9mZ0ZDMW9GYlNIIiwiaWQiOiI2UHA2cUdFeXdEZG9mZ0ZDMW9GYlNIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2E5MWI3NWM5ZWY2NWVkOGQ3NjBmZjYwMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhOTFiNzVjOWVmNjVlZDhkNzYwZmY2MDAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWE5MWI3NWM5ZWY2NWVkOGQ3NjBmZjYwMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQdW5pc2hlciIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDYtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2UHA2cUdFeXdEZG9mZ0ZDMW9GYlNIIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xcjF1eG95MTlmek14dW50M09OQWtHIiwiaWQiOiIxcjF1eG95MTlmek14dW50M09OQWtHIiwibmFtZSI6IlBob2ViZSBCcmlkZ2VycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxcjF1eG95MTlmek14dW50M09OQWtHIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI3NzY3NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSjVHMjAyMDAwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDZSTnJBa0dzcVdURHJ2MlpQT0FieCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQ2Uk5yQWtHc3FXVERydjJaUE9BYngiLCJpZCI6IjQ2Uk5yQWtHc3FXVERydjJaUE9BYngiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTW9vbiBTb25nIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjQ2Uk5yQWtHc3FXVERydjJaUE9BYngifV19fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1vb24lMjBTb25nJTIyJTIwYXJ0aXN0JTNBJTIyUGhvZWJlJTIwQnJpZGdlcnMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsImlkIjoiMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsIm5hbWUiOiJQaG9lYmUgQnJpZGdlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZQcDZxR0V5d0Rkb2ZnRkMxb0ZiU0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82UHA2cUdFeXdEZG9mZ0ZDMW9GYlNIIiwiaWQiOiI2UHA2cUdFeXdEZG9mZ0ZDMW9GYlNIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLg==", + "c2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTkxYjc1YzllZjY1ZWQ4ZDc2MGZmNjAwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmE5MWI3NWM5ZWY2NWVkOGQ3NjBmZjYwMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTkxYjc1YzllZjY1ZWQ4ZDc2MGZmNjAwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlB1bmlzaGVyIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wNi0xOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZQcDZxR0V5d0Rkb2ZnRkMxb0ZiU0gifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xcjF1eG95MTlmek14dW50M09OQWtHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJpZCI6IjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJuYW1lIjoiUGhvZWJlIEJyaWRnZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjc3Njc2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNKNUcyMDIwMDA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80NlJOckFrR3NxV1REcnYyWlBPQWJ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDZSTnJBa0dzcVdURHJ2MlpQT0FieCIsImlkIjoiNDZSTnJBa0dzcVdURHJ2MlpQT0FieCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb29uIFNvbmciLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NDZSTnJBa0dzcVdURHJ2MlpQT0FieCJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Moon+Song%22+artist%3A%22Phoebe+Bridgers%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldoZW4lMjBJJTIwR2V0JTIwVGhlcmUlMjIlMjBhcnRpc3QlM0ElMjJCaWclMjBXaWxkJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUHh6R25DWUJwU3VhSTQ5T1I5NGNBIiwiaWQiOiIwUHh6R25DWUJwU3VhSTQ5T1I5NGNBIiwibmFtZSI6IkJpZyBXaWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83OFJPY1I1cmtLNTZGblNZeEJvNDBMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzhST2NSNXJrSzU2Rm5TWXhCbzQwTCIsImlkIjoiNzhST2NSNXJrSzU2Rm5TWXhCbzQwTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zYw==", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I2Y2YxMmJlOThhZDg4NzcwMzNkNTM3YyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiNmNmMTJiZTk4YWQ4ODc3MDMzZDUzN2MifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI2Y2YxMmJlOThhZDg4NzcwMzNkNTM3YyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbnZpbmNpYmxlIEVQIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wMi0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzhST2NSNXJrSzU2Rm5TWXhCbzQwTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSIsImlkIjoiMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSIsIm5hbWUiOiJCaWcgV2lsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUHh6R25DWUJwU3VhSTQ5T1I5NGNBIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMDAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUVk1MTcwNjExMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN25ZQ2x6ek5ZNmYzRWNmZURGTnFoUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzduWUNsenpOWTZmM0VjZmVERk5xaFMiLCJpZCI6IjduWUNsenpOWTZmM0VjZmVERk5xaFMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2hlbiBJIEdldCBUaGVyZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3bllDbHp6Tlk2ZjNFY2ZlREZOcWhTIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzQyZkVXek5SVXpJSW1GZ0M4NUFkZ1UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNDJmRVd6TlJVeklJbUZnQzg1QWRnVSIsImlkIjoiNDJmRVd6TlJVeklJbUZnQzg1QWRnVSIsIm5hbWUiOiJGb3JlaWduIEZhbWlseSBDb2xsZWN0aQ==", + "dmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDJmRVd6TlJVeklJbUZnQzg1QWRnVSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzAyWDY3M0NkcVRjU09tQkR1TlhQcXcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wMlg2NzNDZHFUY1NPbUJEdU5YUHF3IiwiaWQiOiIwMlg2NzNDZHFUY1NPbUJEdU5YUHF3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ZhZWM5MDFmZjJjNGE4NDQ1ZDg4NmQyMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmYWVjOTAxZmYyYzRhODQ0NWQ4ODZkMjMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWZhZWM5MDFmZjJjNGE4NDQ1ZDg4NmQyMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGb3JlaWduIEZhbWlseSBDb2xsZWN0aXZlLCBWb2wuIDIiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTAzLTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MDJYNjczQ2RxVGNTT21CRHVOWFBxdyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBQeHpHbkNZQnBTdWFJNDlPUjk0Y0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSIsImlkIjoiMFB4ekduQ1lCcFN1YUk0OU9SOTRjQSIsIm5hbWUiOiJCaWcgV2lsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUHh6R25DWUJwU3VhSTQ5T1I5NGNBIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMDAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUVk1MTcwNjExMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnA1Y1hyaWNldzVid0NGUkt2NWNyNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZwNWNYcmljZXc1YndDRlJLdjVjcjciLCJpZCI6IjZwNWNYcmljZXc1YndDRlJLdjVjcjciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2hlbiBJIEdldCBUaGVyZSIsInRyYWNrX251bQ==", + "YmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2cDVjWHJpY2V3NWJ3Q0ZSS3Y1Y3I3In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22When+I+Get+There%22+artist%3A%22Big+Wild%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkthaWp1JTIyJTIwYXJ0aXN0JTNBJTIyU2FrYW5hY3Rpb24lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8waENXVk1HR1FuUlZmRGdtaHdMSXhxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBoQ1dWTUdHUW5SVmZEZ21od0xJeHEiLCJpZCI6IjBoQ1dWTUdHUW5SVmZEZ21od0xJeHEiLCJuYW1lIjoic2FrYW5hY3Rpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGhDV1ZNR0dRblJWZkRnbWh3TEl4cSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFEaUw3Z3dTdUVoZzJ5MFN2Z1FobFMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xRGlMN2d3U3VFaGcyeTBTdmdRaGxTIiwiaWQiOiIxRGlMN2d3U3VFaGcyeTBTdmdRaGxTIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYQ==", + "YjY3NjE2ZDAwMDBiMjczMjMzN2YwMzYyMDQyMGQ0NTYxYzdlNmM5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjIzMzdmMDM2MjA0MjBkNDU2MWM3ZTZjOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjMzN2YwMzYyMDQyMGQ0NTYxYzdlNmM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkthaWp1IiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMi0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MURpTDdnd1N1RWhnMnkwU3ZnUWhsUyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBoQ1dWTUdHUW5SVmZEZ21od0xJeHEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGhDV1ZNR0dRblJWZkRnbWh3TEl4cSIsImlkIjoiMGhDV1ZNR0dRblJWZkRnbWh3TEl4cSIsIm5hbWUiOiJzYWthbmFjdGlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowaENXVk1HR1FuUlZmRGdtaHdMSXhxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1MjcyMiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkpQVkkwMjQwMzU2MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN3NNUkRqandzQjd3UUVCT2tkZmcwaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdzTVJEamp3c0I3d1FFQk9rZGZnMGkiLCJpZCI6IjdzTVJEamp3c0I3d1FFQk9rZGZnMGkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS2FpanUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N3NNUkRqandzQjd3UUVCT2tkZmcwaSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Kaiju%22+artist%3A%22Sakanaction%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Home%20Lens&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/196dcuwJrobm0Rb6KYRFfw"},"href":"https://api.spotify.com/v1/artists/196dcuwJrobm0Rb6KYRFfw","id":"196dcuwJrobm0Rb6KYRFfw","name":"Alex Stonebay","type":"artist","uri":"spotify:artist:196dcuwJrobm0Rb6KYRFfw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cEBwBPqIxz8CKy3lTtfHw"},"href":"https://api.spotify.com/v1/artists/3cEBwBPqIxz8CKy3lTtfHw","id":"3cEBwBPqIxz8CKy3lTtfHw","name":"Lenso","type":"artist","uri":"spotify:artist:3cEBwBPqIxz8CKy3lTtfHw"}],"external_urls":{"spotify":"https://open.spotify.com/album/4IbeyyFgdFK71edAyoAQpm"},"href":"https://api.spotify.com/v1/albums/4IbeyyFgdFK71edAyoAQpm","id":"4IbeyyFgdFK71edAyoAQpm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273caf7750971d2d5bb6c3095d2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02caf7750971d2d5bb6c3095d2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851caf7750971d2d5bb6c3095d2"}],"is_playable":true,"name":"Take Me Home (Lenso Remix)","release_date":"2026-03-13","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4IbeyyFgdFK71edAyoAQpm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/196dcuwJrobm0Rb6KYRFfw"},"href":"https://api.spotify.com/v1/artists/196dcuwJrobm0Rb6KYRFfw","id":"196dcuwJrobm0Rb6KYRFfw","name":"Alex Stonebay","type":"artist","uri":"spotify:artist:196dcuwJrobm0Rb6KYRFfw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cEBwBPqIxz8CKy3lTtfHw"},"href":"https://api.spotify.com/v1/artists/3cEBwBPqIxz8CKy3lTtfHw","id":"3cEBwBPqIxz8CKy3lTtfHw","name":"Lenso","type":"artist","uri":"spotify:artist:3cEBwBPqIxz8CKy3lTtfHw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/04DhPedaqUbTclK69WosXR"},"href":"https://api.spotify.com/v1/artists/04DhPedaqUbTclK69WosXR","id":"04DhPedaqUbTclK69WosXR","name":"serephina skyrs\u00e5n","type":"artist","uri":"spotify:artist:04DhPedaqUbTclK69WosXR"}],"disc_number":1,"duration_ms":250909,"explicit":false,"external_ids":{"isrc":"QZMEQ2605138"},"external_urls":{"spotify":"https://open.spotify.com/track/6CE6l0wkAr8c7rbWdrltmL"},"href":"https://api.spotify.com/v1/tracks/6CE6l0wkAr8c7rbWdrltmL","id":"6CE6l0wkAr8c7rbWdrltmL","is_local":false,"is_playable":true,"name":"Take Me Home - Lenso Remix","track_number":1,"type":"track","uri":"spotify:track:6CE6l0wkAr8c7rbWdrltmL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1hak05VDAWZqSimeBx6fjQ"},"href":"https://api.spotify.com/v1/artists/1hak05VDAWZqSimeBx6fjQ","id":"1hak05VDAWZqSimeBx6fjQ","name":"Strong Bad","type":"artist","uri":"spotify:artist:1hak05VDAWZqSimeBx6fjQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/4zfqJ2Cj6mk9cI9ahGmSSQ"},"href":"https://api.spotify.com/v1/albums/4zfqJ2Cj6mk9cI9ahGmSSQ","id":"4zfqJ2Cj6mk9cI9ahGmSSQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273df2bffc5c0c15ea2c086de93"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02df2bffc5c0c15ea2c086de93"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851df2bffc5c0c15ea2c086de93"}],"is_playable":true,"name":"Homestar Runner Original Soundtrack Volume 1","release_date":"2020-04-10","release_date_precision":"day","total_tracks":60,"type":"album","uri":"spotify:album:4zfqJ2Cj6mk9cI9ahGmSSQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1hak05VDAWZqSimeBx6fjQ"},"href":"https://api.spotify.com/v1/artists/1hak05VDAWZqSimeBx6fjQ","id":"1hak05VDAWZqSimeBx6fjQ","name":"Strong Bad","type":"artist","uri":"spotify:artist:1hak05VDAWZqSimeBx6fjQ"}],"disc_number":1,"duration_ms":169080,"explicit":false,"external_ids":{"isrc":"QZDA62064065"},"external_urls":{"spotify":"https://open.spotify.com/track/199a9ABuTUObL1hRaQe4Xl"},"href":"https://api.spotify.com/v1/tracks/199a9ABuTUObL1hRaQe4Xl","id":"199a9ABuTUObL1hRaQe4Xl","is_local":false,"is_playable":true,"name":"Fisheye Lens","track_number":2,"type":"track","uri":"spotify:track:199a9ABuTUObL1hRaQe4Xl"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Q0tsXC2u6geWS9yydLdhM"},"href":"https://api.spotify.com/v1/artists/4Q0tsXC2u6geWS9yydLdhM","id":"4Q0tsXC2u6geWS9yydLdhM","name":"Theo Lens","type":"artist","uri":"spotify:artist:4Q0tsXC2u6geWS9yydLdhM"}],"external_urls":{"spotify":"https://open.spotify.com/album/58OKMDOKoIi3NZpxSVeKx9"},"href":"https://api.spotify.com/v1/albums/58OKMDOKoIi3NZpxSVeKx9","id":"58OKMDOKoIi3NZpxSVeKx9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27396fc5e3da6420f96cc44e3fa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0296fc5e3da6420f96cc44e3fa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485196fc5e3da6420f96cc44e3fa"}],"is_playable":true,"name":"Come Home","release_date":"2018-09-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:58OKMDOKoIi3NZpxSVeKx9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Q0tsXC2u6geWS9yydLdhM"},"href":"https://api.spotify.com/v1/artists/4Q0tsXC2u6geWS9yydLdhM","id":"4Q0tsXC2u6geWS9yydLdhM","name":"Theo Lens","type":"artist","uri":"spotify:artist:4Q0tsXC2u6geWS9yydLdhM"}],"disc_number":1,"duration_ms":245179,"explicit":false,"external_ids":{"isrc":"NLQM71100021"},"external_urls":{"spotify":"https://open.spotify.com/track/5MgN569Q9zmPH3g0rDdsd0"},"href":"https://api.spotify.com/v1/tracks/5MgN569Q9zmPH3g0rDdsd0","id":"5MgN569Q9zmPH3g0rDdsd0","is_local":false,"is_playable":true,"name":"Come Home","track_number":1,"type":"track","uri":"spotify:track:5MgN569Q9zmPH3g0rDdsd0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5HoxUV5njSmYDj1U9i9zHY"},"href":"https://api.spotify.com/v1/artists/5HoxUV5njSmYDj1U9i9zHY","id":"5HoxUV5njSmYDj1U9i9zHY","name":"Dotlights","type":"artist","uri":"spotify:artist:5HoxUV5njSmYDj1U9i9zHY"}],"external_urls":{"spotify":"https://open.spotify.com/album/3r8QuWZhdsguIZq8kRNOPf"},"href":"https://api.spotify.com/v1/albums/3r8QuWZhdsguIZq8kRNOPf","id":"3r8QuWZhdsguIZq8kRNOPf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e95c13394ba3ad30dfabbb0e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e95c13394ba3ad30dfabbb0e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e95c13394ba3ad30dfabbb0e"}],"is_playable":true,"name":"A Journey Home","release_date":"2021-08-06","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:3r8QuWZhdsguIZq8kRNOPf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5HoxUV5njSmYDj1U9i9zHY"},"href":"https://api.spotify.com/v1/artists/5HoxUV5njSmYDj1U9i9zHY","id":"5HoxUV5njSmYDj1U9i9zHY","name":"Dotlights","type":"artist","uri":"spotify:artist:5HoxUV5njSmYDj1U9i9zHY"}],"disc_number":1,"duration_ms":143292,"explicit":false,"external_ids":{"isrc":"NL1LE2102296"},"external_urls":{"spotify":"https://open.spotify.com/track/598ktjEv5Tv7x4AaP7RjRP"},"href":"https://api.spotify.com/v1/tracks/598ktjEv5Tv7x4AaP7RjRP","id":"598ktjEv5Tv7x4AaP7RjRP","is_local":false,"is_playable":true,"name":"Grit In The Lens","track_number":9,"type":"track","uri":"spotify:track:598ktjEv5Tv7x4AaP7RjRP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nOiPscNpVTSydKa7Snfin"},"href":"https://api.spotify.com/v1/artists/6nOiPscNpVTSydKa7Snfin","id":"6nOiPscNpVTSydKa7Snfin","name":"Be Careful","type":"artist","uri":"spotify:artist:6nOiPscNpVTSydKa7Snfin"}],"external_urls":{"spotify":"https://open.spotify.com/album/1QSI0csTVcVdhCLSkfKlux"},"href":"https://api.spotify.com/v1/albums/1QSI0csTVcVdhCLSkfKlux","id":"1QSI0csTVcVdhCLSkfKlux","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27352ba6f0bb58f777598205c5f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0252ba6f0bb58f777598205c5f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485152ba6f0bb58f777598205c5f"}],"is_playable":true,"name":"Liminal Cove","release_date":"2021-03-05","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:1QSI0csTVcVdhCLSkfKlux"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nOiPscNpVTSydKa7Snfin"},"href":"https://api.spotify.com/v1/artists/6nOiPscNpVTSydKa7Snfin","id":"6nOiPscNpVTSydKa7Snfin","name":"Be Careful","type":"artist","uri":"spotify:artist:6nOiPscNpVTSydKa7Snfin"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0gF93jqUmpFOFEtBKXWFiA"},"href":"https://api.spotify.com/v1/artists/0gF93jqUmpFOFEtBKXWFiA","id":"0gF93jqUmpFOFEtBKXWFiA","name":"Donor Lens","type":"artist","uri":"spotify:artist:0gF93jqUmpFOFEtBKXWFiA"}],"disc_number":1,"duration_ms":187200,"explicit":false,"external_ids":{"isrc":"QZDA42185668"},"external_urls":{"spotify":"https://open.spotify.com/track/2FPhnI8uGOR4GoVMxhccGI"},"href":"https://api.spotify.com/v1/tracks/2FPhnI8uGOR4GoVMxhccGI","id":"2FPhnI8uGOR4GoVMxhccGI","is_local":false,"is_playable":true,"name":"Epifauna","track_number":4,"type":"track","uri":"spotify:track:2FPhnI8uGOR4GoVMxhccGI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6CV1eZ3xM0Sfpfd6gkufrJ"},"href":"https://api.spotify.com/v1/artists/6CV1eZ3xM0Sfpfd6gkufrJ","id":"6CV1eZ3xM0Sfpfd6gkufrJ","name":"YAI","type":"artist","uri":"spotify:artist:6CV1eZ3xM0Sfpfd6gkufrJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0epYBMvUpoUYstNjLNHL4k"},"href":"https://api.spotify.com/v1/artists/0epYBMvUpoUYstNjLNHL4k","id":"0epYBMvUpoUYstNjLNHL4k","name":"John Thayer","type":"artist","uri":"spotify:artist:0epYBMvUpoUYstNjLNHL4k"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2tVUa3qDGMQQp0Qr3BgDYS"},"href":"https://api.spotify.com/v1/artists/2tVUa3qDGMQQp0Qr3BgDYS","id":"2tVUa3qDGMQQp0Qr3BgDYS","name":"David Lackner","type":"artist","uri":"spotify:artist:2tVUa3qDGMQQp0Qr3BgDYS"}],"external_urls":{"spotify":"https://open.spotify.com/album/55pWMljVAkpiZX6qZkenGd"},"href":"https://api.spotify.com/v1/albums/55pWMljVAkpiZX6qZkenGd","id":"55pWMljVAkpiZX6qZkenGd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737622e20e2c56be61f7282fcb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027622e20e2c56be61f7282fcb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517622e20e2c56be61f7282fcb"}],"is_playable":true,"name":"Flowers from Home","release_date":"2022-01-28","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:55pWMljVAkpiZX6qZkenGd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6CV1eZ3xM0Sfpfd6gkufrJ"},"href":"https://api.spotify.com/v1/artists/6CV1eZ3xM0Sfpfd6gkufrJ","id":"6CV1eZ3xM0Sfpfd6gkufrJ","name":"YAI","type":"artist","uri":"spotify:artist:6CV1eZ3xM0Sfpfd6gkufrJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0epYBMvUpoUYstNjLNHL4k"},"href":"https://api.spotify.com/v1/artists/0epYBMvUpoUYstNjLNHL4k","id":"0epYBMvUpoUYstNjLNHL4k","name":"John Thayer","type":"artist","uri":"spotify:artist:0epYBMvUpoUYstNjLNHL4k"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2tVUa3qDGMQQp0Qr3BgDYS"},"href":"https://api.spotify.com/v1/artists/2tVUa3qDGMQQp0Qr3BgDYS","id":"2tVUa3qDGMQQp0Qr3BgDYS","name":"David Lackner","type":"artist","uri":"spotify:artist:2tVUa3qDGMQQp0Qr3BgDYS"}],"disc_number":1,"duration_ms":291637,"explicit":false,"external_ids":{"isrc":"USA2Z2101440"},"external_urls":{"spotify":"https://open.spotify.com/track/3DiXtku7SkM9dkh3Xs286R"},"href":"https://api.spotify.com/v1/tracks/3DiXtku7SkM9dkh3Xs286R","id":"3DiXtku7SkM9dkh3Xs286R","is_local":false,"is_playable":true,"name":"Parallax Lens","track_number":10,"type":"track","uri":"spotify:track:3DiXtku7SkM9dkh3Xs286R"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dpSr4bpjcD9JuypzSvjc9"},"href":"https://api.spotify.com/v1/artists/3dpSr4bpjcD9JuypzSvjc9","id":"3dpSr4bpjcD9JuypzSvjc9","name":"Room Living","type":"artist","uri":"spotify:artist:3dpSr4bpjcD9JuypzSvjc9"}],"external_urls":{"spotify":"https://open.spotify.com/album/5pxfs29FevvKPaP57DvSxg"},"href":"https://api.spotify.com/v1/albums/5pxfs29FevvKPaP57DvSxg","id":"5pxfs29FevvKPaP57DvSxg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732cfdbf3d812444cc69f9fef2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022cfdbf3d812444cc69f9fef2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512cfdbf3d812444cc69f9fef2"}],"is_playable":true,"name":"Homegrown","release_date":"2022-03-18","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:5pxfs29FevvKPaP57DvSxg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dpSr4bpjcD9JuypzSvjc9"},"href":"https://api.spotify.com/v1/artists/3dpSr4bpjcD9JuypzSvjc9","id":"3dpSr4bpjcD9JuypzSvjc9","name":"Room Living","type":"artist","uri":"spotify:artist:3dpSr4bpjcD9JuypzSvjc9"}],"disc_number":1,"duration_ms":234000,"explicit":false,"external_ids":{"isrc":"GBLFP2202334"},"external_urls":{"spotify":"https://open.spotify.com/track/25WxbkTFINxZdWsbdFJcb4"},"href":"https://api.spotify.com/v1/tracks/25WxbkTFINxZdWsbdFJcb4","id":"25WxbkTFINxZdWsbdFJcb4","is_local":false,"is_playable":true,"name":"Lens Flare","track_number":4,"type":"track","uri":"spotify:track:25WxbkTFINxZdWsbdFJcb4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tohVJC9TjZdlve56ttA6Y"},"href":"https://api.spotify.com/v1/albums/5tohVJC9TjZdlve56ttA6Y","id":"5tohVJC9TjZdlve56ttA6Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733002d315a39759f2f3418fbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023002d315a39759f2f3418fbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513002d315a39759f2f3418fbc"}],"is_playable":true,"name":"Cozy Fall Days","release_date":"2025-10-09","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5tohVJC9TjZdlve56ttA6Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":202679,"explicit":false,"external_ids":{"isrc":"QT3FA2534520"},"external_urls":{"spotify":"https://open.spotify.com/track/5Tb2ggSJ8UyerdxwIyZEV2"},"href":"https://api.spotify.com/v1/tracks/5Tb2ggSJ8UyerdxwIyZEV2","id":"5Tb2ggSJ8UyerdxwIyZEV2","is_local":false,"is_playable":true,"name":"Home in the Rain","track_number":7,"type":"track","uri":"spotify:track:5Tb2ggSJ8UyerdxwIyZEV2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tohVJC9TjZdlve56ttA6Y"},"href":"https://api.spotify.com/v1/albums/5tohVJC9TjZdlve56ttA6Y","id":"5tohVJC9TjZdlve56ttA6Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733002d315a39759f2f3418fbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023002d315a39759f2f3418fbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513002d315a39759f2f3418fbc"}],"is_playable":true,"name":"Cozy Fall Days","release_date":"2025-10-09","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5tohVJC9TjZdlve56ttA6Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":190000,"explicit":false,"external_ids":{"isrc":"QT3FA2534518"},"external_urls":{"spotify":"https://open.spotify.com/track/22yiPgN12r54urDH6SXNb0"},"href":"https://api.spotify.com/v1/tracks/22yiPgN12r54urDH6SXNb0","id":"22yiPgN12r54urDH6SXNb0","is_local":false,"is_playable":true,"name":"Homeward Glow","track_number":5,"type":"track","uri":"spotify:track:22yiPgN12r54urDH6SXNb0"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Home%20Lens&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/196dcuwJrobm0Rb6KYRFfw"},"href":"https://api.spotify.com/v1/artists/196dcuwJrobm0Rb6KYRFfw","id":"196dcuwJrobm0Rb6KYRFfw","name":"Alex Stonebay","type":"artist","uri":"spotify:artist:196dcuwJrobm0Rb6KYRFfw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cEBwBPqIxz8CKy3lTtfHw"},"href":"https://api.spotify.com/v1/artists/3cEBwBPqIxz8CKy3lTtfHw","id":"3cEBwBPqIxz8CKy3lTtfHw","name":"Lenso","type":"artist","uri":"spotify:artist:3cEBwBPqIxz8CKy3lTtfHw"}],"external_urls":{"spotify":"https://open.spotify.com/album/4IbeyyFgdFK71edAyoAQpm"},"href":"https://api.spotify.com/v1/albums/4IbeyyFgdFK71edAyoAQpm","id":"4IbeyyFgdFK71edAyoAQpm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273caf7750971d2d5bb6c3095d2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02caf7750971d2d5bb6c3095d2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851caf7750971d2d5bb6c3095d2"}],"is_playable":true,"name":"Take Me Home (Lenso Remix)","release_date":"2026-03-13","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4IbeyyFgdFK71edAyoAQpm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/196dcuwJrobm0Rb6KYRFfw"},"href":"https://api.spotify.com/v1/artists/196dcuwJrobm0Rb6KYRFfw","id":"196dcuwJrobm0Rb6KYRFfw","name":"Alex Stonebay","type":"artist","uri":"spotify:artist:196dcuwJrobm0Rb6KYRFfw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cEBwBPqIxz8CKy3lTtfHw"},"href":"https://api.spotify.com/v1/artists/3cEBwBPqIxz8CKy3lTtfHw","id":"3cEBwBPqIxz8CKy3lTtfHw","name":"Lenso","type":"artist","uri":"spotify:artist:3cEBwBPqIxz8CKy3lTtfHw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/04DhPedaqUbTclK69WosXR"},"href":"https://api.spotify.com/v1/artists/04DhPedaqUbTclK69WosXR","id":"04DhPedaqUbTclK69WosXR","name":"serephina skyrs\u00e5n","type":"artist","uri":"spotify:artist:04DhPedaqUbTclK69WosXR"}],"disc_number":1,"duration_ms":250909,"explicit":false,"external_ids":{"isrc":"QZMEQ2605138"},"external_urls":{"spotify":"https://open.spotify.com/track/6CE6l0wkAr8c7rbWdrltmL"},"href":"https://api.spotify.com/v1/tracks/6CE6l0wkAr8c7rbWdrltmL","id":"6CE6l0wkAr8c7rbWdrltmL","is_local":false,"is_playable":true,"name":"Take Me Home - Lenso Remix","track_number":1,"type":"track","uri":"spotify:track:6CE6l0wkAr8c7rbWdrltmL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1hak05VDAWZqSimeBx6fjQ"},"href":"https://api.spotify.com/v1/artists/1hak05VDAWZqSimeBx6fjQ","id":"1hak05VDAWZqSimeBx6fjQ","name":"Strong Bad","type":"artist","uri":"spotify:artist:1hak05VDAWZqSimeBx6fjQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/4zfqJ2Cj6mk9cI9ahGmSSQ"},"href":"https://api.spotify.com/v1/albums/4zfqJ2Cj6mk9cI9ahGmSSQ","id":"4zfqJ2Cj6mk9cI9ahGmSSQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273df2bffc5c0c15ea2c086de93"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02df2bffc5c0c15ea2c086de93"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851df2bffc5c0c15ea2c086de93"}],"is_playable":true,"name":"Homestar Runner Original Soundtrack Volume 1","release_date":"2020-04-10","release_date_precision":"day","total_tracks":60,"type":"album","uri":"spotify:album:4zfqJ2Cj6mk9cI9ahGmSSQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1hak05VDAWZqSimeBx6fjQ"},"href":"https://api.spotify.com/v1/artists/1hak05VDAWZqSimeBx6fjQ","id":"1hak05VDAWZqSimeBx6fjQ","name":"Strong Bad","type":"artist","uri":"spotify:artist:1hak05VDAWZqSimeBx6fjQ"}],"disc_number":1,"duration_ms":169080,"explicit":false,"external_ids":{"isrc":"QZDA62064065"},"external_urls":{"spotify":"https://open.spotify.com/track/199a9ABuTUObL1hRaQe4Xl"},"href":"https://api.spotify.com/v1/tracks/199a9ABuTUObL1hRaQe4Xl","id":"199a9ABuTUObL1hRaQe4Xl","is_local":false,"is_playable":true,"name":"Fisheye Lens","track_number":2,"type":"track","uri":"spotify:track:199a9ABuTUObL1hRaQe4Xl"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Q0tsXC2u6geWS9yydLdhM"},"href":"https://api.spotify.com/v1/artists/4Q0tsXC2u6geWS9yydLdhM","id":"4Q0tsXC2u6geWS9yydLdhM","name":"Theo Lens","type":"artist","uri":"spotify:artist:4Q0tsXC2u6geWS9yydLdhM"}],"external_urls":{"spotify":"https://open.spotify.com/album/58OKMDOKoIi3NZpxSVeKx9"},"href":"https://api.spotify.com/v1/albums/58OKMDOKoIi3NZpxSVeKx9","id":"58OKMDOKoIi3NZpxSVeKx9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27396fc5e3da6420f96cc44e3fa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0296fc5e3da6420f96cc44e3fa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485196fc5e3da6420f96cc44e3fa"}],"is_playable":true,"name":"Come Home","release_date":"2018-09-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:58OKMDOKoIi3NZpxSVeKx9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4Q0tsXC2u6geWS9yydLdhM"},"href":"https://api.spotify.com/v1/artists/4Q0tsXC2u6geWS9yydLdhM","id":"4Q0tsXC2u6geWS9yydLdhM","name":"Theo Lens","type":"artist","uri":"spotify:artist:4Q0tsXC2u6geWS9yydLdhM"}],"disc_number":1,"duration_ms":245179,"explicit":false,"external_ids":{"isrc":"NLQM71100021"},"external_urls":{"spotify":"https://open.spotify.com/track/5MgN569Q9zmPH3g0rDdsd0"},"href":"https://api.spotify.com/v1/tracks/5MgN569Q9zmPH3g0rDdsd0","id":"5MgN569Q9zmPH3g0rDdsd0","is_local":false,"is_playable":true,"name":"Come Home","track_number":1,"type":"track","uri":"spotify:track:5MgN569Q9zmPH3g0rDdsd0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5HoxUV5njSmYDj1U9i9zHY"},"href":"https://api.spotify.com/v1/artists/5HoxUV5njSmYDj1U9i9zHY","id":"5HoxUV5njSmYDj1U9i9zHY","name":"Dotlights","type":"artist","uri":"spotify:artist:5HoxUV5njSmYDj1U9i9zHY"}],"external_urls":{"spotify":"https://open.spotify.com/album/3r8QuWZhdsguIZq8kRNOPf"},"href":"https://api.spotify.com/v1/albums/3r8QuWZhdsguIZq8kRNOPf","id":"3r8QuWZhdsguIZq8kRNOPf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e95c13394ba3ad30dfabbb0e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e95c13394ba3ad30dfabbb0e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e95c13394ba3ad30dfabbb0e"}],"is_playable":true,"name":"A Journey Home","release_date":"2021-08-06","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:3r8QuWZhdsguIZq8kRNOPf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5HoxUV5njSmYDj1U9i9zHY"},"href":"https://api.spotify.com/v1/artists/5HoxUV5njSmYDj1U9i9zHY","id":"5HoxUV5njSmYDj1U9i9zHY","name":"Dotlights","type":"artist","uri":"spotify:artist:5HoxUV5njSmYDj1U9i9zHY"}],"disc_number":1,"duration_ms":143292,"explicit":false,"external_ids":{"isrc":"NL1LE2102296"},"external_urls":{"spotify":"https://open.spotify.com/track/598ktjEv5Tv7x4AaP7RjRP"},"href":"https://api.spotify.com/v1/tracks/598ktjEv5Tv7x4AaP7RjRP","id":"598ktjEv5Tv7x4AaP7RjRP","is_local":false,"is_playable":true,"name":"Grit In The Lens","track_number":9,"type":"track","uri":"spotify:track:598ktjEv5Tv7x4AaP7RjRP"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nOiPscNpVTSydKa7Snfin"},"href":"https://api.spotify.com/v1/artists/6nOiPscNpVTSydKa7Snfin","id":"6nOiPscNpVTSydKa7Snfin","name":"Be Careful","type":"artist","uri":"spotify:artist:6nOiPscNpVTSydKa7Snfin"}],"external_urls":{"spotify":"https://open.spotify.com/album/1QSI0csTVcVdhCLSkfKlux"},"href":"https://api.spotify.com/v1/albums/1QSI0csTVcVdhCLSkfKlux","id":"1QSI0csTVcVdhCLSkfKlux","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27352ba6f0bb58f777598205c5f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0252ba6f0bb58f777598205c5f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485152ba6f0bb58f777598205c5f"}],"is_playable":true,"name":"Liminal Cove","release_date":"2021-03-05","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:1QSI0csTVcVdhCLSkfKlux"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6nOiPscNpVTSydKa7Snfin"},"href":"https://api.spotify.com/v1/artists/6nOiPscNpVTSydKa7Snfin","id":"6nOiPscNpVTSydKa7Snfin","name":"Be Careful","type":"artist","uri":"spotify:artist:6nOiPscNpVTSydKa7Snfin"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0gF93jqUmpFOFEtBKXWFiA"},"href":"https://api.spotify.com/v1/artists/0gF93jqUmpFOFEtBKXWFiA","id":"0gF93jqUmpFOFEtBKXWFiA","name":"Donor Lens","type":"artist","uri":"spotify:artist:0gF93jqUmpFOFEtBKXWFiA"}],"disc_number":1,"duration_ms":187200,"explicit":false,"external_ids":{"isrc":"QZDA42185668"},"external_urls":{"spotify":"https://open.spotify.com/track/2FPhnI8uGOR4GoVMxhccGI"},"href":"https://api.spotify.com/v1/tracks/2FPhnI8uGOR4GoVMxhccGI","id":"2FPhnI8uGOR4GoVMxhccGI","is_local":false,"is_playable":true,"name":"Epifauna","track_number":4,"type":"track","uri":"spotify:track:2FPhnI8uGOR4GoVMxhccGI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6CV1eZ3xM0Sfpfd6gkufrJ"},"href":"https://api.spotify.com/v1/artists/6CV1eZ3xM0Sfpfd6gkufrJ","id":"6CV1eZ3xM0Sfpfd6gkufrJ","name":"YAI","type":"artist","uri":"spotify:artist:6CV1eZ3xM0Sfpfd6gkufrJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0epYBMvUpoUYstNjLNHL4k"},"href":"https://api.spotify.com/v1/artists/0epYBMvUpoUYstNjLNHL4k","id":"0epYBMvUpoUYstNjLNHL4k","name":"John Thayer","type":"artist","uri":"spotify:artist:0epYBMvUpoUYstNjLNHL4k"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2tVUa3qDGMQQp0Qr3BgDYS"},"href":"https://api.spotify.com/v1/artists/2tVUa3qDGMQQp0Qr3BgDYS","id":"2tVUa3qDGMQQp0Qr3BgDYS","name":"David Lackner","type":"artist","uri":"spotify:artist:2tVUa3qDGMQQp0Qr3BgDYS"}],"external_urls":{"spotify":"https://open.spotify.com/album/55pWMljVAkpiZX6qZkenGd"},"href":"https://api.spotify.com/v1/albums/55pWMljVAkpiZX6qZkenGd","id":"55pWMljVAkpiZX6qZkenGd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737622e20e2c56be61f7282fcb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027622e20e2c56be61f7282fcb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517622e20e2c56be61f7282fcb"}],"is_playable":true,"name":"Flowers from Home","release_date":"2022-01-28","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:55pWMljVAkpiZX6qZkenGd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6CV1eZ3xM0Sfpfd6gkufrJ"},"href":"https://api.spotify.com/v1/artists/6CV1eZ3xM0Sfpfd6gkufrJ","id":"6CV1eZ3xM0Sfpfd6gkufrJ","name":"YAI","type":"artist","uri":"spotify:artist:6CV1eZ3xM0Sfpfd6gkufrJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0epYBMvUpoUYstNjLNHL4k"},"href":"https://api.spotify.com/v1/artists/0epYBMvUpoUYstNjLNHL4k","id":"0epYBMvUpoUYstNjLNHL4k","name":"John Thayer","type":"artist","uri":"spotify:artist:0epYBMvUpoUYstNjLNHL4k"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2tVUa3qDGMQQp0Qr3BgDYS"},"href":"https://api.spotify.com/v1/artists/2tVUa3qDGMQQp0Qr3BgDYS","id":"2tVUa3qDGMQQp0Qr3BgDYS","name":"David Lackner","type":"artist","uri":"spotify:artist:2tVUa3qDGMQQp0Qr3BgDYS"}],"disc_number":1,"duration_ms":291637,"explicit":false,"external_ids":{"isrc":"USA2Z2101440"},"external_urls":{"spotify":"https://open.spotify.com/track/3DiXtku7SkM9dkh3Xs286R"},"href":"https://api.spotify.com/v1/tracks/3DiXtku7SkM9dkh3Xs286R","id":"3DiXtku7SkM9dkh3Xs286R","is_local":false,"is_playable":true,"name":"Parallax Lens","track_number":10,"type":"track","uri":"spotify:track:3DiXtku7SkM9dkh3Xs286R"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dpSr4bpjcD9JuypzSvjc9"},"href":"https://api.spotify.com/v1/artists/3dpSr4bpjcD9JuypzSvjc9","id":"3dpSr4bpjcD9JuypzSvjc9","name":"Room Living","type":"artist","uri":"spotify:artist:3dpSr4bpjcD9JuypzSvjc9"}],"external_urls":{"spotify":"https://open.spotify.com/album/5pxfs29FevvKPaP57DvSxg"},"href":"https://api.spotify.com/v1/albums/5pxfs29FevvKPaP57DvSxg","id":"5pxfs29FevvKPaP57DvSxg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732cfdbf3d812444cc69f9fef2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022cfdbf3d812444cc69f9fef2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512cfdbf3d812444cc69f9fef2"}],"is_playable":true,"name":"Homegrown","release_date":"2022-03-18","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:5pxfs29FevvKPaP57DvSxg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dpSr4bpjcD9JuypzSvjc9"},"href":"https://api.spotify.com/v1/artists/3dpSr4bpjcD9JuypzSvjc9","id":"3dpSr4bpjcD9JuypzSvjc9","name":"Room Living","type":"artist","uri":"spotify:artist:3dpSr4bpjcD9JuypzSvjc9"}],"disc_number":1,"duration_ms":234000,"explicit":false,"external_ids":{"isrc":"GBLFP2202334"},"external_urls":{"spotify":"https://open.spotify.com/track/25WxbkTFINxZdWsbdFJcb4"},"href":"https://api.spotify.com/v1/tracks/25WxbkTFINxZdWsbdFJcb4","id":"25WxbkTFINxZdWsbdFJcb4","is_local":false,"is_playable":true,"name":"Lens Flare","track_number":4,"type":"track","uri":"spotify:track:25WxbkTFINxZdWsbdFJcb4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tohVJC9TjZdlve56ttA6Y"},"href":"https://api.spotify.com/v1/albums/5tohVJC9TjZdlve56ttA6Y","id":"5tohVJC9TjZdlve56ttA6Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733002d315a39759f2f3418fbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023002d315a39759f2f3418fbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513002d315a39759f2f3418fbc"}],"is_playable":true,"name":"Cozy Fall Days","release_date":"2025-10-09","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5tohVJC9TjZdlve56ttA6Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":202679,"explicit":false,"external_ids":{"isrc":"QT3FA2534520"},"external_urls":{"spotify":"https://open.spotify.com/track/5Tb2ggSJ8UyerdxwIyZEV2"},"href":"https://api.spotify.com/v1/tracks/5Tb2ggSJ8UyerdxwIyZEV2","id":"5Tb2ggSJ8UyerdxwIyZEV2","is_local":false,"is_playable":true,"name":"Home in the Rain","track_number":7,"type":"track","uri":"spotify:track:5Tb2ggSJ8UyerdxwIyZEV2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"external_urls":{"spotify":"https://open.spotify.com/album/5tohVJC9TjZdlve56ttA6Y"},"href":"https://api.spotify.com/v1/albums/5tohVJC9TjZdlve56ttA6Y","id":"5tohVJC9TjZdlve56ttA6Y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733002d315a39759f2f3418fbc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023002d315a39759f2f3418fbc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513002d315a39759f2f3418fbc"}],"is_playable":true,"name":"Cozy Fall Days","release_date":"2025-10-09","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5tohVJC9TjZdlve56ttA6Y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0sEtw6voLkwmLlWZJK9dk2"},"href":"https://api.spotify.com/v1/artists/0sEtw6voLkwmLlWZJK9dk2","id":"0sEtw6voLkwmLlWZJK9dk2","name":"Lens of Eden","type":"artist","uri":"spotify:artist:0sEtw6voLkwmLlWZJK9dk2"}],"disc_number":1,"duration_ms":190000,"explicit":false,"external_ids":{"isrc":"QT3FA2534518"},"external_urls":{"spotify":"https://open.spotify.com/track/22yiPgN12r54urDH6SXNb0"},"href":"https://api.spotify.com/v1/tracks/22yiPgN12r54urDH6SXNb0","id":"22yiPgN12r54urDH6SXNb0","is_local":false,"is_playable":true,"name":"Homeward Glow","track_number":5,"type":"track","uri":"spotify:track:22yiPgN12r54urDH6SXNb0"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Home+Lens&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Sure%20Thing%22%20artist%3A%22Miguel%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/493HYe7N5pleudEZRyhE7R"},"href":"https://api.spotify.com/v1/albums/493HYe7N5pleudEZRyhE7R","id":"493HYe7N5pleudEZRyhE7R","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d5a8395b0d80b8c48a5d851c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d5a8395b0d80b8c48a5d851c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d5a8395b0d80b8c48a5d851c"}],"is_playable":true,"name":"All I Want Is You","release_date":"2010-11-30","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:493HYe7N5pleudEZRyhE7R"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":195373,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/0JXXNGljqupsJaZsgSbMZV"},"href":"https://api.spotify.com/v1/tracks/0JXXNGljqupsJaZsgSbMZV","id":"0JXXNGljqupsJaZsgSbMZV","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":1,"type":"track","uri":"spotify:track:0JXXNGljqupsJaZsgSbMZV"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/0IrjdFRneYtHj0CwmAphDT"},"href":"https://api.spotify.com/v1/albums/0IrjdFRneYtHj0CwmAphDT","id":"0IrjdFRneYtHj0CwmAphDT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2a39a7b2f9b4eb6256d3787"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2a39a7b2f9b4eb6256d3787"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2a39a7b2f9b4eb6256d3787"}],"is_playable":true,"name":"Sure Thing (Sped Up)","release_date":"2023-01-27","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:0IrjdFRneYtHj0CwmAphDT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":150053,"explicit":false,"external_ids":{"isrc":"USJI12300001"},"external_urls":{"spotify":"https://open.spotify.com/track/559SdaPI7mqy9IQiscuaMj"},"href":"https://api.spotify.com/v1/tracks/559SdaPI7mqy9IQiscuaMj","id":"559SdaPI7mqy9IQiscuaMj","is_local":false,"is_playable":true,"name":"Sure Thing - Sped Up","track_number":2,"type":"track","uri":"spotify:track:559SdaPI7mqy9IQiscuaMj"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/3PXsBxDrSXMYkSlWwASle1"},"href":"https://api.spotify.com/v1/albums/3PXsBxDrSXMYkSlWwASle1","id":"3PXsBxDrSXMYkSlWwASle1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273801986c3225964f3f57cc261"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02801986c3225964f3f57cc261"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851801986c3225964f3f57cc261"}],"is_playable":true,"name":"Sure Thing (Live)","release_date":"2023-09-15","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3PXsBxDrSXMYkSlWwASle1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":191020,"explicit":false,"external_ids":{"isrc":"USRC12302319"},"external_urls":{"spotify":"https://open.spotify.com/track/0uExoVSY1lgjiAhvtYwmMV"},"href":"https://api.spotify.com/v1/tracks/0uExoVSY1lgjiAhvtYwmMV","id":"0uExoVSY1lgjiAhvtYwmMV","is_local":false,"is_playable":true,"name":"Sure Thing - Live","track_number":1,"type":"track","uri":"spotify:track:0uExoVSY1lgjiAhvtYwmMV"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/0IrjdFRneYtHj0CwmAphDT"},"href":"https://api.spotify.com/v1/albums/0IrjdFRneYtHj0CwmAphDT","id":"0IrjdFRneYtHj0CwmAphDT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2a39a7b2f9b4eb6256d3787"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2a39a7b2f9b4eb6256d3787"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2a39a7b2f9b4eb6256d3787"}],"is_playable":true,"name":"Sure Thing (Sped Up)","release_date":"2023-01-27","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:0IrjdFRneYtHj0CwmAphDT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":198280,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/1FoZBBZok8wOV7flSzy5Mn"},"href":"https://api.spotify.com/v1/tracks/1FoZBBZok8wOV7flSzy5Mn","id":"1FoZBBZok8wOV7flSzy5Mn","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":1,"type":"track","uri":"spotify:track:1FoZBBZok8wOV7flSzy5Mn"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/0IrjdFRneYtHj0CwmAphDT"},"href":"https://api.spotify.com/v1/albums/0IrjdFRneYtHj0CwmAphDT","id":"0IrjdFRneYtHj0CwmAphDT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2a39a7b2f9b4eb6256d3787"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2a39a7b2f9b4eb6256d3787"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2a39a7b2f9b4eb6256d3787"}],"is_playable":true,"name":"Sure Thing (Sped Up)","release_date":"2023-01-27","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:0IrjdFRneYtHj0CwmAphDT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0JSCWkJNFGt7o4YbYcplQ7"},"href":"https://api.spotify.com/v1/artists/0JSCWkJNFGt7o4YbYcplQ7","id":"0JSCWkJNFGt7o4YbYcplQ7","name":"slater","type":"artist","uri":"spotify:artist:0JSCWkJNFGt7o4YbYcplQ7"}],"disc_number":1,"duration_ms":225450,"explicit":false,"external_ids":{"isrc":"USJI12100071"},"external_urls":{"spotify":"https://open.spotify.com/track/5ai3UwdgwPp9wGcHY1zAk1"},"href":"https://api.spotify.com/v1/tracks/5ai3UwdgwPp9wGcHY1zAk1","id":"5ai3UwdgwPp9wGcHY1zAk1","is_local":false,"is_playable":true,"name":"Sure Thing - slowed + reverb","track_number":5,"type":"track","uri":"spotify:track:5ai3UwdgwPp9wGcHY1zAk1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0QhwxYDUougJiVDtyN4Lhm"},"href":"https://api.spotify.com/v1/albums/0QhwxYDUougJiVDtyN4Lhm","id":"0QhwxYDUougJiVDtyN4Lhm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c3fd856b637a87c675d2f29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c3fd856b637a87c675d2f29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c3fd856b637a87c675d2f29"}],"is_playable":true,"name":"R&B - 100 Hits - The Greatest R n B album - 100 R & B Classics featuring Usher, Pitbull and Synthetic Listener Timberlake","release_date":"2013-06-24","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0QhwxYDUougJiVDtyN4Lhm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":199266,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/1RvT5sIns2lXSLq0XOUvKN"},"href":"https://api.spotify.com/v1/tracks/1RvT5sIns2lXSLq0XOUvKN","id":"1RvT5sIns2lXSLq0XOUvKN","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":92,"type":"track","uri":"spotify:track:1RvT5sIns2lXSLq0XOUvKN"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5dh1BNmAltBZAfFQMekENX"},"href":"https://api.spotify.com/v1/albums/5dh1BNmAltBZAfFQMekENX","id":"5dh1BNmAltBZAfFQMekENX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734001dc00cf9efc3c41ed03f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024001dc00cf9efc3c41ed03f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514001dc00cf9efc3c41ed03f5"}],"is_playable":true,"name":"Viral Songs: Pop Hits 2022 | 2023","release_date":"2022-12-16","release_date_precision":"day","total_tracks":67,"type":"album","uri":"spotify:album:5dh1BNmAltBZAfFQMekENX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":195028,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/7AcTb8NTScVRKQKLh50DZB"},"href":"https://api.spotify.com/v1/tracks/7AcTb8NTScVRKQKLh50DZB","id":"7AcTb8NTScVRKQKLh50DZB","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":63,"type":"track","uri":"spotify:track:7AcTb8NTScVRKQKLh50DZB"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7FRxAaVtIZXIjXZUGNU8Qb"},"href":"https://api.spotify.com/v1/albums/7FRxAaVtIZXIjXZUGNU8Qb","id":"7FRxAaVtIZXIjXZUGNU8Qb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27381716b6b7ebd194c4907a32f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0281716b6b7ebd194c4907a32f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485181716b6b7ebd194c4907a32f"}],"is_playable":true,"name":"TikTok Viral Hits 2022 | 2023","release_date":"2022-12-16","release_date_precision":"day","total_tracks":74,"type":"album","uri":"spotify:album:7FRxAaVtIZXIjXZUGNU8Qb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":195028,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/5HjGV1Eq2ay0eThjInUFpy"},"href":"https://api.spotify.com/v1/tracks/5HjGV1Eq2ay0eThjInUFpy","id":"5HjGV1Eq2ay0eThjInUFpy","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":63,"type":"track","uri":"spotify:track:5HjGV1Eq2ay0eThjInUFpy"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ayY1GNvCgBfu0U9WoOeie"},"href":"https://api.spotify.com/v1/albums/4ayY1GNvCgBfu0U9WoOeie","id":"4ayY1GNvCgBfu0U9WoOeie","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273893c4569e7b9779f3489b665"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02893c4569e7b9779f3489b665"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851893c4569e7b9779f3489b665"}],"is_playable":true,"name":"Viral TikTok Hits 2022 | 2023","release_date":"2022-12-16","release_date_precision":"day","total_tracks":74,"type":"album","uri":"spotify:album:4ayY1GNvCgBfu0U9WoOeie"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":195028,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/4MH1fB28gWgCLrhd4GjKme"},"href":"https://api.spotify.com/v1/tracks/4MH1fB28gWgCLrhd4GjKme","id":"4MH1fB28gWgCLrhd4GjKme","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":33,"type":"track","uri":"spotify:track:4MH1fB28gWgCLrhd4GjKme"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Sure%20Thing%22%20artist%3A%22Miguel%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/493HYe7N5pleudEZRyhE7R"},"href":"https://api.spotify.com/v1/albums/493HYe7N5pleudEZRyhE7R","id":"493HYe7N5pleudEZRyhE7R","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d5a8395b0d80b8c48a5d851c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d5a8395b0d80b8c48a5d851c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d5a8395b0d80b8c48a5d851c"}],"is_playable":true,"name":"All I Want Is You","release_date":"2010-11-30","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:493HYe7N5pleudEZRyhE7R"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":195373,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/0JXXNGljqupsJaZsgSbMZV"},"href":"https://api.spotify.com/v1/tracks/0JXXNGljqupsJaZsgSbMZV","id":"0JXXNGljqupsJaZsgSbMZV","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":1,"type":"track","uri":"spotify:track:0JXXNGljqupsJaZsgSbMZV"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/0IrjdFRneYtHj0CwmAphDT"},"href":"https://api.spotify.com/v1/albums/0IrjdFRneYtHj0CwmAphDT","id":"0IrjdFRneYtHj0CwmAphDT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2a39a7b2f9b4eb6256d3787"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2a39a7b2f9b4eb6256d3787"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2a39a7b2f9b4eb6256d3787"}],"is_playable":true,"name":"Sure Thing (Sped Up)","release_date":"2023-01-27","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:0IrjdFRneYtHj0CwmAphDT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":150053,"explicit":false,"external_ids":{"isrc":"USJI12300001"},"external_urls":{"spotify":"https://open.spotify.com/track/559SdaPI7mqy9IQiscuaMj"},"href":"https://api.spotify.com/v1/tracks/559SdaPI7mqy9IQiscuaMj","id":"559SdaPI7mqy9IQiscuaMj","is_local":false,"is_playable":true,"name":"Sure Thing - Sped Up","track_number":2,"type":"track","uri":"spotify:track:559SdaPI7mqy9IQiscuaMj"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/3PXsBxDrSXMYkSlWwASle1"},"href":"https://api.spotify.com/v1/albums/3PXsBxDrSXMYkSlWwASle1","id":"3PXsBxDrSXMYkSlWwASle1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273801986c3225964f3f57cc261"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02801986c3225964f3f57cc261"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851801986c3225964f3f57cc261"}],"is_playable":true,"name":"Sure Thing (Live)","release_date":"2023-09-15","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3PXsBxDrSXMYkSlWwASle1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":191020,"explicit":false,"external_ids":{"isrc":"USRC12302319"},"external_urls":{"spotify":"https://open.spotify.com/track/0uExoVSY1lgjiAhvtYwmMV"},"href":"https://api.spotify.com/v1/tracks/0uExoVSY1lgjiAhvtYwmMV","id":"0uExoVSY1lgjiAhvtYwmMV","is_local":false,"is_playable":true,"name":"Sure Thing - Live","track_number":1,"type":"track","uri":"spotify:track:0uExoVSY1lgjiAhvtYwmMV"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/0IrjdFRneYtHj0CwmAphDT"},"href":"https://api.spotify.com/v1/albums/0IrjdFRneYtHj0CwmAphDT","id":"0IrjdFRneYtHj0CwmAphDT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2a39a7b2f9b4eb6256d3787"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2a39a7b2f9b4eb6256d3787"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2a39a7b2f9b4eb6256d3787"}],"is_playable":true,"name":"Sure Thing (Sped Up)","release_date":"2023-01-27","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:0IrjdFRneYtHj0CwmAphDT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":198280,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/1FoZBBZok8wOV7flSzy5Mn"},"href":"https://api.spotify.com/v1/tracks/1FoZBBZok8wOV7flSzy5Mn","id":"1FoZBBZok8wOV7flSzy5Mn","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":1,"type":"track","uri":"spotify:track:1FoZBBZok8wOV7flSzy5Mn"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"external_urls":{"spotify":"https://open.spotify.com/album/0IrjdFRneYtHj0CwmAphDT"},"href":"https://api.spotify.com/v1/albums/0IrjdFRneYtHj0CwmAphDT","id":"0IrjdFRneYtHj0CwmAphDT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2a39a7b2f9b4eb6256d3787"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2a39a7b2f9b4eb6256d3787"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2a39a7b2f9b4eb6256d3787"}],"is_playable":true,"name":"Sure Thing (Sped Up)","release_date":"2023-01-27","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:0IrjdFRneYtHj0CwmAphDT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0JSCWkJNFGt7o4YbYcplQ7"},"href":"https://api.spotify.com/v1/artists/0JSCWkJNFGt7o4YbYcplQ7","id":"0JSCWkJNFGt7o4YbYcplQ7","name":"slater","type":"artist","uri":"spotify:artist:0JSCWkJNFGt7o4YbYcplQ7"}],"disc_number":1,"duration_ms":225450,"explicit":false,"external_ids":{"isrc":"USJI12100071"},"external_urls":{"spotify":"https://open.spotify.com/track/5ai3UwdgwPp9wGcHY1zAk1"},"href":"https://api.spotify.com/v1/tracks/5ai3UwdgwPp9wGcHY1zAk1","id":"5ai3UwdgwPp9wGcHY1zAk1","is_local":false,"is_playable":true,"name":"Sure Thing - slowed + reverb","track_number":5,"type":"track","uri":"spotify:track:5ai3UwdgwPp9wGcHY1zAk1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0QhwxYDUougJiVDtyN4Lhm"},"href":"https://api.spotify.com/v1/albums/0QhwxYDUougJiVDtyN4Lhm","id":"0QhwxYDUougJiVDtyN4Lhm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c3fd856b637a87c675d2f29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c3fd856b637a87c675d2f29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c3fd856b637a87c675d2f29"}],"is_playable":true,"name":"R&B - 100 Hits - The Greatest R n B album - 100 R & B Classics featuring Usher, Pitbull and Synthetic Listener Timberlake","release_date":"2013-06-24","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0QhwxYDUougJiVDtyN4Lhm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":199266,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/1RvT5sIns2lXSLq0XOUvKN"},"href":"https://api.spotify.com/v1/tracks/1RvT5sIns2lXSLq0XOUvKN","id":"1RvT5sIns2lXSLq0XOUvKN","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":92,"type":"track","uri":"spotify:track:1RvT5sIns2lXSLq0XOUvKN"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5dh1BNmAltBZAfFQMekENX"},"href":"https://api.spotify.com/v1/albums/5dh1BNmAltBZAfFQMekENX","id":"5dh1BNmAltBZAfFQMekENX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734001dc00cf9efc3c41ed03f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024001dc00cf9efc3c41ed03f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514001dc00cf9efc3c41ed03f5"}],"is_playable":true,"name":"Viral Songs: Pop Hits 2022 | 2023","release_date":"2022-12-16","release_date_precision":"day","total_tracks":67,"type":"album","uri":"spotify:album:5dh1BNmAltBZAfFQMekENX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":195028,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/7AcTb8NTScVRKQKLh50DZB"},"href":"https://api.spotify.com/v1/tracks/7AcTb8NTScVRKQKLh50DZB","id":"7AcTb8NTScVRKQKLh50DZB","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":63,"type":"track","uri":"spotify:track:7AcTb8NTScVRKQKLh50DZB"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7FRxAaVtIZXIjXZUGNU8Qb"},"href":"https://api.spotify.com/v1/albums/7FRxAaVtIZXIjXZUGNU8Qb","id":"7FRxAaVtIZXIjXZUGNU8Qb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27381716b6b7ebd194c4907a32f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0281716b6b7ebd194c4907a32f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485181716b6b7ebd194c4907a32f"}],"is_playable":true,"name":"TikTok Viral Hits 2022 | 2023","release_date":"2022-12-16","release_date_precision":"day","total_tracks":74,"type":"album","uri":"spotify:album:7FRxAaVtIZXIjXZUGNU8Qb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":195028,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/5HjGV1Eq2ay0eThjInUFpy"},"href":"https://api.spotify.com/v1/tracks/5HjGV1Eq2ay0eThjInUFpy","id":"5HjGV1Eq2ay0eThjInUFpy","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":63,"type":"track","uri":"spotify:track:5HjGV1Eq2ay0eThjInUFpy"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ayY1GNvCgBfu0U9WoOeie"},"href":"https://api.spotify.com/v1/albums/4ayY1GNvCgBfu0U9WoOeie","id":"4ayY1GNvCgBfu0U9WoOeie","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273893c4569e7b9779f3489b665"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02893c4569e7b9779f3489b665"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851893c4569e7b9779f3489b665"}],"is_playable":true,"name":"Viral TikTok Hits 2022 | 2023","release_date":"2022-12-16","release_date_precision":"day","total_tracks":74,"type":"album","uri":"spotify:album:4ayY1GNvCgBfu0U9WoOeie"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/360IAlyVv4PCEVjgyMZrxK"},"href":"https://api.spotify.com/v1/artists/360IAlyVv4PCEVjgyMZrxK","id":"360IAlyVv4PCEVjgyMZrxK","name":"Miguel","type":"artist","uri":"spotify:artist:360IAlyVv4PCEVjgyMZrxK"}],"disc_number":1,"duration_ms":195028,"explicit":false,"external_ids":{"isrc":"USJI10800160"},"external_urls":{"spotify":"https://open.spotify.com/track/4MH1fB28gWgCLrhd4GjKme"},"href":"https://api.spotify.com/v1/tracks/4MH1fB28gWgCLrhd4GjKme","id":"4MH1fB28gWgCLrhd4GjKme","is_local":false,"is_playable":true,"name":"Sure Thing","track_number":33,"type":"track","uri":"spotify:track:4MH1fB28gWgCLrhd4GjKme"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Sure+Thing%22+artist%3A%22Miguel%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Slow%20Down%20Sabre&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Slow%20Down%20Sabre&type=track","offset":0,"previous":null,"total":26,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"}],"external_urls":{"spotify":"https://open.spotify.com/album/7fTeO9yatW5oHOJKKg6FfD"},"href":"https://api.spotify.com/v1/albums/7fTeO9yatW5oHOJKKg6FfD","id":"7fTeO9yatW5oHOJKKg6FfD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739624a6317434fea738b30a59"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029624a6317434fea738b30a59"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519624a6317434fea738b30a59"}],"is_playable":true,"name":"When I Wake Up","release_date":"2019-03-22","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7fTeO9yatW5oHOJKKg6FfD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"}],"disc_number":1,"duration_ms":211064,"explicit":false,"external_ids":{"isrc":"QM7281831525"},"external_urls":{"spotify":"https://open.spotify.com/track/3acsDG4uqWOGPidRAZkrqk"},"href":"https://api.spotify.com/v1/tracks/3acsDG4uqWOGPidRAZkrqk","id":"3acsDG4uqWOGPidRAZkrqk","is_local":false,"is_playable":true,"name":"Slow Down","track_number":6,"type":"track","uri":"spotify:track:3acsDG4uqWOGPidRAZkrqk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"}],"external_urls":{"spotify":"https://open.spotify.com/album/3AvjrWwSEgfZs0Ic7Srt8b"},"href":"https://api.spotify.com/v1/albums/3AvjrWwSEgfZs0Ic7Srt8b","id":"3AvjrWwSEgfZs0Ic7Srt8b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb6906ff39ee5ec9f230e05d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb6906ff39ee5ec9f230e05d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb6906ff39ee5ec9f230e05d"}],"is_playable":true,"name":"Slow Down (feat. Jorja Smith) [Vintage Culture & Slow Motion Remix]","release_date":"2020-04-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3AvjrWwSEgfZs0Ic7Srt8b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6jmHuLfbWlq34KedQ7mA5I"},"href":"https://api.spotify.com/v1/artists/6jmHuLfbWlq34KedQ7mA5I","id":"6jmHuLfbWlq34KedQ7mA5I","name":"Slow Motion","type":"artist","uri":"spotify:artist:6jmHuLfbWlq34KedQ7mA5I"}],"disc_number":1,"duration_ms":181306,"explicit":false,"external_ids":{"isrc":"NLZ542000356"},"external_urls":{"spotify":"https://open.spotify.com/track/5PNvgiKSwMdjBsDsgFCFLX"},"href":"https://api.spotify.com/v1/tracks/5PNvgiKSwMdjBsDsgFCFLX","id":"5PNvgiKSwMdjBsDsgFCFLX","is_local":false,"is_playable":true,"name":"Slow Down (feat. Jorja Smith) - Vintage Culture & Slow Motion Remix","track_number":1,"type":"track","uri":"spotify:track:5PNvgiKSwMdjBsDsgFCFLX"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4uRl0LZUcciuN8tfRQ3LRM"},"href":"https://api.spotify.com/v1/artists/4uRl0LZUcciuN8tfRQ3LRM","id":"4uRl0LZUcciuN8tfRQ3LRM","name":"James Cole","type":"artist","uri":"spotify:artist:4uRl0LZUcciuN8tfRQ3LRM"}],"external_urls":{"spotify":"https://open.spotify.com/album/3zrP0lDAbH8sF4219tbsX4"},"href":"https://api.spotify.com/v1/albums/3zrP0lDAbH8sF4219tbsX4","id":"3zrP0lDAbH8sF4219tbsX4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27372f04b49a8c224b162dd2ec1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0272f04b49a8c224b162dd2ec1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485172f04b49a8c224b162dd2ec1"}],"is_playable":true,"name":"Slow Down (James Cole Remix)","release_date":"2022-06-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3zrP0lDAbH8sF4219tbsX4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4uRl0LZUcciuN8tfRQ3LRM"},"href":"https://api.spotify.com/v1/artists/4uRl0LZUcciuN8tfRQ3LRM","id":"4uRl0LZUcciuN8tfRQ3LRM","name":"James Cole","type":"artist","uri":"spotify:artist:4uRl0LZUcciuN8tfRQ3LRM"}],"disc_number":1,"duration_ms":417999,"explicit":false,"external_ids":{"isrc":"QM6MZ2296397"},"external_urls":{"spotify":"https://open.spotify.com/track/7IasAOphluLSAmgMtg9jYA"},"href":"https://api.spotify.com/v1/tracks/7IasAOphluLSAmgMtg9jYA","id":"7IasAOphluLSAmgMtg9jYA","is_local":false,"is_playable":true,"name":"Slow Down - James Cole Remix","track_number":1,"type":"track","uri":"spotify:track:7IasAOphluLSAmgMtg9jYA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wTUsxee6HtnB6Z6QiUCub"},"href":"https://api.spotify.com/v1/artists/1wTUsxee6HtnB6Z6QiUCub","id":"1wTUsxee6HtnB6Z6QiUCub","name":"Sabrina Starke","type":"artist","uri":"spotify:artist:1wTUsxee6HtnB6Z6QiUCub"}],"external_urls":{"spotify":"https://open.spotify.com/album/0ckoLZt4Xb73Vebt8AxHTE"},"href":"https://api.spotify.com/v1/albums/0ckoLZt4Xb73Vebt8AxHTE","id":"0ckoLZt4Xb73Vebt8AxHTE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fec26714e2093a64e0029a69"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fec26714e2093a64e0029a69"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fec26714e2093a64e0029a69"}],"is_playable":true,"name":"Weather The Storm","release_date":"2024-11-22","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0ckoLZt4Xb73Vebt8AxHTE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wTUsxee6HtnB6Z6QiUCub"},"href":"https://api.spotify.com/v1/artists/1wTUsxee6HtnB6Z6QiUCub","id":"1wTUsxee6HtnB6Z6QiUCub","name":"Sabrina Starke","type":"artist","uri":"spotify:artist:1wTUsxee6HtnB6Z6QiUCub"}],"disc_number":1,"duration_ms":310853,"explicit":false,"external_ids":{"isrc":"US3F72310938"},"external_urls":{"spotify":"https://open.spotify.com/track/1O2X5mPjE8EcYBR3mxPlha"},"href":"https://api.spotify.com/v1/tracks/1O2X5mPjE8EcYBR3mxPlha","id":"1O2X5mPjE8EcYBR3mxPlha","is_local":false,"is_playable":true,"name":"Slow It Down","track_number":7,"type":"track","uri":"spotify:track:1O2X5mPjE8EcYBR3mxPlha"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wTUsxee6HtnB6Z6QiUCub"},"href":"https://api.spotify.com/v1/artists/1wTUsxee6HtnB6Z6QiUCub","id":"1wTUsxee6HtnB6Z6QiUCub","name":"Sabrina Starke","type":"artist","uri":"spotify:artist:1wTUsxee6HtnB6Z6QiUCub"}],"external_urls":{"spotify":"https://open.spotify.com/album/36ZvISB24D2QaueXIz1Wks"},"href":"https://api.spotify.com/v1/albums/36ZvISB24D2QaueXIz1Wks","id":"36ZvISB24D2QaueXIz1Wks","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f83460a94ee1fc18230ed8e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f83460a94ee1fc18230ed8e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f83460a94ee1fc18230ed8e7"}],"is_playable":true,"name":"Slow It Down","release_date":"2023-04-28","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:36ZvISB24D2QaueXIz1Wks"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wTUsxee6HtnB6Z6QiUCub"},"href":"https://api.spotify.com/v1/artists/1wTUsxee6HtnB6Z6QiUCub","id":"1wTUsxee6HtnB6Z6QiUCub","name":"Sabrina Starke","type":"artist","uri":"spotify:artist:1wTUsxee6HtnB6Z6QiUCub"}],"disc_number":1,"duration_ms":310853,"explicit":false,"external_ids":{"isrc":"US3F72310938"},"external_urls":{"spotify":"https://open.spotify.com/track/02sFZjfNx8PoBlRgZifQUG"},"href":"https://api.spotify.com/v1/tracks/02sFZjfNx8PoBlRgZifQUG","id":"02sFZjfNx8PoBlRgZifQUG","is_local":false,"is_playable":true,"name":"Slow It Down","track_number":1,"type":"track","uri":"spotify:track:02sFZjfNx8PoBlRgZifQUG"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"external_urls":{"spotify":"https://open.spotify.com/album/7dK54iZuOxXFarGhXwEXfF"},"href":"https://api.spotify.com/v1/albums/7dK54iZuOxXFarGhXwEXfF","id":"7dK54iZuOxXFarGhXwEXfF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738db37bc9a58543471bee78c5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028db37bc9a58543471bee78c5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518db37bc9a58543471bee78c5"}],"is_playable":true,"name":"Lemonade","release_date":"2016-04-23","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7dK54iZuOxXFarGhXwEXfF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"disc_number":1,"duration_ms":221093,"explicit":true,"external_ids":{"isrc":"USSM11603176"},"external_urls":{"spotify":"https://open.spotify.com/track/0rzNMzZsubFcXSEh7dnem7"},"href":"https://api.spotify.com/v1/tracks/0rzNMzZsubFcXSEh7dnem7","id":"0rzNMzZsubFcXSEh7dnem7","is_local":false,"is_playable":true,"name":"Hold Up","track_number":2,"type":"track","uri":"spotify:track:0rzNMzZsubFcXSEh7dnem7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7ofG5BaSiQp8WeL4YCYDhF"},"href":"https://api.spotify.com/v1/artists/7ofG5BaSiQp8WeL4YCYDhF","id":"7ofG5BaSiQp8WeL4YCYDhF","name":"adore","type":"artist","uri":"spotify:artist:7ofG5BaSiQp8WeL4YCYDhF"}],"external_urls":{"spotify":"https://open.spotify.com/album/5mw5lqpHiII2dtNFjWfKTd"},"href":"https://api.spotify.com/v1/albums/5mw5lqpHiII2dtNFjWfKTd","id":"5mw5lqpHiII2dtNFjWfKTd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e5db09ae4a2813a1b2b342a5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e5db09ae4a2813a1b2b342a5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e5db09ae4a2813a1b2b342a5"}],"is_playable":true,"name":"did i tell u that i miss u","release_date":"2024-05-30","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:5mw5lqpHiII2dtNFjWfKTd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7ofG5BaSiQp8WeL4YCYDhF"},"href":"https://api.spotify.com/v1/artists/7ofG5BaSiQp8WeL4YCYDhF","id":"7ofG5BaSiQp8WeL4YCYDhF","name":"adore","type":"artist","uri":"spotify:artist:7ofG5BaSiQp8WeL4YCYDhF"}],"disc_number":1,"duration_ms":115921,"explicit":false,"external_ids":{"isrc":"CA5KR2447784"},"external_urls":{"spotify":"https://open.spotify.com/track/3qeFjtPJ1lIRKDTB5DZWpt"},"href":"https://api.spotify.com/v1/tracks/3qeFjtPJ1lIRKDTB5DZWpt","id":"3qeFjtPJ1lIRKDTB5DZWpt","is_local":false,"is_playable":true,"name":"did i tell u that i miss u","track_number":1,"type":"track","uri":"spotify:track:3qeFjtPJ1lIRKDTB5DZWpt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6d47Z08T4snK50HgTEHo5Z"},"href":"https://api.spotify.com/v1/artists/6d47Z08T4snK50HgTEHo5Z","id":"6d47Z08T4snK50HgTEHo5Z","name":"Sage The Gemini","type":"artist","uri":"spotify:artist:6d47Z08T4snK50HgTEHo5Z"}],"external_urls":{"spotify":"https://open.spotify.com/album/5udw4f9l9vwuJVkrbRFy3j"},"href":"https://api.spotify.com/v1/albums/5udw4f9l9vwuJVkrbRFy3j","id":"5udw4f9l9vwuJVkrbRFy3j","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e86422731c4379b0a28ab2c5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e86422731c4379b0a28ab2c5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e86422731c4379b0a28ab2c5"}],"is_playable":true,"name":"Remember Me","release_date":"2014-03-25","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5udw4f9l9vwuJVkrbRFy3j"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6d47Z08T4snK50HgTEHo5Z"},"href":"https://api.spotify.com/v1/artists/6d47Z08T4snK50HgTEHo5Z","id":"6d47Z08T4snK50HgTEHo5Z","name":"Sage The Gemini","type":"artist","uri":"spotify:artist:6d47Z08T4snK50HgTEHo5Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZavqCJe7uqkRpISes0NFi"},"href":"https://api.spotify.com/v1/artists/2ZavqCJe7uqkRpISes0NFi","id":"2ZavqCJe7uqkRpISes0NFi","name":"Iamsu!","type":"artist","uri":"spotify:artist:2ZavqCJe7uqkRpISes0NFi"}],"disc_number":1,"duration_ms":208160,"explicit":true,"external_ids":{"isrc":"USUYG1027384"},"external_urls":{"spotify":"https://open.spotify.com/track/1UMKquW1olreYO1LlLmTqi"},"href":"https://api.spotify.com/v1/tracks/1UMKquW1olreYO1LlLmTqi","id":"1UMKquW1olreYO1LlLmTqi","is_local":false,"is_playable":true,"name":"Gas Pedal","track_number":4,"type":"track","uri":"spotify:track:1UMKquW1olreYO1LlLmTqi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ssKBN5wWP7fyQDJD3oV4g"},"href":"https://api.spotify.com/v1/artists/1ssKBN5wWP7fyQDJD3oV4g","id":"1ssKBN5wWP7fyQDJD3oV4g","name":"Putra Wiradwi","type":"artist","uri":"spotify:artist:1ssKBN5wWP7fyQDJD3oV4g"}],"external_urls":{"spotify":"https://open.spotify.com/album/1v4NgWw885H6bgqrYJ0Yg1"},"href":"https://api.spotify.com/v1/albums/1v4NgWw885H6bgqrYJ0Yg1","id":"1v4NgWw885H6bgqrYJ0Yg1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fed04cf9a6f24e755200bcce"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fed04cf9a6f24e755200bcce"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fed04cf9a6f24e755200bcce"}],"is_playable":true,"name":"Room 7","release_date":"2021-02-24","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:1v4NgWw885H6bgqrYJ0Yg1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ssKBN5wWP7fyQDJD3oV4g"},"href":"https://api.spotify.com/v1/artists/1ssKBN5wWP7fyQDJD3oV4g","id":"1ssKBN5wWP7fyQDJD3oV4g","name":"Putra Wiradwi","type":"artist","uri":"spotify:artist:1ssKBN5wWP7fyQDJD3oV4g"}],"disc_number":1,"duration_ms":210000,"explicit":false,"external_ids":{"isrc":"QZFZ22172732"},"external_urls":{"spotify":"https://open.spotify.com/track/44yx1JKUsD3EtoL5F2BvXt"},"href":"https://api.spotify.com/v1/tracks/44yx1JKUsD3EtoL5F2BvXt","id":"44yx1JKUsD3EtoL5F2BvXt","is_local":false,"is_playable":true,"name":"Slow It Down","track_number":9,"type":"track","uri":"spotify:track:44yx1JKUsD3EtoL5F2BvXt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YjQ3m0XlKoyx2PY9OnryA"},"href":"https://api.spotify.com/v1/artists/2YjQ3m0XlKoyx2PY9OnryA","id":"2YjQ3m0XlKoyx2PY9OnryA","name":"A-natural","type":"artist","uri":"spotify:artist:2YjQ3m0XlKoyx2PY9OnryA"}],"external_urls":{"spotify":"https://open.spotify.com/album/3IqLHVTTXmkZcNZdc0QIsA"},"href":"https://api.spotify.com/v1/albums/3IqLHVTTXmkZcNZdc0QIsA","id":"3IqLHVTTXmkZcNZdc0QIsA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730b04f7d9fcd72ad9d6636a06"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020b04f7d9fcd72ad9d6636a06"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510b04f7d9fcd72ad9d6636a06"}],"is_playable":true,"name":"The Love Experiment","release_date":"2022-09-30","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:3IqLHVTTXmkZcNZdc0QIsA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YjQ3m0XlKoyx2PY9OnryA"},"href":"https://api.spotify.com/v1/artists/2YjQ3m0XlKoyx2PY9OnryA","id":"2YjQ3m0XlKoyx2PY9OnryA","name":"A-natural","type":"artist","uri":"spotify:artist:2YjQ3m0XlKoyx2PY9OnryA"}],"disc_number":1,"duration_ms":227340,"explicit":false,"external_ids":{"isrc":"QZNWT2211256"},"external_urls":{"spotify":"https://open.spotify.com/track/0xLQbRfc54lYDo8wtjmxPj"},"href":"https://api.spotify.com/v1/tracks/0xLQbRfc54lYDo8wtjmxPj","id":"0xLQbRfc54lYDo8wtjmxPj","is_local":false,"is_playable":true,"name":"Life Support","track_number":4,"type":"track","uri":"spotify:track:0xLQbRfc54lYDo8wtjmxPj"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Slow%20Down%20Sabre&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Slow%20Down%20Sabre&type=track","offset":0,"previous":null,"total":26,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"}],"external_urls":{"spotify":"https://open.spotify.com/album/7fTeO9yatW5oHOJKKg6FfD"},"href":"https://api.spotify.com/v1/albums/7fTeO9yatW5oHOJKKg6FfD","id":"7fTeO9yatW5oHOJKKg6FfD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739624a6317434fea738b30a59"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029624a6317434fea738b30a59"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519624a6317434fea738b30a59"}],"is_playable":true,"name":"When I Wake Up","release_date":"2019-03-22","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7fTeO9yatW5oHOJKKg6FfD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"}],"disc_number":1,"duration_ms":211064,"explicit":false,"external_ids":{"isrc":"QM7281831525"},"external_urls":{"spotify":"https://open.spotify.com/track/3acsDG4uqWOGPidRAZkrqk"},"href":"https://api.spotify.com/v1/tracks/3acsDG4uqWOGPidRAZkrqk","id":"3acsDG4uqWOGPidRAZkrqk","is_local":false,"is_playable":true,"name":"Slow Down","track_number":6,"type":"track","uri":"spotify:track:3acsDG4uqWOGPidRAZkrqk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"}],"external_urls":{"spotify":"https://open.spotify.com/album/3AvjrWwSEgfZs0Ic7Srt8b"},"href":"https://api.spotify.com/v1/albums/3AvjrWwSEgfZs0Ic7Srt8b","id":"3AvjrWwSEgfZs0Ic7Srt8b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb6906ff39ee5ec9f230e05d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb6906ff39ee5ec9f230e05d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb6906ff39ee5ec9f230e05d"}],"is_playable":true,"name":"Slow Down (feat. Jorja Smith) [Vintage Culture & Slow Motion Remix]","release_date":"2020-04-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3AvjrWwSEgfZs0Ic7Srt8b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/28uJnu5EsrGml2tBd7y8ts"},"href":"https://api.spotify.com/v1/artists/28uJnu5EsrGml2tBd7y8ts","id":"28uJnu5EsrGml2tBd7y8ts","name":"Vintage Culture","type":"artist","uri":"spotify:artist:28uJnu5EsrGml2tBd7y8ts"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6jmHuLfbWlq34KedQ7mA5I"},"href":"https://api.spotify.com/v1/artists/6jmHuLfbWlq34KedQ7mA5I","id":"6jmHuLfbWlq34KedQ7mA5I","name":"Slow Motion","type":"artist","uri":"spotify:artist:6jmHuLfbWlq34KedQ7mA5I"}],"disc_number":1,"duration_ms":181306,"explicit":false,"external_ids":{"isrc":"NLZ542000356"},"external_urls":{"spotify":"https://open.spotify.com/track/5PNvgiKSwMdjBsDsgFCFLX"},"href":"https://api.spotify.com/v1/tracks/5PNvgiKSwMdjBsDsgFCFLX","id":"5PNvgiKSwMdjBsDsgFCFLX","is_local":false,"is_playable":true,"name":"Slow Down (feat. Jorja Smith) - Vintage Culture & Slow Motion Remix","track_number":1,"type":"track","uri":"spotify:track:5PNvgiKSwMdjBsDsgFCFLX"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4uRl0LZUcciuN8tfRQ3LRM"},"href":"https://api.spotify.com/v1/artists/4uRl0LZUcciuN8tfRQ3LRM","id":"4uRl0LZUcciuN8tfRQ3LRM","name":"James Cole","type":"artist","uri":"spotify:artist:4uRl0LZUcciuN8tfRQ3LRM"}],"external_urls":{"spotify":"https://open.spotify.com/album/3zrP0lDAbH8sF4219tbsX4"},"href":"https://api.spotify.com/v1/albums/3zrP0lDAbH8sF4219tbsX4","id":"3zrP0lDAbH8sF4219tbsX4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27372f04b49a8c224b162dd2ec1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0272f04b49a8c224b162dd2ec1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485172f04b49a8c224b162dd2ec1"}],"is_playable":true,"name":"Slow Down (James Cole Remix)","release_date":"2022-06-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3zrP0lDAbH8sF4219tbsX4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0ukgrNYk51TkMQr0f2Br4Q"},"href":"https://api.spotify.com/v1/artists/0ukgrNYk51TkMQr0f2Br4Q","id":"0ukgrNYk51TkMQr0f2Br4Q","name":"Maverick Sabre","type":"artist","uri":"spotify:artist:0ukgrNYk51TkMQr0f2Br4Q"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1CoZyIx7UvdxT5c8UkMzHd"},"href":"https://api.spotify.com/v1/artists/1CoZyIx7UvdxT5c8UkMzHd","id":"1CoZyIx7UvdxT5c8UkMzHd","name":"Jorja Smith","type":"artist","uri":"spotify:artist:1CoZyIx7UvdxT5c8UkMzHd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4uRl0LZUcciuN8tfRQ3LRM"},"href":"https://api.spotify.com/v1/artists/4uRl0LZUcciuN8tfRQ3LRM","id":"4uRl0LZUcciuN8tfRQ3LRM","name":"James Cole","type":"artist","uri":"spotify:artist:4uRl0LZUcciuN8tfRQ3LRM"}],"disc_number":1,"duration_ms":417999,"explicit":false,"external_ids":{"isrc":"QM6MZ2296397"},"external_urls":{"spotify":"https://open.spotify.com/track/7IasAOphluLSAmgMtg9jYA"},"href":"https://api.spotify.com/v1/tracks/7IasAOphluLSAmgMtg9jYA","id":"7IasAOphluLSAmgMtg9jYA","is_local":false,"is_playable":true,"name":"Slow Down - James Cole Remix","track_number":1,"type":"track","uri":"spotify:track:7IasAOphluLSAmgMtg9jYA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wTUsxee6HtnB6Z6QiUCub"},"href":"https://api.spotify.com/v1/artists/1wTUsxee6HtnB6Z6QiUCub","id":"1wTUsxee6HtnB6Z6QiUCub","name":"Sabrina Starke","type":"artist","uri":"spotify:artist:1wTUsxee6HtnB6Z6QiUCub"}],"external_urls":{"spotify":"https://open.spotify.com/album/0ckoLZt4Xb73Vebt8AxHTE"},"href":"https://api.spotify.com/v1/albums/0ckoLZt4Xb73Vebt8AxHTE","id":"0ckoLZt4Xb73Vebt8AxHTE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fec26714e2093a64e0029a69"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fec26714e2093a64e0029a69"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fec26714e2093a64e0029a69"}],"is_playable":true,"name":"Weather The Storm","release_date":"2024-11-22","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0ckoLZt4Xb73Vebt8AxHTE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wTUsxee6HtnB6Z6QiUCub"},"href":"https://api.spotify.com/v1/artists/1wTUsxee6HtnB6Z6QiUCub","id":"1wTUsxee6HtnB6Z6QiUCub","name":"Sabrina Starke","type":"artist","uri":"spotify:artist:1wTUsxee6HtnB6Z6QiUCub"}],"disc_number":1,"duration_ms":310853,"explicit":false,"external_ids":{"isrc":"US3F72310938"},"external_urls":{"spotify":"https://open.spotify.com/track/1O2X5mPjE8EcYBR3mxPlha"},"href":"https://api.spotify.com/v1/tracks/1O2X5mPjE8EcYBR3mxPlha","id":"1O2X5mPjE8EcYBR3mxPlha","is_local":false,"is_playable":true,"name":"Slow It Down","track_number":7,"type":"track","uri":"spotify:track:1O2X5mPjE8EcYBR3mxPlha"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wTUsxee6HtnB6Z6QiUCub"},"href":"https://api.spotify.com/v1/artists/1wTUsxee6HtnB6Z6QiUCub","id":"1wTUsxee6HtnB6Z6QiUCub","name":"Sabrina Starke","type":"artist","uri":"spotify:artist:1wTUsxee6HtnB6Z6QiUCub"}],"external_urls":{"spotify":"https://open.spotify.com/album/36ZvISB24D2QaueXIz1Wks"},"href":"https://api.spotify.com/v1/albums/36ZvISB24D2QaueXIz1Wks","id":"36ZvISB24D2QaueXIz1Wks","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f83460a94ee1fc18230ed8e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f83460a94ee1fc18230ed8e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f83460a94ee1fc18230ed8e7"}],"is_playable":true,"name":"Slow It Down","release_date":"2023-04-28","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:36ZvISB24D2QaueXIz1Wks"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wTUsxee6HtnB6Z6QiUCub"},"href":"https://api.spotify.com/v1/artists/1wTUsxee6HtnB6Z6QiUCub","id":"1wTUsxee6HtnB6Z6QiUCub","name":"Sabrina Starke","type":"artist","uri":"spotify:artist:1wTUsxee6HtnB6Z6QiUCub"}],"disc_number":1,"duration_ms":310853,"explicit":false,"external_ids":{"isrc":"US3F72310938"},"external_urls":{"spotify":"https://open.spotify.com/track/02sFZjfNx8PoBlRgZifQUG"},"href":"https://api.spotify.com/v1/tracks/02sFZjfNx8PoBlRgZifQUG","id":"02sFZjfNx8PoBlRgZifQUG","is_local":false,"is_playable":true,"name":"Slow It Down","track_number":1,"type":"track","uri":"spotify:track:02sFZjfNx8PoBlRgZifQUG"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"external_urls":{"spotify":"https://open.spotify.com/album/7dK54iZuOxXFarGhXwEXfF"},"href":"https://api.spotify.com/v1/albums/7dK54iZuOxXFarGhXwEXfF","id":"7dK54iZuOxXFarGhXwEXfF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738db37bc9a58543471bee78c5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028db37bc9a58543471bee78c5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518db37bc9a58543471bee78c5"}],"is_playable":true,"name":"Lemonade","release_date":"2016-04-23","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7dK54iZuOxXFarGhXwEXfF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"disc_number":1,"duration_ms":221093,"explicit":true,"external_ids":{"isrc":"USSM11603176"},"external_urls":{"spotify":"https://open.spotify.com/track/0rzNMzZsubFcXSEh7dnem7"},"href":"https://api.spotify.com/v1/tracks/0rzNMzZsubFcXSEh7dnem7","id":"0rzNMzZsubFcXSEh7dnem7","is_local":false,"is_playable":true,"name":"Hold Up","track_number":2,"type":"track","uri":"spotify:track:0rzNMzZsubFcXSEh7dnem7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7ofG5BaSiQp8WeL4YCYDhF"},"href":"https://api.spotify.com/v1/artists/7ofG5BaSiQp8WeL4YCYDhF","id":"7ofG5BaSiQp8WeL4YCYDhF","name":"adore","type":"artist","uri":"spotify:artist:7ofG5BaSiQp8WeL4YCYDhF"}],"external_urls":{"spotify":"https://open.spotify.com/album/5mw5lqpHiII2dtNFjWfKTd"},"href":"https://api.spotify.com/v1/albums/5mw5lqpHiII2dtNFjWfKTd","id":"5mw5lqpHiII2dtNFjWfKTd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e5db09ae4a2813a1b2b342a5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e5db09ae4a2813a1b2b342a5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e5db09ae4a2813a1b2b342a5"}],"is_playable":true,"name":"did i tell u that i miss u","release_date":"2024-05-30","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:5mw5lqpHiII2dtNFjWfKTd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7ofG5BaSiQp8WeL4YCYDhF"},"href":"https://api.spotify.com/v1/artists/7ofG5BaSiQp8WeL4YCYDhF","id":"7ofG5BaSiQp8WeL4YCYDhF","name":"adore","type":"artist","uri":"spotify:artist:7ofG5BaSiQp8WeL4YCYDhF"}],"disc_number":1,"duration_ms":115921,"explicit":false,"external_ids":{"isrc":"CA5KR2447784"},"external_urls":{"spotify":"https://open.spotify.com/track/3qeFjtPJ1lIRKDTB5DZWpt"},"href":"https://api.spotify.com/v1/tracks/3qeFjtPJ1lIRKDTB5DZWpt","id":"3qeFjtPJ1lIRKDTB5DZWpt","is_local":false,"is_playable":true,"name":"did i tell u that i miss u","track_number":1,"type":"track","uri":"spotify:track:3qeFjtPJ1lIRKDTB5DZWpt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6d47Z08T4snK50HgTEHo5Z"},"href":"https://api.spotify.com/v1/artists/6d47Z08T4snK50HgTEHo5Z","id":"6d47Z08T4snK50HgTEHo5Z","name":"Sage The Gemini","type":"artist","uri":"spotify:artist:6d47Z08T4snK50HgTEHo5Z"}],"external_urls":{"spotify":"https://open.spotify.com/album/5udw4f9l9vwuJVkrbRFy3j"},"href":"https://api.spotify.com/v1/albums/5udw4f9l9vwuJVkrbRFy3j","id":"5udw4f9l9vwuJVkrbRFy3j","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e86422731c4379b0a28ab2c5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e86422731c4379b0a28ab2c5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e86422731c4379b0a28ab2c5"}],"is_playable":true,"name":"Remember Me","release_date":"2014-03-25","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5udw4f9l9vwuJVkrbRFy3j"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6d47Z08T4snK50HgTEHo5Z"},"href":"https://api.spotify.com/v1/artists/6d47Z08T4snK50HgTEHo5Z","id":"6d47Z08T4snK50HgTEHo5Z","name":"Sage The Gemini","type":"artist","uri":"spotify:artist:6d47Z08T4snK50HgTEHo5Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2ZavqCJe7uqkRpISes0NFi"},"href":"https://api.spotify.com/v1/artists/2ZavqCJe7uqkRpISes0NFi","id":"2ZavqCJe7uqkRpISes0NFi","name":"Iamsu!","type":"artist","uri":"spotify:artist:2ZavqCJe7uqkRpISes0NFi"}],"disc_number":1,"duration_ms":208160,"explicit":true,"external_ids":{"isrc":"USUYG1027384"},"external_urls":{"spotify":"https://open.spotify.com/track/1UMKquW1olreYO1LlLmTqi"},"href":"https://api.spotify.com/v1/tracks/1UMKquW1olreYO1LlLmTqi","id":"1UMKquW1olreYO1LlLmTqi","is_local":false,"is_playable":true,"name":"Gas Pedal","track_number":4,"type":"track","uri":"spotify:track:1UMKquW1olreYO1LlLmTqi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ssKBN5wWP7fyQDJD3oV4g"},"href":"https://api.spotify.com/v1/artists/1ssKBN5wWP7fyQDJD3oV4g","id":"1ssKBN5wWP7fyQDJD3oV4g","name":"Putra Wiradwi","type":"artist","uri":"spotify:artist:1ssKBN5wWP7fyQDJD3oV4g"}],"external_urls":{"spotify":"https://open.spotify.com/album/1v4NgWw885H6bgqrYJ0Yg1"},"href":"https://api.spotify.com/v1/albums/1v4NgWw885H6bgqrYJ0Yg1","id":"1v4NgWw885H6bgqrYJ0Yg1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fed04cf9a6f24e755200bcce"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fed04cf9a6f24e755200bcce"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fed04cf9a6f24e755200bcce"}],"is_playable":true,"name":"Room 7","release_date":"2021-02-24","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:1v4NgWw885H6bgqrYJ0Yg1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ssKBN5wWP7fyQDJD3oV4g"},"href":"https://api.spotify.com/v1/artists/1ssKBN5wWP7fyQDJD3oV4g","id":"1ssKBN5wWP7fyQDJD3oV4g","name":"Putra Wiradwi","type":"artist","uri":"spotify:artist:1ssKBN5wWP7fyQDJD3oV4g"}],"disc_number":1,"duration_ms":210000,"explicit":false,"external_ids":{"isrc":"QZFZ22172732"},"external_urls":{"spotify":"https://open.spotify.com/track/44yx1JKUsD3EtoL5F2BvXt"},"href":"https://api.spotify.com/v1/tracks/44yx1JKUsD3EtoL5F2BvXt","id":"44yx1JKUsD3EtoL5F2BvXt","is_local":false,"is_playable":true,"name":"Slow It Down","track_number":9,"type":"track","uri":"spotify:track:44yx1JKUsD3EtoL5F2BvXt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YjQ3m0XlKoyx2PY9OnryA"},"href":"https://api.spotify.com/v1/artists/2YjQ3m0XlKoyx2PY9OnryA","id":"2YjQ3m0XlKoyx2PY9OnryA","name":"A-natural","type":"artist","uri":"spotify:artist:2YjQ3m0XlKoyx2PY9OnryA"}],"external_urls":{"spotify":"https://open.spotify.com/album/3IqLHVTTXmkZcNZdc0QIsA"},"href":"https://api.spotify.com/v1/albums/3IqLHVTTXmkZcNZdc0QIsA","id":"3IqLHVTTXmkZcNZdc0QIsA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730b04f7d9fcd72ad9d6636a06"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020b04f7d9fcd72ad9d6636a06"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510b04f7d9fcd72ad9d6636a06"}],"is_playable":true,"name":"The Love Experiment","release_date":"2022-09-30","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:3IqLHVTTXmkZcNZdc0QIsA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2YjQ3m0XlKoyx2PY9OnryA"},"href":"https://api.spotify.com/v1/artists/2YjQ3m0XlKoyx2PY9OnryA","id":"2YjQ3m0XlKoyx2PY9OnryA","name":"A-natural","type":"artist","uri":"spotify:artist:2YjQ3m0XlKoyx2PY9OnryA"}],"disc_number":1,"duration_ms":227340,"explicit":false,"external_ids":{"isrc":"QZNWT2211256"},"external_urls":{"spotify":"https://open.spotify.com/track/0xLQbRfc54lYDo8wtjmxPj"},"href":"https://api.spotify.com/v1/tracks/0xLQbRfc54lYDo8wtjmxPj","id":"0xLQbRfc54lYDo8wtjmxPj","is_local":false,"is_playable":true,"name":"Life Support","track_number":4,"type":"track","uri":"spotify:track:0xLQbRfc54lYDo8wtjmxPj"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Slow+Down+Sabre&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Superfly%22%20artist%3A%22Curtis%20Mayfield%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ljIGCRRvS48V4ADzPGav2"},"href":"https://api.spotify.com/v1/albums/5ljIGCRRvS48V4ADzPGav2","id":"5ljIGCRRvS48V4ADzPGav2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273532e0956a0f5ae7418c63ceb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02532e0956a0f5ae7418c63ceb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851532e0956a0f5ae7418c63ceb"}],"is_playable":true,"name":"Superfly (Original Soundtrack)","release_date":"1972-07-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5ljIGCRRvS48V4ADzPGav2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"disc_number":1,"duration_ms":233600,"explicit":false,"external_ids":{"isrc":"USRH10284929"},"external_urls":{"spotify":"https://open.spotify.com/track/4XsH9zBWPOCdXoH9ZDdS8r"},"href":"https://api.spotify.com/v1/tracks/4XsH9zBWPOCdXoH9ZDdS8r","id":"4XsH9zBWPOCdXoH9ZDdS8r","is_local":false,"is_playable":true,"name":"Superfly","track_number":9,"type":"track","uri":"spotify:track:4XsH9zBWPOCdXoH9ZDdS8r"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"external_urls":{"spotify":"https://open.spotify.com/album/5QuvlU7nCUZZJauMvhlWR4"},"href":"https://api.spotify.com/v1/albums/5QuvlU7nCUZZJauMvhlWR4","id":"5QuvlU7nCUZZJauMvhlWR4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273177fea3fc7f8075fdb40f167"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02177fea3fc7f8075fdb40f167"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851177fea3fc7f8075fdb40f167"}],"is_playable":true,"name":"Superfly: Deluxe 25th Anniversary Edition","release_date":"1972-07-01","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:5QuvlU7nCUZZJauMvhlWR4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"disc_number":1,"duration_ms":240160,"explicit":false,"external_ids":{"isrc":"USRH10282626"},"external_urls":{"spotify":"https://open.spotify.com/track/0Y2L2bd7T8JFlvB602sMIw"},"href":"https://api.spotify.com/v1/tracks/0Y2L2bd7T8JFlvB602sMIw","id":"0Y2L2bd7T8JFlvB602sMIw","is_local":false,"is_playable":true,"name":"Superfly","track_number":9,"type":"track","uri":"spotify:track:0Y2L2bd7T8JFlvB602sMIw"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ljIGCRRvS48V4ADzPGav2"},"href":"https://api.spotify.com/v1/albums/5ljIGCRRvS48V4ADzPGav2","id":"5ljIGCRRvS48V4ADzPGav2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273532e0956a0f5ae7418c63ceb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02532e0956a0f5ae7418c63ceb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851532e0956a0f5ae7418c63ceb"}],"is_playable":true,"name":"Superfly (Original Soundtrack)","release_date":"1972-07-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5ljIGCRRvS48V4ADzPGav2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"disc_number":1,"duration_ms":188200,"explicit":false,"external_ids":{"isrc":"USRH10283404"},"external_urls":{"spotify":"https://open.spotify.com/track/3IKvjx4g9ONbiE7j6XnhAD"},"href":"https://api.spotify.com/v1/tracks/3IKvjx4g9ONbiE7j6XnhAD","id":"3IKvjx4g9ONbiE7j6XnhAD","is_local":false,"is_playable":true,"name":"Superfly - Single Mix Version","track_number":11,"type":"track","uri":"spotify:track:3IKvjx4g9ONbiE7j6XnhAD"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"external_urls":{"spotify":"https://open.spotify.com/album/5GugslIWlR2QSKyWMQS5CB"},"href":"https://api.spotify.com/v1/albums/5GugslIWlR2QSKyWMQS5CB","id":"5GugslIWlR2QSKyWMQS5CB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273844c8bafeb35bf1c274d86c1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02844c8bafeb35bf1c274d86c1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851844c8bafeb35bf1c274d86c1"}],"is_playable":true,"name":"Rhino Hi-Five: Curtis Mayfield","release_date":"2005-04-19","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:5GugslIWlR2QSKyWMQS5CB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"disc_number":1,"duration_ms":240160,"explicit":false,"external_ids":{"isrc":"USRH10282626"},"external_urls":{"spotify":"https://open.spotify.com/track/52sHkNOKpiSUTz4tUFCMq8"},"href":"https://api.spotify.com/v1/tracks/52sHkNOKpiSUTz4tUFCMq8","id":"52sHkNOKpiSUTz4tUFCMq8","is_local":false,"is_playable":true,"name":"Superfly","track_number":3,"type":"track","uri":"spotify:track:52sHkNOKpiSUTz4tUFCMq8"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/30W3y8DsqCdmD4mcGrzk0f"},"href":"https://api.spotify.com/v1/albums/30W3y8DsqCdmD4mcGrzk0f","id":"30W3y8DsqCdmD4mcGrzk0f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27349f04f600e785d9538fc5057"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0249f04f600e785d9538fc5057"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485149f04f600e785d9538fc5057"}],"is_playable":true,"name":"Soul (Introducing)","release_date":"2017-05-19","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:30W3y8DsqCdmD4mcGrzk0f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"disc_number":1,"duration_ms":240160,"explicit":false,"external_ids":{"isrc":"USRH10282626"},"external_urls":{"spotify":"https://open.spotify.com/track/3HyJXXYGhvzSE5EWzOeHAP"},"href":"https://api.spotify.com/v1/tracks/3HyJXXYGhvzSE5EWzOeHAP","id":"3HyJXXYGhvzSE5EWzOeHAP","is_local":false,"is_playable":true,"name":"Superfly","track_number":37,"type":"track","uri":"spotify:track:3HyJXXYGhvzSE5EWzOeHAP"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0eGh2jSWPBX5GuqIHoZJZG"},"href":"https://api.spotify.com/v1/artists/0eGh2jSWPBX5GuqIHoZJZG","id":"0eGh2jSWPBX5GuqIHoZJZG","name":"ICE-T","type":"artist","uri":"spotify:artist:0eGh2jSWPBX5GuqIHoZJZG"}],"external_urls":{"spotify":"https://open.spotify.com/album/7vKuK1Per3hIUJ3b9uEOGn"},"href":"https://api.spotify.com/v1/albums/7vKuK1Per3hIUJ3b9uEOGn","id":"7vKuK1Per3hIUJ3b9uEOGn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27343d9a379f987f8516b832d12"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0243d9a379f987f8516b832d12"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485143d9a379f987f8516b832d12"}],"is_playable":true,"name":"Superfly 1990","release_date":"1990-01-01","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:7vKuK1Per3hIUJ3b9uEOGn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0eGh2jSWPBX5GuqIHoZJZG"},"href":"https://api.spotify.com/v1/artists/0eGh2jSWPBX5GuqIHoZJZG","id":"0eGh2jSWPBX5GuqIHoZJZG","name":"ICE-T","type":"artist","uri":"spotify:artist:0eGh2jSWPBX5GuqIHoZJZG"}],"disc_number":1,"duration_ms":272266,"explicit":false,"external_ids":{"isrc":"USCA29001424"},"external_urls":{"spotify":"https://open.spotify.com/track/68bzNk7BrvAGTu5Y8VEaSQ"},"href":"https://api.spotify.com/v1/tracks/68bzNk7BrvAGTu5Y8VEaSQ","id":"68bzNk7BrvAGTu5Y8VEaSQ","is_local":false,"is_playable":true,"name":"Superfly 1990 - LP Edit","track_number":1,"type":"track","uri":"spotify:track:68bzNk7BrvAGTu5Y8VEaSQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"external_urls":{"spotify":"https://open.spotify.com/album/688Kh9FEef2uaJOXFtOtXp"},"href":"https://api.spotify.com/v1/albums/688Kh9FEef2uaJOXFtOtXp","id":"688Kh9FEef2uaJOXFtOtXp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b68b90592e0bafebd0f1836e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b68b90592e0bafebd0f1836e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b68b90592e0bafebd0f1836e"}],"is_playable":true,"name":"Curtis Live! (US Release)","release_date":"1971","release_date_precision":"year","total_tracks":18,"type":"album","uri":"spotify:album:688Kh9FEef2uaJOXFtOtXp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"disc_number":1,"duration_ms":236666,"explicit":false,"external_ids":{"isrc":"USRH10200171"},"external_urls":{"spotify":"https://open.spotify.com/track/3YhIfL4Q0eCiixZXRNGcFC"},"href":"https://api.spotify.com/v1/tracks/3YhIfL4Q0eCiixZXRNGcFC","id":"3YhIfL4Q0eCiixZXRNGcFC","is_local":false,"is_playable":true,"name":"Superfly - Recorded Live by WTTW-TV Chicago","track_number":17,"type":"track","uri":"spotify:track:3YhIfL4Q0eCiixZXRNGcFC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"external_urls":{"spotify":"https://open.spotify.com/album/0yad6uGsh2rJvMbYHqsprf"},"href":"https://api.spotify.com/v1/albums/0yad6uGsh2rJvMbYHqsprf","id":"0yad6uGsh2rJvMbYHqsprf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273342982226c6e7c9a8cf14a91"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02342982226c6e7c9a8cf14a91"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851342982226c6e7c9a8cf14a91"}],"is_playable":true,"name":"The Essentials","release_date":"2002-06-18","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:0yad6uGsh2rJvMbYHqsprf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"disc_number":1,"duration_ms":233600,"explicit":false,"external_ids":{"isrc":"USRH10284929"},"external_urls":{"spotify":"https://open.spotify.com/track/7FVJvx1BDwXGPMrzz26bqX"},"href":"https://api.spotify.com/v1/tracks/7FVJvx1BDwXGPMrzz26bqX","id":"7FVJvx1BDwXGPMrzz26bqX","is_local":false,"is_playable":true,"name":"Superfly","track_number":4,"type":"track","uri":"spotify:track:7FVJvx1BDwXGPMrzz26bqX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"external_urls":{"spotify":"https://open.spotify.com/album/5QuvlU7nCUZZJauMvhlWR4"},"href":"https://api.spotify.com/v1/albums/5QuvlU7nCUZZJauMvhlWR4","id":"5QuvlU7nCUZZJauMvhlWR4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273177fea3fc7f8075fdb40f167"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02177fea3fc7f8075fdb40f167"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851177fea3fc7f8075fdb40f167"}],"is_playable":true,"name":"Superfly: Deluxe 25th Anniversary Edition","release_date":"1972-07-01","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:5QuvlU7nCUZZJauMvhlWR4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"disc_number":1,"duration_ms":211360,"explicit":false,"external_ids":{"isrc":"USRH10283404"},"external_urls":{"spotify":"https://open.spotify.com/track/5ZlLI6n8e3wlOrscAoCKmQ"},"href":"https://api.spotify.com/v1/tracks/5ZlLI6n8e3wlOrscAoCKmQ","id":"5ZlLI6n8e3wlOrscAoCKmQ","is_local":false,"is_playable":true,"name":"Superfly - Single Mix Version","track_number":11,"type":"track","uri":"spotify:track:5ZlLI6n8e3wlOrscAoCKmQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ljIGCRRvS48V4ADzPGav2"},"href":"https://api.spotify.com/v1/albums/5ljIGCRRvS48V4ADzPGav2","id":"5ljIGCRRvS48V4ADzPGav2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273532e0956a0f5ae7418c63ceb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02532e0956a0f5ae7418c63ceb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851532e0956a0f5ae7418c63ceb"}],"is_playable":true,"name":"Superfly (Original Soundtrack)","release_date":"1972-07-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5ljIGCRRvS48V4ADzPGav2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AV6XDIs32ofIJhkkDevjm"},"href":"https://api.spotify.com/v1/artists/2AV6XDIs32ofIJhkkDevjm","id":"2AV6XDIs32ofIJhkkDevjm","name":"Curtis Mayfield","type":"artist","uri":"spotify:artist:2AV6XDIs32ofIJhkkDevjm"}],"disc_number":1,"duration_ms":200720,"explicit":false,"external_ids":{"isrc":"USRH10282842"},"external_urls":{"spotify":"https://open.spotify.com/track/2TcZ0F3g5Yy7MYdzF3RvQX"},"href":"https://api.spotify.com/v1/tracks/2TcZ0F3g5Yy7MYdzF3RvQX","id":"2TcZ0F3g5Yy7MYdzF3RvQX","is_local":false,"is_playable":true,"name":"Freddie's Dead - Theme From 'Superfly'; Single Mix","track_number":10,"type":"track","uri":"spotify:track:2TcZ0F3g5Yy7MYdzF3RvQX"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN1cGVyZmx5JTIyJTIwYXJ0aXN0JTNBJTIyQ3VydGlzJTIwTWF5ZmllbGQlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJBVjZYRElzMzJvZklKaGtrRGV2am0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsImlkIjoiMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsIm5hbWUiOiJDdXJ0aXMgTWF5ZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVsaklHQ1JSdlM0OFY0QUR6UEdhdjIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81bGpJR0NSUnZTNDhWNEFEelBHYXYyIiwiaWQiOiI1bGpJR0NSUnZTNDhWNEFEelBHYXYyIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNj", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzUzMmUwOTU2YTBmNWFlNzQxOGM2M2NlYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1MzJlMDk1NmEwZjVhZTc0MThjNjNjZWIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTUzMmUwOTU2YTBmNWFlNzQxOGM2M2NlYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdXBlcmZseSAoT3JpZ2luYWwgU291bmR0cmFjaykiLCJyZWxlYXNlX2RhdGUiOiIxOTcyLTA3LTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWxqSUdDUlJ2UzQ4VjRBRHpQR2F2MiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJBVjZYRElzMzJvZklKaGtrRGV2am0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsImlkIjoiMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsIm5hbWUiOiJDdXJ0aXMgTWF5ZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzM2MDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTAyODQ5MjkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRYc0g5ekJXUE9DZFhvSDlaRGRTOHIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80WHNIOXpCV1BPQ2RYb0g5WkRkUzhyIiwiaWQiOiI0WHNIOXpCV1BPQ2RYb0g5WkRkUzhyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1cGVyZmx5IiwidHJhY2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRYc0g5ekJXUE9DZFhvSDlaRGRTOHIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQVY2WERJczMyb2ZJSmhra0RldmptIiwiaWQiOiIyQVY2WERJczMyb2ZJSmhra0RldmptIiwibmFtZSI6IkN1cnRpcw==", + "IE1heWZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVjZYRElzMzJvZklKaGtrRGV2am0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81UXV2bFU3bkNVWlpKYXVNdmhsV1I0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNVF1dmxVN25DVVpaSmF1TXZobFdSNCIsImlkIjoiNVF1dmxVN25DVVpaSmF1TXZobFdSNCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNzdmZWEzZmM3ZjgwNzVmZGI0MGYxNjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTc3ZmVhM2ZjN2Y4MDc1ZmRiNDBmMTY3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExNzdmZWEzZmM3ZjgwNzVmZGI0MGYxNjcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VwZXJmbHk6IERlbHV4ZSAyNXRoIEFubml2ZXJzYXJ5IEVkaXRpb24iLCJyZWxlYXNlX2RhdGUiOiIxOTcyLTA3LTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVF1dmxVN25DVVpaSmF1TXZobFdSNCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJBVjZYRElzMzJvZklKaGtrRGV2am0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsImlkIjoiMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsIm5hbWUiOiJDdXJ0aXMgTWF5ZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDAxNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTAyODI2MjYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBZMkwyYmQ3VDhKRmx2QjYwMnNNSXcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wWTJMMmJkN1Q4SkZsdkI2MDJzTUl3IiwiaWQiOiIwWTJMMmJkN1Q4SkZsdkI2MDJzTUl3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1cGVyZg==", + "bHkiLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MFkyTDJiZDdUOEpGbHZCNjAyc01JdyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQVY2WERJczMyb2ZJSmhra0RldmptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJpZCI6IjJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJuYW1lIjoiQ3VydGlzIE1heWZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVjZYRElzMzJvZklKaGtrRGV2am0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81bGpJR0NSUnZTNDhWNEFEelBHYXYyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWxqSUdDUlJ2UzQ4VjRBRHpQR2F2MiIsImlkIjoiNWxqSUdDUlJ2UzQ4VjRBRHpQR2F2MiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1MzJlMDk1NmEwZjVhZTc0MThjNjNjZWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTMyZTA5NTZhMGY1YWU3NDE4YzYzY2ViIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1MzJlMDk1NmEwZjVhZTc0MThjNjNjZWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VwZXJmbHkgKE9yaWdpbmFsIFNvdW5kdHJhY2spIiwicmVsZWFzZV9kYXRlIjoiMTk3Mi0wNy0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVsaklHQ1JSdlM0OFY0QUR6UEdhdjIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQVY2WERJczMyb2ZJSmhra0RldmptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJpZCI6IjJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJuYW1lIjoiQ3VydGlzIE1heWZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVjZYRElzMzJvZklKaGtrRGV2am0ifV0sImRpc2NfbnVtYmVyIg==", + "OjEsImR1cmF0aW9uX21zIjoxODgyMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTAyODM0MDQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNJS3ZqeDRnOU9OYmlFN2o2WG5oQUQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zSUt2ang0ZzlPTmJpRTdqNlhuaEFEIiwiaWQiOiIzSUt2ang0ZzlPTmJpRTdqNlhuaEFEIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1cGVyZmx5IC0gU2luZ2xlIE1peCBWZXJzaW9uIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozSUt2ang0ZzlPTmJpRTdqNlhuaEFEIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQVY2WERJczMyb2ZJSmhra0RldmptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJpZCI6IjJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJuYW1lIjoiQ3VydGlzIE1heWZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVjZYRElzMzJvZklKaGtrRGV2am0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81R3Vnc2xJV2xSMlFTS3lXTVFTNUNCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUd1Z3NsSVdsUjJRU0t5V01RUzVDQiIsImlkIjoiNUd1Z3NsSVdsUjJRU0t5V01RUzVDQiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4NDRjOGJhZmViMzViZjFjMjc0ZDg2YzEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODQ0YzhiYWZlYjM1YmYxYzI3NGQ4NmMxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4NDRjOGJhZmViMzViZjFjMjc0ZDg2YzEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmhpbm8gSGktRml2ZTogQ3VydGlzIE1heWZpZWxkIiwicmVsZWFzZV9kYXRlIjoiMjAwNS0wNC0xOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwbw==", + "dGlmeTphbGJ1bTo1R3Vnc2xJV2xSMlFTS3lXTVFTNUNCIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQVY2WERJczMyb2ZJSmhra0RldmptIiwiaWQiOiIyQVY2WERJczMyb2ZJSmhra0RldmptIiwibmFtZSI6IkN1cnRpcyBNYXlmaWVsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQVY2WERJczMyb2ZJSmhra0RldmptIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDE2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMDI4MjYyNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNTJzSGtOT0twaVNVVHo0dFVGQ01xOCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzUyc0hrTk9LcGlTVVR6NHRVRkNNcTgiLCJpZCI6IjUyc0hrTk9LcGlTVVR6NHRVRkNNcTgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VwZXJmbHkiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NTJzSGtOT0twaVNVVHo0dFVGQ01xOCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zMFczeThEc3FDZG1ENG1jR3J6azBmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMzBXM3k4RHNxQ2RtRDRtY0dyemswZiIsImlkIjoiMzBXM3k4RHNxQ2RtRDRtY0dyemswZiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0OWYwNGY2MDBlNzg1ZDk1MzhmYzUwNTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kucw==", + "Y2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0OWYwNGY2MDBlNzg1ZDk1MzhmYzUwNTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQ5ZjA0ZjYwMGU3ODVkOTUzOGZjNTA1NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb3VsIChJbnRyb2R1Y2luZykiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA1LTE5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MzBXM3k4RHNxQ2RtRDRtY0dyemswZiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJBVjZYRElzMzJvZklKaGtrRGV2am0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsImlkIjoiMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsIm5hbWUiOiJDdXJ0aXMgTWF5ZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDAxNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTAyODI2MjYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNIeUpYWFlHaHZ6U0U1RVd6T2VIQVAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zSHlKWFhZR2h2elNFNUVXek9lSEFQIiwiaWQiOiIzSHlKWFhZR2h2elNFNUVXek9lSEFQIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1cGVyZmx5IiwidHJhY2tfbnVtYmVyIjozNywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozSHlKWFhZR2h2elNFNUVXek9lSEFQIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQVY2WERJczMyb2ZJSmhra0RldmptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJpZCI6IjJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJuYW1lIjoiQ3VydGlzIE1heWZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVjZYRElzMzJvZklKaGtrRGV2am0ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOg==", + "Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZUdoMmpTV1BCWDVHdXFJSG9aSlpHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBlR2gyalNXUEJYNUd1cUlIb1pKWkciLCJpZCI6IjBlR2gyalNXUEJYNUd1cUlIb1pKWkciLCJuYW1lIjoiSUNFLVQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGVHaDJqU1dQQlg1R3VxSUhvWkpaRyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzd2S3VLMVBlcjNoSVVKM2I5dUVPR24ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83dkt1SzFQZXIzaElVSjNiOXVFT0duIiwiaWQiOiI3dkt1SzFQZXIzaElVSjNiOXVFT0duIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQzZDlhMzc5Zjk4N2Y4NTE2YjgzMmQxMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0M2Q5YTM3OWY5ODdmODUxNmI4MzJkMTIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQzZDlhMzc5Zjk4N2Y4NTE2YjgzMmQxMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdXBlcmZseSAxOTkwIiwicmVsZWFzZV9kYXRlIjoiMTk5MC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N3ZLdUsxUGVyM2hJVUozYjl1RU9HbiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJBVjZYRElzMzJvZklKaGtrRGV2am0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsImlkIjoiMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsIm5hbWUiOiJDdXJ0aXMgTWF5ZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZUdoMmpTV1BCWDVHdXFJSG9aSlpHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBlR2gyalNXUEJYNUd1cUlIb1pKWkciLCJpZCI6IjBlR2gyalNXUEJYNUd1cUlIb1pKWkciLCJuYW1lIjoiSUNFLVQiLCJ0eQ==", + "cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZUdoMmpTV1BCWDVHdXFJSG9aSlpHIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI3MjI2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQ0EyOTAwMTQyNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNjhiek5rN0JydkFHVHU1WThWRWFTUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzY4YnpOazdCcnZBR1R1NVk4VkVhU1EiLCJpZCI6IjY4YnpOazdCcnZBR1R1NVk4VkVhU1EiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VwZXJmbHkgMTk5MCAtIExQIEVkaXQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Njhiek5rN0JydkFHVHU1WThWRWFTUSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQVY2WERJczMyb2ZJSmhra0RldmptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJpZCI6IjJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJuYW1lIjoiQ3VydGlzIE1heWZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVjZYRElzMzJvZklKaGtrRGV2am0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82ODhLaDlGRWVmMnVhSk9YRnRPdFhwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjg4S2g5RkVlZjJ1YUpPWEZ0T3RYcCIsImlkIjoiNjg4S2g5RkVlZjJ1YUpPWEZ0T3RYcCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiNjhiOTA1OTJlMGJhZmViZDBmMTgzNmUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjY4YjkwNTkyZTBiYWZlYmQwZjE4MzZlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiNjhiOTA1OTJlMGJhZmViZDBmMTgzNmUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ3VydGlzIExpdmUhIChVUyBSZWxlYXNlKSIsInJlbGVhc2VfZGF0ZSI6IjE5NzEiLCJyZWxlYXNlX2RhdGVfcHJlYw==", + "aXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2ODhLaDlGRWVmMnVhSk9YRnRPdFhwIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQVY2WERJczMyb2ZJSmhra0RldmptIiwiaWQiOiIyQVY2WERJczMyb2ZJSmhra0RldmptIiwibmFtZSI6IkN1cnRpcyBNYXlmaWVsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQVY2WERJczMyb2ZJSmhra0RldmptIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNjY2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMDIwMDE3MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM1loSWZMNFEwZUNpaXhaWFJOR2NGQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNZaElmTDRRMGVDaWl4WlhSTkdjRkMiLCJpZCI6IjNZaElmTDRRMGVDaWl4WlhSTkdjRkMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VwZXJmbHkgLSBSZWNvcmRlZCBMaXZlIGJ5IFdUVFctVFYgQ2hpY2FnbyIsInRyYWNrX251bWJlciI6MTcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M1loSWZMNFEwZUNpaXhaWFJOR2NGQyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQVY2WERJczMyb2ZJSmhra0RldmptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJpZCI6IjJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJuYW1lIjoiQ3VydGlzIE1heWZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVjZYRElzMzJvZklKaGtrRGV2am0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8weWFkNnVHc2gyckp2TWJZSHFzcHJmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMHlhZDZ1R3NoMnJKdk1iWUhxc3ByZiIsImlkIjoiMHlhZDZ1R3NoMnJKdk1iWUhxc3ByZiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvLw==", + "aW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzM0Mjk4MjIyNmM2ZTdjOWE4Y2YxNGE5MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzNDI5ODIyMjZjNmU3YzlhOGNmMTRhOTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTM0Mjk4MjIyNmM2ZTdjOWE4Y2YxNGE5MSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgRXNzZW50aWFscyIsInJlbGVhc2VfZGF0ZSI6IjIwMDItMDYtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToweWFkNnVHc2gyckp2TWJZSHFzcHJmIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yQVY2WERJczMyb2ZJSmhra0RldmptIiwiaWQiOiIyQVY2WERJczMyb2ZJSmhra0RldmptIiwibmFtZSI6IkN1cnRpcyBNYXlmaWVsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyQVY2WERJczMyb2ZJSmhra0RldmptIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzMzYwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMDI4NDkyOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN0ZWSnZ4MUJEd1hHUE1yenoyNmJxWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdGVkp2eDFCRHdYR1BNcnp6MjZicVgiLCJpZCI6IjdGVkp2eDFCRHdYR1BNcnp6MjZicVgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VwZXJmbHkiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N0ZWSnZ4MUJEd1hHUE1yenoyNmJxWCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQVY2WERJczMyb2ZJSmhra0RldmptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJpZCI6IjJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJuYW1lIjoiQ3VydGlzIE1heWZpZWxkIiwidHlwZSI6ImFydA==", + "aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVRdXZsVTduQ1VaWkphdU12aGxXUjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81UXV2bFU3bkNVWlpKYXVNdmhsV1I0IiwiaWQiOiI1UXV2bFU3bkNVWlpKYXVNdmhsV1I0IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE3N2ZlYTNmYzdmODA3NWZkYjQwZjE2NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNzdmZWEzZmM3ZjgwNzVmZGI0MGYxNjcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE3N2ZlYTNmYzdmODA3NWZkYjQwZjE2NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdXBlcmZseTogRGVsdXhlIDI1dGggQW5uaXZlcnNhcnkgRWRpdGlvbiIsInJlbGVhc2VfZGF0ZSI6IjE5NzItMDctMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1UXV2bFU3bkNVWlpKYXVNdmhsV1I0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aQ==", + "c3RzLzJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJpZCI6IjJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJuYW1lIjoiQ3VydGlzIE1heWZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVjZYRElzMzJvZklKaGtrRGV2am0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjExMzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDEwMjgzNDA0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81WmxMSTZuOGUzd2xPcnNjQW9DS21RIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNVpsTEk2bjhlM3dsT3JzY0FvQ0ttUSIsImlkIjoiNVpsTEk2bjhlM3dsT3JzY0FvQ0ttUSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdXBlcmZseSAtIFNpbmdsZSBNaXggVmVyc2lvbiIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NVpsTEk2bjhlM3dsT3JzY0FvQ0ttUSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yQVY2WERJczMyb2ZJSmhra0RldmptIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJpZCI6IjJBVjZYRElzMzJvZklKaGtrRGV2am0iLCJuYW1lIjoiQ3VydGlzIE1heWZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVjZYRElzMzJvZklKaGtrRGV2am0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81bGpJR0NSUnZTNDhWNEFEelBHYXYyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWxqSUdDUlJ2UzQ4VjRBRHpQR2F2MiIsImlkIjoiNWxqSUdDUlJ2UzQ4VjRBRHpQR2F2MiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1MzJlMDk1NmEwZjVhZTc0MThjNjNjZWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTMyZTA5NTZhMGY1YWU3NDE4YzYzY2ViIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1MzJlMDk1NmEwZjVhZTc0MThjNjNjZWIifV0sIg==", + "aXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdXBlcmZseSAoT3JpZ2luYWwgU291bmR0cmFjaykiLCJyZWxlYXNlX2RhdGUiOiIxOTcyLTA3LTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWxqSUdDUlJ2UzQ4VjRBRHpQR2F2MiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJBVjZYRElzMzJvZklKaGtrRGV2am0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsImlkIjoiMkFWNlhESXMzMm9mSUpoa2tEZXZqbSIsIm5hbWUiOiJDdXJ0aXMgTWF5ZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkFWNlhESXMzMm9mSUpoa2tEZXZqbSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDA3MjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTAyODI4NDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJUY1owRjNnNVl5N01ZZHpGM1J2UVgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yVGNaMEYzZzVZeTdNWWR6RjNSdlFYIiwiaWQiOiIyVGNaMEYzZzVZeTdNWWR6RjNSdlFYIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZyZWRkaWUncyBEZWFkIC0gVGhlbWUgRnJvbSAnU3VwZXJmbHknOyBTaW5nbGUgTWl4IiwidHJhY2tfbnVtYmVyIjoxMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyVGNaMEYzZzVZeTdNWWR6RjNSdlFYIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Superfly%22+artist%3A%22Curtis+Mayfield%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Let%27s%20Stay%20Together%22%20artist%3A%22Al%20Green%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"external_urls":{"spotify":"https://open.spotify.com/album/58eMx3QrTkiRmGGbSz2XL0"},"href":"https://api.spotify.com/v1/albums/58eMx3QrTkiRmGGbSz2XL0","id":"58eMx3QrTkiRmGGbSz2XL0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a1fc113a6858d0824d9aaf38"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a1fc113a6858d0824d9aaf38"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a1fc113a6858d0824d9aaf38"}],"is_playable":true,"name":"Let's Stay Together","release_date":"1972","release_date_precision":"year","total_tracks":9,"type":"album","uri":"spotify:album:58eMx3QrTkiRmGGbSz2XL0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"disc_number":1,"duration_ms":199396,"explicit":false,"external_ids":{"isrc":"US2HK0913701"},"external_urls":{"spotify":"https://open.spotify.com/track/63xdwScd1Ai1GigAwQxE8y"},"href":"https://api.spotify.com/v1/tracks/63xdwScd1Ai1GigAwQxE8y","id":"63xdwScd1Ai1GigAwQxE8y","is_local":false,"is_playable":true,"name":"Let's Stay Together","track_number":1,"type":"track","uri":"spotify:track:63xdwScd1Ai1GigAwQxE8y"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"external_urls":{"spotify":"https://open.spotify.com/album/1tnqnzIT3HR1zBa8bkvwci"},"href":"https://api.spotify.com/v1/albums/1tnqnzIT3HR1zBa8bkvwci","id":"1tnqnzIT3HR1zBa8bkvwci","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273344dc5e7ace0a881691e7a35"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02344dc5e7ace0a881691e7a35"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851344dc5e7ace0a881691e7a35"}],"is_playable":true,"name":"Give Me More Love","release_date":"2021-09-24","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1tnqnzIT3HR1zBa8bkvwci"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"disc_number":1,"duration_ms":219029,"explicit":false,"external_ids":{"isrc":"QMBZ92196625"},"external_urls":{"spotify":"https://open.spotify.com/track/1HbIFqrqfETLyCMX3E1PWr"},"href":"https://api.spotify.com/v1/tracks/1HbIFqrqfETLyCMX3E1PWr","id":"1HbIFqrqfETLyCMX3E1PWr","is_local":false,"is_playable":true,"name":"Let's Stay Together - Orchestral","track_number":3,"type":"track","uri":"spotify:track:1HbIFqrqfETLyCMX3E1PWr"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"external_urls":{"spotify":"https://open.spotify.com/album/6W0V8B0fJItvOwC8v114rZ"},"href":"https://api.spotify.com/v1/albums/6W0V8B0fJItvOwC8v114rZ","id":"6W0V8B0fJItvOwC8v114rZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273400cef779a4cd24ebe742e9c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02400cef779a4cd24ebe742e9c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851400cef779a4cd24ebe742e9c"}],"is_playable":true,"name":"Greatest Hits","release_date":"1975-05-29","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:6W0V8B0fJItvOwC8v114rZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"disc_number":1,"duration_ms":198400,"explicit":false,"external_ids":{"isrc":"US2HK0914206"},"external_urls":{"spotify":"https://open.spotify.com/track/43YXZFad8aVLWojvBLZ62V"},"href":"https://api.spotify.com/v1/tracks/43YXZFad8aVLWojvBLZ62V","id":"43YXZFad8aVLWojvBLZ62V","is_local":false,"is_playable":true,"name":"Let's Stay Together","track_number":6,"type":"track","uri":"spotify:track:43YXZFad8aVLWojvBLZ62V"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ON1SpKi7LFb8axFjAmpEJ"},"href":"https://api.spotify.com/v1/albums/5ON1SpKi7LFb8axFjAmpEJ","id":"5ON1SpKi7LFb8axFjAmpEJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b28a1abbf39d2677ceee94c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b28a1abbf39d2677ceee94c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b28a1abbf39d2677ceee94c"}],"is_playable":true,"name":"Tokyo... Live","release_date":"1978-06-23","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:5ON1SpKi7LFb8axFjAmpEJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"disc_number":1,"duration_ms":232706,"explicit":false,"external_ids":{"isrc":"USFP71658503"},"external_urls":{"spotify":"https://open.spotify.com/track/474iAHLvDbXAQnEI82i4RW"},"href":"https://api.spotify.com/v1/tracks/474iAHLvDbXAQnEI82i4RW","id":"474iAHLvDbXAQnEI82i4RW","is_local":false,"is_playable":true,"name":"Let's Stay Together - Live","track_number":3,"type":"track","uri":"spotify:track:474iAHLvDbXAQnEI82i4RW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Ae8CQOm7V1OQYtDlsUNbQ"},"href":"https://api.spotify.com/v1/albums/5Ae8CQOm7V1OQYtDlsUNbQ","id":"5Ae8CQOm7V1OQYtDlsUNbQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27322fd78b6a140e7532d4d984b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0222fd78b6a140e7532d4d984b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485122fd78b6a140e7532d4d984b"}],"is_playable":true,"name":"Greatest Hits: The Best of Al Green","release_date":"2014-11-24","release_date_precision":"day","total_tracks":42,"type":"album","uri":"spotify:album:5Ae8CQOm7V1OQYtDlsUNbQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"disc_number":1,"duration_ms":197733,"explicit":false,"external_ids":{"isrc":"US2HK1448701"},"external_urls":{"spotify":"https://open.spotify.com/track/5kPlqT7F0jDOYeUfNAUuRu"},"href":"https://api.spotify.com/v1/tracks/5kPlqT7F0jDOYeUfNAUuRu","id":"5kPlqT7F0jDOYeUfNAUuRu","is_local":false,"is_playable":true,"name":"Let's Stay Together","track_number":1,"type":"track","uri":"spotify:track:5kPlqT7F0jDOYeUfNAUuRu"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6xDW6TfPeBAiq1gmqMJnM6"},"href":"https://api.spotify.com/v1/artists/6xDW6TfPeBAiq1gmqMJnM6","id":"6xDW6TfPeBAiq1gmqMJnM6","name":"Tom Moulton","type":"artist","uri":"spotify:artist:6xDW6TfPeBAiq1gmqMJnM6"}],"external_urls":{"spotify":"https://open.spotify.com/album/4fE63ktGXZM7heCoYUyynL"},"href":"https://api.spotify.com/v1/albums/4fE63ktGXZM7heCoYUyynL","id":"4fE63ktGXZM7heCoYUyynL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27373278bbe38df0f8a74689494"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0273278bbe38df0f8a74689494"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485173278bbe38df0f8a74689494"}],"is_playable":true,"name":"Let's Stay Together - A Tom Moulton Mix","release_date":"2018-03-09","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4fE63ktGXZM7heCoYUyynL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6xDW6TfPeBAiq1gmqMJnM6"},"href":"https://api.spotify.com/v1/artists/6xDW6TfPeBAiq1gmqMJnM6","id":"6xDW6TfPeBAiq1gmqMJnM6","name":"Tom Moulton","type":"artist","uri":"spotify:artist:6xDW6TfPeBAiq1gmqMJnM6"}],"disc_number":1,"duration_ms":442484,"explicit":false,"external_ids":{"isrc":"USFP71813799"},"external_urls":{"spotify":"https://open.spotify.com/track/3CGXiuNWPWEyUnTxE8L270"},"href":"https://api.spotify.com/v1/tracks/3CGXiuNWPWEyUnTxE8L270","id":"3CGXiuNWPWEyUnTxE8L270","is_local":false,"is_playable":true,"name":"Let's Stay Together","track_number":1,"type":"track","uri":"spotify:track:3CGXiuNWPWEyUnTxE8L270"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"external_urls":{"spotify":"https://open.spotify.com/album/72nas8CAoZ4gQzKq4VqYvH"},"href":"https://api.spotify.com/v1/albums/72nas8CAoZ4gQzKq4VqYvH","id":"72nas8CAoZ4gQzKq4VqYvH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cd6d29ee82ca2c3c3bfd7add"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cd6d29ee82ca2c3c3bfd7add"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cd6d29ee82ca2c3c3bfd7add"}],"is_playable":true,"name":"All Right With Me (Live Chicago '87)","release_date":"2022-09-23","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:72nas8CAoZ4gQzKq4VqYvH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"disc_number":1,"duration_ms":208527,"explicit":false,"external_ids":{"isrc":"GX89G2271725"},"external_urls":{"spotify":"https://open.spotify.com/track/5sUR8wYWBWxHYOuG7wnZOj"},"href":"https://api.spotify.com/v1/tracks/5sUR8wYWBWxHYOuG7wnZOj","id":"5sUR8wYWBWxHYOuG7wnZOj","is_local":false,"is_playable":true,"name":"Let's Stay Together - Live","track_number":7,"type":"track","uri":"spotify:track:5sUR8wYWBWxHYOuG7wnZOj"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"external_urls":{"spotify":"https://open.spotify.com/album/2Q8dU9GQEeuZRfJ6gpietG"},"href":"https://api.spotify.com/v1/albums/2Q8dU9GQEeuZRfJ6gpietG","id":"2Q8dU9GQEeuZRfJ6gpietG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730e5e1bcd0cb3d1485b6b74e1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020e5e1bcd0cb3d1485b6b74e1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510e5e1bcd0cb3d1485b6b74e1"}],"is_playable":true,"name":"The Love Songs Collection","release_date":"2013","release_date_precision":"year","total_tracks":18,"type":"album","uri":"spotify:album:2Q8dU9GQEeuZRfJ6gpietG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"disc_number":1,"duration_ms":198640,"explicit":false,"external_ids":{"isrc":"USFP71329116"},"external_urls":{"spotify":"https://open.spotify.com/track/4RPPZAz9DeCPL0l6v8BhYJ"},"href":"https://api.spotify.com/v1/tracks/4RPPZAz9DeCPL0l6v8BhYJ","id":"4RPPZAz9DeCPL0l6v8BhYJ","is_local":false,"is_playable":true,"name":"Let's Stay Together","track_number":16,"type":"track","uri":"spotify:track:4RPPZAz9DeCPL0l6v8BhYJ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/116sH1i68OaOgaCyliZVOD"},"href":"https://api.spotify.com/v1/albums/116sH1i68OaOgaCyliZVOD","id":"116sH1i68OaOgaCyliZVOD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736f61bb6135b835355678700b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026f61bb6135b835355678700b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516f61bb6135b835355678700b"}],"is_playable":true,"name":"Hi Records: The Soul Years","release_date":"2016-12-01","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:116sH1i68OaOgaCyliZVOD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"disc_number":1,"duration_ms":198400,"explicit":false,"external_ids":{"isrc":"US2HK1448311"},"external_urls":{"spotify":"https://open.spotify.com/track/0yvEJYbHVAicEaGAaQ9KPt"},"href":"https://api.spotify.com/v1/tracks/0yvEJYbHVAicEaGAaQ9KPt","id":"0yvEJYbHVAicEaGAaQ9KPt","is_local":false,"is_playable":true,"name":"Let's Stay Together","track_number":11,"type":"track","uri":"spotify:track:0yvEJYbHVAicEaGAaQ9KPt"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"external_urls":{"spotify":"https://open.spotify.com/album/6gFbwjfZlO5NKSFD5THsSJ"},"href":"https://api.spotify.com/v1/albums/6gFbwjfZlO5NKSFD5THsSJ","id":"6gFbwjfZlO5NKSFD5THsSJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273817bda29f2779cd3ce072ecb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02817bda29f2779cd3ce072ecb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851817bda29f2779cd3ce072ecb"}],"is_playable":true,"name":"The Hi Records Singles Collection","release_date":"2019-06-14","release_date_precision":"day","total_tracks":57,"type":"album","uri":"spotify:album:6gFbwjfZlO5NKSFD5THsSJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3dkbV4qihUeMsqN4vBGg93"},"href":"https://api.spotify.com/v1/artists/3dkbV4qihUeMsqN4vBGg93","id":"3dkbV4qihUeMsqN4vBGg93","name":"Al Green","type":"artist","uri":"spotify:artist:3dkbV4qihUeMsqN4vBGg93"}],"disc_number":1,"duration_ms":200064,"explicit":false,"external_ids":{"isrc":"US2HK0914206"},"external_urls":{"spotify":"https://open.spotify.com/track/1FYKJqIMxNvK5ZFjJEIHAE"},"href":"https://api.spotify.com/v1/tracks/1FYKJqIMxNvK5ZFjJEIHAE","id":"1FYKJqIMxNvK5ZFjJEIHAE","is_local":false,"is_playable":true,"name":"Let's Stay Together","track_number":15,"type":"track","uri":"spotify:track:1FYKJqIMxNvK5ZFjJEIHAE"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkxldCUyN3MlMjBTdGF5JTIwVG9nZXRoZXIlMjIlMjBhcnRpc3QlM0ElMjJBbCUyMEdyZWVuJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZGtiVjRxaWhVZU1zcU40dkJHZzkzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJpZCI6IjNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJuYW1lIjoiQWwgR3JlZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2RrYlY0cWloVWVNc3FONHZCR2c5MyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzU4ZU14M1FyVGtpUm1HR2JTejJYTDAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81OGVNeDNRclRraVJtR0diU3oyWEwwIiwiaWQiOiI1OGVNeDNRclRraVJtR0diU3oyWEwwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ExZmMxMTNhNjg1OGQwODI0ZDlhYWYzOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhMWZjMTEzYTY4NThkMDgyNGQ5YWFmMzgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWExZmMxMTNhNjg1OGQwODI0ZDlhYWYzOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMZXQncyBTdGF5IFRvZ2V0aGVyIiwicmVsZWFzZV9kYXRlIjoiMTk3MiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjo5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjU4ZU14M1FyVGtpUm1HR2JTejJYTDAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZGtiVjRxaWhVZU1zcU40dkJHZzkzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJpZCI6IjNka2JWNA==", + "cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGtiVjRxaWhVZU1zcU40dkJHZzkzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5OTM5NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTMkhLMDkxMzcwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNjN4ZHdTY2QxQWkxR2lnQXdReEU4eSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzYzeGR3U2NkMUFpMUdpZ0F3UXhFOHkiLCJpZCI6IjYzeGR3U2NkMUFpMUdpZ0F3UXhFOHkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGV0J3MgU3RheSBUb2dldGhlciIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2M3hkd1NjZDFBaTFHaWdBd1F4RTh5In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsImlkIjoiM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGtiVjRxaWhVZU1zcU40dkJHZzkzIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMXRucW56SVQzSFIxekJhOGJrdndjaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzF0bnFueklUM0hSMXpCYThia3Z3Y2kiLCJpZCI6IjF0bnFueklUM0hSMXpCYThia3Z3Y2kiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzQ0ZGM1ZTdhY2UwYTg4MTY5MWU3YTM1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjM0NGRjNWU3YWNlMGE4ODE2OTFlN2EzNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzQ0ZGM1ZTdhY2UwYTg4MTY5MWU3YTM1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdpdmUgTWUgTW9yZSBMb3ZlIiwicmVsZWFzZV9kYXRlIjoiMjAyMQ==", + "LTA5LTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXRucW56SVQzSFIxekJhOGJrdndjaSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsImlkIjoiM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGtiVjRxaWhVZU1zcU40dkJHZzkzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxOTAyOSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFNQlo5MjE5NjYyNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUhiSUZxcnFmRVRMeUNNWDNFMVBXciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFIYklGcXJxZkVUTHlDTVgzRTFQV3IiLCJpZCI6IjFIYklGcXJxZkVUTHlDTVgzRTFQV3IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGV0J3MgU3RheSBUb2dldGhlciAtIE9yY2hlc3RyYWwiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUhiSUZxcnFmRVRMeUNNWDNFMVBXciJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZGtiVjRxaWhVZU1zcU40dkJHZzkzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJpZCI6IjNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJuYW1lIjoiQWwgR3JlZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2RrYlY0cWloVWVNc3FONHZCR2c5MyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZXMFY4QjBmSkl0dk93Qzh2MTE0cloifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82VzBWOEIwZkpJdHZPd0M4djExNHJaIiwiaWQiOiI2VzBWOEIwZkpJdHZPd0M4djExNHJaIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaQ==", + "bWFnZS9hYjY3NjE2ZDAwMDBiMjczNDAwY2VmNzc5YTRjZDI0ZWJlNzQyZTljIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQwMGNlZjc3OWE0Y2QyNGViZTc0MmU5YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDAwY2VmNzc5YTRjZDI0ZWJlNzQyZTljIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdyZWF0ZXN0IEhpdHMiLCJyZWxlYXNlX2RhdGUiOiIxOTc1LTA1LTI5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlcwVjhCMGZKSXR2T3dDOHYxMTRyWiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsImlkIjoiM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGtiVjRxaWhVZU1zcU40dkJHZzkzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5ODQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTMkhLMDkxNDIwNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDNZWFpGYWQ4YVZMV29qdkJMWjYyViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQzWVhaRmFkOGFWTFdvanZCTFo2MlYiLCJpZCI6IjQzWVhaRmFkOGFWTFdvanZCTFo2MlYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGV0J3MgU3RheSBUb2dldGhlciIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0M1lYWkZhZDhhVkxXb2p2QkxaNjJWIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsImlkIjoiM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLA==", + "InVyaSI6InNwb3RpZnk6YXJ0aXN0OjNka2JWNHFpaFVlTXNxTjR2QkdnOTMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81T04xU3BLaTdMRmI4YXhGakFtcEVKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNU9OMVNwS2k3TEZiOGF4RmpBbXBFSiIsImlkIjoiNU9OMVNwS2k3TEZiOGF4RmpBbXBFSiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1YjI4YTFhYmJmMzlkMjY3N2NlZWU5NGMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWIyOGExYWJiZjM5ZDI2NzdjZWVlOTRjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1YjI4YTFhYmJmMzlkMjY3N2NlZWU5NGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVG9reW8uLi4gTGl2ZSIsInJlbGVhc2VfZGF0ZSI6IjE5NzgtMDYtMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1T04xU3BLaTdMRmI4YXhGakFtcEVKIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2RrYlY0cWloVWVNc3FONHZCR2c5MyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zZGtiVjRxaWhVZU1zcU40dkJHZzkzIiwiaWQiOiIzZGtiVjRxaWhVZU1zcU40dkJHZzkzIiwibmFtZSI6IkFsIEdyZWVuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNka2JWNHFpaFVlTXNxTjR2QkdnOTMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMyNzA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNGUDcxNjU4NTAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80NzRpQUhMdkRiWEFRbkVJODJpNFJXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDc0aUFITHZEYlhBUW5FSTgyaTRSVyIsImlkIjoiNDc0aUFITHZEYlhBUW5FSTgyaTRSVyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMZXQncyBTdGF5IFRvZ2V0aGVyIC0gTGl2ZSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoicw==", + "cG90aWZ5OnRyYWNrOjQ3NGlBSEx2RGJYQVFuRUk4Mmk0UlcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2RrYlY0cWloVWVNc3FONHZCR2c5MyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zZGtiVjRxaWhVZU1zcU40dkJHZzkzIiwiaWQiOiIzZGtiVjRxaWhVZU1zcU40dkJHZzkzIiwibmFtZSI6IkFsIEdyZWVuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNka2JWNHFpaFVlTXNxTjR2QkdnOTMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81QWU4Q1FPbTdWMU9RWXREbHNVTmJRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUFlOENRT203VjFPUVl0RGxzVU5iUSIsImlkIjoiNUFlOENRT203VjFPUVl0RGxzVU5iUSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyMmZkNzhiNmExNDBlNzUzMmQ0ZDk4NGIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMjJmZDc4YjZhMTQwZTc1MzJkNGQ5ODRiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyMmZkNzhiNmExNDBlNzUzMmQ0ZDk4NGIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3JlYXRlc3QgSGl0czogVGhlIEJlc3Qgb2YgQWwgR3JlZW4iLCJyZWxlYXNlX2RhdGUiOiIyMDE0LTExLTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUFlOENRT203VjFPUVl0RGxzVU5iUSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsImlkIjoiM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGtiVjRxaWhVZU1zcU40dkJHZzkzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5NzczMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcg==", + "bmFsX2lkcyI6eyJpc3JjIjoiVVMySEsxNDQ4NzAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81a1BscVQ3RjBqRE9ZZVVmTkFVdVJ1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNWtQbHFUN0YwakRPWWVVZk5BVXVSdSIsImlkIjoiNWtQbHFUN0YwakRPWWVVZk5BVXVSdSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMZXQncyBTdGF5IFRvZ2V0aGVyIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVrUGxxVDdGMGpET1llVWZOQVV1UnUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsImlkIjoiM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGtiVjRxaWhVZU1zcU40dkJHZzkzIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ4RFc2VGZQZUJBaXExZ21xTUpuTTYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnhEVzZUZlBlQkFpcTFnbXFNSm5NNiIsImlkIjoiNnhEVzZUZlBlQkFpcTFnbXFNSm5NNiIsIm5hbWUiOiJUb20gTW91bHRvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2eERXNlRmUGVCQWlxMWdtcU1Kbk02In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNGZFNjNrdEdYWk03aGVDb1lVeXluTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRmRTYza3RHWFpNN2hlQ29ZVXl5bkwiLCJpZCI6IjRmRTYza3RHWFpNN2hlQ29ZVXl5bkwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzMyNzhiYmUzOGRmMGY4YTc0Njg5NDk0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjczMjc4YmJlMzhkZjBmOGE3NDY4OTQ5NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYg==", + "Njc2MTZkMDAwMDQ4NTE3MzI3OGJiZTM4ZGYwZjhhNzQ2ODk0OTQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGV0J3MgU3RheSBUb2dldGhlciAtIEEgVG9tIE1vdWx0b24gTWl4IiwicmVsZWFzZV9kYXRlIjoiMjAxOC0wMy0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NGZFNjNrdEdYWk03aGVDb1lVeXluTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsImlkIjoiM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGtiVjRxaWhVZU1zcU40dkJHZzkzIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ4RFc2VGZQZUJBaXExZ21xTUpuTTYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnhEVzZUZlBlQkFpcTFnbXFNSm5NNiIsImlkIjoiNnhEVzZUZlBlQkFpcTFnbXFNSm5NNiIsIm5hbWUiOiJUb20gTW91bHRvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2eERXNlRmUGVCQWlxMWdtcU1Kbk02In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQ0MjQ4NCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRlA3MTgxMzc5OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0NHWGl1TldQV0V5VW5UeEU4TDI3MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNDR1hpdU5XUFdFeVVuVHhFOEwyNzAiLCJpZCI6IjNDR1hpdU5XUFdFeVVuVHhFOEwyNzAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGV0J3MgU3RheSBUb2dldGhlciIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozQ0dYaXVOV1BXRXlVblR4RThMMjcwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMw==", + "ZGtiVjRxaWhVZU1zcU40dkJHZzkzIiwiaWQiOiIzZGtiVjRxaWhVZU1zcU40dkJHZzkzIiwibmFtZSI6IkFsIEdyZWVuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNka2JWNHFpaFVlTXNxTjR2QkdnOTMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83Mm5hczhDQW9aNGdRektxNFZxWXZIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzJuYXM4Q0FvWjRnUXpLcTRWcVl2SCIsImlkIjoiNzJuYXM4Q0FvWjRnUXpLcTRWcVl2SCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjZDZkMjllZTgyY2EyYzNjM2JmZDdhZGQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyY2Q2ZDI5ZWU4MmNhMmMzYzNiZmQ3YWRkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjZDZkMjllZTgyY2EyYzNjM2JmZDdhZGQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWxsIFJpZ2h0IFdpdGggTWUgKExpdmUgQ2hpY2FnbyAnODcpIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0wOS0yMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjcybmFzOENBb1o0Z1F6S3E0VnFZdkgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZGtiVjRxaWhVZU1zcU40dkJHZzkzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJpZCI6IjNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJuYW1lIjoiQWwgR3JlZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2RrYlY0cWloVWVNc3FONHZCR2c5MyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDg1MjcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHWDg5RzIyNzE3MjUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVzVVI4d1lXQld4SFlPdUc3d25aT2oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81c1VSOHdZV0JXeEhZT3VHN3duWk9qIiwiaWQiOiI1c1VSOHdZV0JXeEhZT3VHN3duWk9qIiwiaQ==", + "c19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGV0J3MgU3RheSBUb2dldGhlciAtIExpdmUiLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXNVUjh3WVdCV3hIWU91Rzd3blpPaiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZGtiVjRxaWhVZU1zcU40dkJHZzkzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJpZCI6IjNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJuYW1lIjoiQWwgR3JlZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2RrYlY0cWloVWVNc3FONHZCR2c5MyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJROGRVOUdRRWV1WlJmSjZncGlldEcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yUThkVTlHUUVldVpSZko2Z3BpZXRHIiwiaWQiOiIyUThkVTlHUUVldVpSZko2Z3BpZXRHIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzBlNWUxYmNkMGNiM2QxNDg1YjZiNzRlMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwZTVlMWJjZDBjYjNkMTQ4NWI2Yjc0ZTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTBlNWUxYmNkMGNiM2QxNDg1YjZiNzRlMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgTG92ZSBTb25ncyBDb2xsZWN0aW9uIiwicmVsZWFzZV9kYXRlIjoiMjAxMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyUThkVTlHUUVldVpSZko2Z3BpZXRHIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2RrYlY0cWloVWVNc3FONHZCR2c5MyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zZGtiVjRxaWhVZU1zcU40dkJHZzkzIiwiaWQiOiIzZGtiVjRxaWhVZU1zcU40dkJHZzkzIiwibmFtZSI6IkFsIEdyZWVuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZg==", + "eTphcnRpc3Q6M2RrYlY0cWloVWVNc3FONHZCR2c5MyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTg2NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0ZQNzEzMjkxMTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRSUFBaQXo5RGVDUEwwbDZ2OEJoWUoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80UlBQWkF6OURlQ1BMMGw2djhCaFlKIiwiaWQiOiI0UlBQWkF6OURlQ1BMMGw2djhCaFlKIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxldCdzIFN0YXkgVG9nZXRoZXIiLCJ0cmFja19udW1iZXIiOjE2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRSUFBaQXo5RGVDUEwwbDZ2OEJoWUoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMTE2c0gxaTY4T2FPZ2FDeWxpWlZPRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzExNnNIMWk2OE9hT2dhQ3lsaVpWT0QiLCJpZCI6IjExNnNIMWk2OE9hT2dhQ3lsaVpWT0QiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmY2MWJiNjEzNWI4MzUzNTU2Nzg3MDBiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZmNjFiYjYxMzViODM1MzU1Njc4NzAwYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmY2MWJiNjEzNWI4MzUzNTU2Nzg3MDBiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhpIFJlY29yZHM6IFRoZSBTb3VsIFllYXJzIiwicmVsZWFzZV9kYXRlIjoiMjAxNi0xMi0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0bw==", + "dGFsX3RyYWNrcyI6NDgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MTE2c0gxaTY4T2FPZ2FDeWxpWlZPRCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsImlkIjoiM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGtiVjRxaWhVZU1zcU40dkJHZzkzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5ODQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTMkhLMTQ0ODMxMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHl2RUpZYkhWQWljRWFHQWFROUtQdCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzB5dkVKWWJIVkFpY0VhR0FhUTlLUHQiLCJpZCI6IjB5dkVKWWJIVkFpY0VhR0FhUTlLUHQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGV0J3MgU3RheSBUb2dldGhlciIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHl2RUpZYkhWQWljRWFHQWFROUtQdCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZGtiVjRxaWhVZU1zcU40dkJHZzkzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJpZCI6IjNka2JWNHFpaFVlTXNxTjR2QkdnOTMiLCJuYW1lIjoiQWwgR3JlZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2RrYlY0cWloVWVNc3FONHZCR2c5MyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZnRmJ3amZabE81TktTRkQ1VEhzU0oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29t", + "L3YxL2FsYnVtcy82Z0Zid2pmWmxPNU5LU0ZENVRIc1NKIiwiaWQiOiI2Z0Zid2pmWmxPNU5LU0ZENVRIc1NKIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzgxN2JkYTI5ZjI3NzljZDNjZTA3MmVjYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4MTdiZGEyOWYyNzc5Y2QzY2UwNzJlY2IifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTgxN2JkYTI5ZjI3NzljZDNjZTA3MmVjYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgSGkgUmVjb3JkcyBTaW5nbGVzIENvbGxlY3Rpb24iLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA2LTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NmdGYndqZlpsTzVOS1NGRDVUSHNTSiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNka2JWNHFpaFVlTXNxTjR2QkdnOTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsImlkIjoiM2RrYlY0cWloVWVNc3FONHZCR2c5MyIsIm5hbWUiOiJBbCBHcmVlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZGtiVjRxaWhVZU1zcU40dkJHZzkzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwMDA2NCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTMkhLMDkxNDIwNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUZZS0pxSU14TnZLNVpGakpFSUhBRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFGWUtKcUlNeE52SzVaRmpKRUlIQUUiLCJpZCI6IjFGWUtKcUlNeE52SzVaRmpKRUlIQUUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGV0J3MgU3RheSBUb2dldGhlciIsInRyYWNrX251bWJlciI6MTUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUZZS0pxSU14TnZLNVpGakpFSUhBRSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Let%27s+Stay+Together%22+artist%3A%22Al+Green%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Natural%20High%22%20artist%3A%22Bloodstone%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7z1zaOeWiHpl4SD2N9ZBgk"},"href":"https://api.spotify.com/v1/artists/7z1zaOeWiHpl4SD2N9ZBgk","id":"7z1zaOeWiHpl4SD2N9ZBgk","name":"Bloodstone","type":"artist","uri":"spotify:artist:7z1zaOeWiHpl4SD2N9ZBgk"}],"external_urls":{"spotify":"https://open.spotify.com/album/4kjf1C8Xpqr2e7pTDwblG2"},"href":"https://api.spotify.com/v1/albums/4kjf1C8Xpqr2e7pTDwblG2","id":"4kjf1C8Xpqr2e7pTDwblG2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273809e8b9431e1cb62c66e270a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02809e8b9431e1cb62c66e270a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851809e8b9431e1cb62c66e270a"}],"is_playable":true,"name":"Natural High","release_date":"1972-09-15","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4kjf1C8Xpqr2e7pTDwblG2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7z1zaOeWiHpl4SD2N9ZBgk"},"href":"https://api.spotify.com/v1/artists/7z1zaOeWiHpl4SD2N9ZBgk","id":"7z1zaOeWiHpl4SD2N9ZBgk","name":"Bloodstone","type":"artist","uri":"spotify:artist:7z1zaOeWiHpl4SD2N9ZBgk"}],"disc_number":1,"duration_ms":240466,"explicit":false,"external_ids":{"isrc":"USRH10450039"},"external_urls":{"spotify":"https://open.spotify.com/track/7aKrysuyZvDnU3JwnlO3dd"},"href":"https://api.spotify.com/v1/tracks/7aKrysuyZvDnU3JwnlO3dd","id":"7aKrysuyZvDnU3JwnlO3dd","is_local":false,"is_playable":true,"name":"Natural High","track_number":6,"type":"track","uri":"spotify:track:7aKrysuyZvDnU3JwnlO3dd"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7z1zaOeWiHpl4SD2N9ZBgk"},"href":"https://api.spotify.com/v1/artists/7z1zaOeWiHpl4SD2N9ZBgk","id":"7z1zaOeWiHpl4SD2N9ZBgk","name":"Bloodstone","type":"artist","uri":"spotify:artist:7z1zaOeWiHpl4SD2N9ZBgk"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Zh3Vzx1q4Vk8SgFg5HXGP"},"href":"https://api.spotify.com/v1/albums/5Zh3Vzx1q4Vk8SgFg5HXGP","id":"5Zh3Vzx1q4Vk8SgFg5HXGP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733cbf10696b1fcc228d0aea83"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023cbf10696b1fcc228d0aea83"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513cbf10696b1fcc228d0aea83"}],"is_playable":true,"name":"Natural High","release_date":"1972-09-14","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:5Zh3Vzx1q4Vk8SgFg5HXGP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7z1zaOeWiHpl4SD2N9ZBgk"},"href":"https://api.spotify.com/v1/artists/7z1zaOeWiHpl4SD2N9ZBgk","id":"7z1zaOeWiHpl4SD2N9ZBgk","name":"Bloodstone","type":"artist","uri":"spotify:artist:7z1zaOeWiHpl4SD2N9ZBgk"}],"disc_number":1,"duration_ms":240509,"explicit":false,"external_ids":{"isrc":"GXF972570265"},"external_urls":{"spotify":"https://open.spotify.com/track/2mmcaJP0Ch1sV99WFiZhgV"},"href":"https://api.spotify.com/v1/tracks/2mmcaJP0Ch1sV99WFiZhgV","id":"2mmcaJP0Ch1sV99WFiZhgV","is_local":false,"is_playable":true,"name":"Natural High","track_number":6,"type":"track","uri":"spotify:track:2mmcaJP0Ch1sV99WFiZhgV"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1DXSrgY5dpBSTWPC0uhXcj"},"href":"https://api.spotify.com/v1/artists/1DXSrgY5dpBSTWPC0uhXcj","id":"1DXSrgY5dpBSTWPC0uhXcj","name":"Bloodstone","type":"artist","uri":"spotify:artist:1DXSrgY5dpBSTWPC0uhXcj"}],"external_urls":{"spotify":"https://open.spotify.com/album/40itH1o9OXNvjVjendp50L"},"href":"https://api.spotify.com/v1/albums/40itH1o9OXNvjVjendp50L","id":"40itH1o9OXNvjVjendp50L","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a291ef6113c6875c5227a332"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a291ef6113c6875c5227a332"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a291ef6113c6875c5227a332"}],"is_playable":true,"name":"The Essentials: Bloodstone","release_date":"2007-03-24","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:40itH1o9OXNvjVjendp50L"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1DXSrgY5dpBSTWPC0uhXcj"},"href":"https://api.spotify.com/v1/artists/1DXSrgY5dpBSTWPC0uhXcj","id":"1DXSrgY5dpBSTWPC0uhXcj","name":"Bloodstone","type":"artist","uri":"spotify:artist:1DXSrgY5dpBSTWPC0uhXcj"}],"disc_number":1,"duration_ms":249093,"explicit":false,"external_ids":{"isrc":"USRH10200195"},"external_urls":{"spotify":"https://open.spotify.com/track/73etijhz7pV4Wx7GTANLpq"},"href":"https://api.spotify.com/v1/tracks/73etijhz7pV4Wx7GTANLpq","id":"73etijhz7pV4Wx7GTANLpq","is_local":false,"is_playable":true,"name":"Natural High - Single Version","track_number":1,"type":"track","uri":"spotify:track:73etijhz7pV4Wx7GTANLpq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/01Z8f71ZDPUUzPRDKD9cOY"},"href":"https://api.spotify.com/v1/albums/01Z8f71ZDPUUzPRDKD9cOY","id":"01Z8f71ZDPUUzPRDKD9cOY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734279da93a5f5d2c7e9bbd200"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024279da93a5f5d2c7e9bbd200"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514279da93a5f5d2c7e9bbd200"}],"is_playable":true,"name":"Jaren 70 Ballads","release_date":"2020-07-10","release_date_precision":"day","total_tracks":45,"type":"album","uri":"spotify:album:01Z8f71ZDPUUzPRDKD9cOY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7z1zaOeWiHpl4SD2N9ZBgk"},"href":"https://api.spotify.com/v1/artists/7z1zaOeWiHpl4SD2N9ZBgk","id":"7z1zaOeWiHpl4SD2N9ZBgk","name":"Bloodstone","type":"artist","uri":"spotify:artist:7z1zaOeWiHpl4SD2N9ZBgk"}],"disc_number":1,"duration_ms":249093,"explicit":false,"external_ids":{"isrc":"USRH10200195"},"external_urls":{"spotify":"https://open.spotify.com/track/3V8HHplQLnPDVndHWZLlur"},"href":"https://api.spotify.com/v1/tracks/3V8HHplQLnPDVndHWZLlur","id":"3V8HHplQLnPDVndHWZLlur","is_local":false,"is_playable":true,"name":"Natural High","track_number":41,"type":"track","uri":"spotify:track:3V8HHplQLnPDVndHWZLlur"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0HWTUmrCqXj6ZBiYc0yn0e"},"href":"https://api.spotify.com/v1/albums/0HWTUmrCqXj6ZBiYc0yn0e","id":"0HWTUmrCqXj6ZBiYc0yn0e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736e8ccfadebf53db64689e048"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026e8ccfadebf53db64689e048"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516e8ccfadebf53db64689e048"}],"is_playable":true,"name":"Maak me wakker met muziek uit de jaren 70","release_date":"2025-08-12","release_date_precision":"day","total_tracks":80,"type":"album","uri":"spotify:album:0HWTUmrCqXj6ZBiYc0yn0e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZXVNYcVbAKLLjjJIQy9aG"},"href":"https://api.spotify.com/v1/artists/3ZXVNYcVbAKLLjjJIQy9aG","id":"3ZXVNYcVbAKLLjjJIQy9aG","name":"Bloodstone","type":"artist","uri":"spotify:artist:3ZXVNYcVbAKLLjjJIQy9aG"}],"disc_number":1,"duration_ms":249093,"explicit":false,"external_ids":{"isrc":"USRH10200195"},"external_urls":{"spotify":"https://open.spotify.com/track/26RBhqrU35Yas187Voxu8R"},"href":"https://api.spotify.com/v1/tracks/26RBhqrU35Yas187Voxu8R","id":"26RBhqrU35Yas187Voxu8R","is_local":false,"is_playable":true,"name":"Natural High","track_number":57,"type":"track","uri":"spotify:track:26RBhqrU35Yas187Voxu8R"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1FvrPygTsMy4AXc1DGsP2y"},"href":"https://api.spotify.com/v1/albums/1FvrPygTsMy4AXc1DGsP2y","id":"1FvrPygTsMy4AXc1DGsP2y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733f831dd344e488a485fa2a86"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023f831dd344e488a485fa2a86"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513f831dd344e488a485fa2a86"}],"is_playable":true,"name":"Low Rider Oldies","release_date":"2017-09-13","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:1FvrPygTsMy4AXc1DGsP2y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WCp2TFJRkB9lzIONOiw71"},"href":"https://api.spotify.com/v1/artists/4WCp2TFJRkB9lzIONOiw71","id":"4WCp2TFJRkB9lzIONOiw71","name":"Bloodstone","type":"artist","uri":"spotify:artist:4WCp2TFJRkB9lzIONOiw71"}],"disc_number":1,"duration_ms":249093,"explicit":false,"external_ids":{"isrc":"USRH10200195"},"external_urls":{"spotify":"https://open.spotify.com/track/5P7nCauQMFFzQq9YdQPhfS"},"href":"https://api.spotify.com/v1/tracks/5P7nCauQMFFzQq9YdQPhfS","id":"5P7nCauQMFFzQq9YdQPhfS","is_local":false,"is_playable":true,"name":"Natural High","track_number":1,"type":"track","uri":"spotify:track:5P7nCauQMFFzQq9YdQPhfS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1Ertiz8rpL11KJrmlnBPo7"},"href":"https://api.spotify.com/v1/albums/1Ertiz8rpL11KJrmlnBPo7","id":"1Ertiz8rpL11KJrmlnBPo7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f0b03b86ca23fa5eac2310ed"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f0b03b86ca23fa5eac2310ed"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f0b03b86ca23fa5eac2310ed"}],"is_playable":true,"name":"Soft Soul","release_date":"2017-07-06","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:1Ertiz8rpL11KJrmlnBPo7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7z1zaOeWiHpl4SD2N9ZBgk"},"href":"https://api.spotify.com/v1/artists/7z1zaOeWiHpl4SD2N9ZBgk","id":"7z1zaOeWiHpl4SD2N9ZBgk","name":"Bloodstone","type":"artist","uri":"spotify:artist:7z1zaOeWiHpl4SD2N9ZBgk"}],"disc_number":1,"duration_ms":249093,"explicit":false,"external_ids":{"isrc":"USRH10200195"},"external_urls":{"spotify":"https://open.spotify.com/track/0F128xUUv2wqHNXC47vUQa"},"href":"https://api.spotify.com/v1/tracks/0F128xUUv2wqHNXC47vUQa","id":"0F128xUUv2wqHNXC47vUQa","is_local":false,"is_playable":true,"name":"Natural High","track_number":24,"type":"track","uri":"spotify:track:0F128xUUv2wqHNXC47vUQa"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6SRDfAmG8XTwYEZNSwaKTY"},"href":"https://api.spotify.com/v1/albums/6SRDfAmG8XTwYEZNSwaKTY","id":"6SRDfAmG8XTwYEZNSwaKTY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273335eeb48328f2869c9799c65"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02335eeb48328f2869c9799c65"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851335eeb48328f2869c9799c65"}],"is_playable":true,"name":"Seventies Hits","release_date":"2025-02-08","release_date_precision":"day","total_tracks":80,"type":"album","uri":"spotify:album:6SRDfAmG8XTwYEZNSwaKTY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZXVNYcVbAKLLjjJIQy9aG"},"href":"https://api.spotify.com/v1/artists/3ZXVNYcVbAKLLjjJIQy9aG","id":"3ZXVNYcVbAKLLjjJIQy9aG","name":"Bloodstone","type":"artist","uri":"spotify:artist:3ZXVNYcVbAKLLjjJIQy9aG"}],"disc_number":1,"duration_ms":249093,"explicit":false,"external_ids":{"isrc":"USRH10200195"},"external_urls":{"spotify":"https://open.spotify.com/track/6NzP2C5u6TjE8F42GnzM3v"},"href":"https://api.spotify.com/v1/tracks/6NzP2C5u6TjE8F42GnzM3v","id":"6NzP2C5u6TjE8F42GnzM3v","is_local":false,"is_playable":true,"name":"Natural High","track_number":70,"type":"track","uri":"spotify:track:6NzP2C5u6TjE8F42GnzM3v"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5EFO2gxq7vdAZxg2WNi4yj"},"href":"https://api.spotify.com/v1/albums/5EFO2gxq7vdAZxg2WNi4yj","id":"5EFO2gxq7vdAZxg2WNi4yj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27396be6a8cfa6b90dbdc84f8d5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0296be6a8cfa6b90dbdc84f8d5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485196be6a8cfa6b90dbdc84f8d5"}],"is_playable":true,"name":"Seventies Ballads","release_date":"2023-12-09","release_date_precision":"day","total_tracks":55,"type":"album","uri":"spotify:album:5EFO2gxq7vdAZxg2WNi4yj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZXVNYcVbAKLLjjJIQy9aG"},"href":"https://api.spotify.com/v1/artists/3ZXVNYcVbAKLLjjJIQy9aG","id":"3ZXVNYcVbAKLLjjJIQy9aG","name":"Bloodstone","type":"artist","uri":"spotify:artist:3ZXVNYcVbAKLLjjJIQy9aG"}],"disc_number":1,"duration_ms":249093,"explicit":false,"external_ids":{"isrc":"USRH10200195"},"external_urls":{"spotify":"https://open.spotify.com/track/6t3Q8hkZAeU1KemrFCpsMl"},"href":"https://api.spotify.com/v1/tracks/6t3Q8hkZAeU1KemrFCpsMl","id":"6t3Q8hkZAeU1KemrFCpsMl","is_local":false,"is_playable":true,"name":"Natural High","track_number":32,"type":"track","uri":"spotify:track:6t3Q8hkZAeU1KemrFCpsMl"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0qLO4SCYALuGaA2OisKoqE"},"href":"https://api.spotify.com/v1/albums/0qLO4SCYALuGaA2OisKoqE","id":"0qLO4SCYALuGaA2OisKoqE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b28f729757062e10884e31d0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b28f729757062e10884e31d0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b28f729757062e10884e31d0"}],"is_playable":true,"name":"70s Hits - 100 Top Songs","release_date":"2024-09-24","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0qLO4SCYALuGaA2OisKoqE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3ZXVNYcVbAKLLjjJIQy9aG"},"href":"https://api.spotify.com/v1/artists/3ZXVNYcVbAKLLjjJIQy9aG","id":"3ZXVNYcVbAKLLjjJIQy9aG","name":"Bloodstone","type":"artist","uri":"spotify:artist:3ZXVNYcVbAKLLjjJIQy9aG"}],"disc_number":1,"duration_ms":249093,"explicit":false,"external_ids":{"isrc":"USRH10200195"},"external_urls":{"spotify":"https://open.spotify.com/track/1rRvdR1jcAaQY6gllnXLTy"},"href":"https://api.spotify.com/v1/tracks/1rRvdR1jcAaQY6gllnXLTy","id":"1rRvdR1jcAaQY6gllnXLTy","is_local":false,"is_playable":true,"name":"Natural High","track_number":32,"type":"track","uri":"spotify:track:1rRvdR1jcAaQY6gllnXLTy"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk5hdHVyYWwlMjBIaWdoJTIyJTIwYXJ0aXN0JTNBJTIyQmxvb2RzdG9uZSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3oxemFPZVdpSHBsNFNEMk45WkJnayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83ejF6YU9lV2lIcGw0U0QyTjlaQmdrIiwiaWQiOiI3ejF6YU9lV2lIcGw0U0QyTjlaQmdrIiwibmFtZSI6IkJsb29kc3RvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3oxemFPZVdpSHBsNFNEMk45WkJnayJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRramYxQzhYcHFyMmU3cFREd2JsRzIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80a2pmMUM4WHBxcjJlN3BURHdibEcyIiwiaWQiOiI0a2pmMUM4WHBxcjJlN3BURHdibEcyIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzgwOWU4Yjk0MzFlMWNiNjJjNjZlMjcwYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4MDllOGI5NDMxZTFjYjYyYzY2ZTI3MGEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTgwOWU4Yjk0MzFlMWNiNjJjNjZlMjcwYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOYXR1cmFsIEhpZ2giLCJyZWxlYXNlX2RhdGUiOiIxOTcyLTA5LTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NGtqZjFDOFhwcXIyZTdwVER3YmxHMiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd6MXphT2VXaUhwbDRTRDJOOVpCZ2sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3oxemFPZVdpSHBsNFNEMk45WkJnayIsImlkIjoiN3oxemFPZVdpSHBsNFNEMg==", + "TjlaQmdrIiwibmFtZSI6IkJsb29kc3RvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3oxemFPZVdpSHBsNFNEMk45WkJnayJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDA0NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTA0NTAwMzkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdhS3J5c3V5WnZEblUzSndubE8zZGQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83YUtyeXN1eVp2RG5VM0p3bmxPM2RkIiwiaWQiOiI3YUtyeXN1eVp2RG5VM0p3bmxPM2RkIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5hdHVyYWwgSGlnaCIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3YUtyeXN1eVp2RG5VM0p3bmxPM2RkIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd6MXphT2VXaUhwbDRTRDJOOVpCZ2sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3oxemFPZVdpSHBsNFNEMk45WkJnayIsImlkIjoiN3oxemFPZVdpSHBsNFNEMk45WkJnayIsIm5hbWUiOiJCbG9vZHN0b25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd6MXphT2VXaUhwbDRTRDJOOVpCZ2sifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81WmgzVnp4MXE0Vms4U2dGZzVIWEdQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNVpoM1Z6eDFxNFZrOFNnRmc1SFhHUCIsImlkIjoiNVpoM1Z6eDFxNFZrOFNnRmc1SFhHUCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzY2JmMTA2OTZiMWZjYzIyOGQwYWVhODMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyM2NiZjEwNjk2YjFmY2MyMjhkMGFlYTgzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzY2JmMTA2OTZiMWZjYzIyOGQwYWVhODMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmF0dXJhbCBIaWdoIiwicmVsZWFzZV9kYXRlIjoiMTk3Mi0wOS0xNCIsInJlbGVhc2VfZA==", + "YXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVpoM1Z6eDFxNFZrOFNnRmc1SFhHUCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd6MXphT2VXaUhwbDRTRDJOOVpCZ2sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3oxemFPZVdpSHBsNFNEMk45WkJnayIsImlkIjoiN3oxemFPZVdpSHBsNFNEMk45WkJnayIsIm5hbWUiOiJCbG9vZHN0b25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd6MXphT2VXaUhwbDRTRDJOOVpCZ2sifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQwNTA5LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR1hGOTcyNTcwMjY1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8ybW1jYUpQMENoMXNWOTlXRmlaaGdWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMm1tY2FKUDBDaDFzVjk5V0ZpWmhnViIsImlkIjoiMm1tY2FKUDBDaDFzVjk5V0ZpWmhnViIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOYXR1cmFsIEhpZ2giLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mm1tY2FKUDBDaDFzVjk5V0ZpWmhnViJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xRFhTcmdZNWRwQlNUV1BDMHVoWGNqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFEWFNyZ1k1ZHBCU1RXUEMwdWhYY2oiLCJpZCI6IjFEWFNyZ1k1ZHBCU1RXUEMwdWhYY2oiLCJuYW1lIjoiQmxvb2RzdG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxRFhTcmdZNWRwQlNUV1BDMHVoWGNqIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNDBpdEgxbzlPWE52alZqZW5kcDUwTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzQwaXRIMW85T1hOdmpWamVuZHA1MEwiLCJpZCI6IjQwaXRIMW85T1hOdmpWamVuZHA1MEwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTI5MWVmNjExM2M2OA==", + "NzVjNTIyN2EzMzIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTI5MWVmNjExM2M2ODc1YzUyMjdhMzMyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhMjkxZWY2MTEzYzY4NzVjNTIyN2EzMzIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEVzc2VudGlhbHM6IEJsb29kc3RvbmUiLCJyZWxlYXNlX2RhdGUiOiIyMDA3LTAzLTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NDBpdEgxbzlPWE52alZqZW5kcDUwTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFEWFNyZ1k1ZHBCU1RXUEMwdWhYY2oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMURYU3JnWTVkcEJTVFdQQzB1aFhjaiIsImlkIjoiMURYU3JnWTVkcEJTVFdQQzB1aFhjaiIsIm5hbWUiOiJCbG9vZHN0b25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFEWFNyZ1k1ZHBCU1RXUEMwdWhYY2oifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ5MDkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDEwMjAwMTk1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83M2V0aWpoejdwVjRXeDdHVEFOTHBxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNzNldGlqaHo3cFY0V3g3R1RBTkxwcSIsImlkIjoiNzNldGlqaHo3cFY0V3g3R1RBTkxwcSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOYXR1cmFsIEhpZ2ggLSBTaW5nbGUgVmVyc2lvbiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3M2V0aWpoejdwVjRXeDdHVEFOTHBxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aQ==", + "c3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMDFaOGY3MVpEUFVVelBSREtEOWNPWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzAxWjhmNzFaRFBVVXpQUkRLRDljT1kiLCJpZCI6IjAxWjhmNzFaRFBVVXpQUkRLRDljT1kiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDI3OWRhOTNhNWY1ZDJjN2U5YmJkMjAwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQyNzlkYTkzYTVmNWQyYzdlOWJiZDIwMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDI3OWRhOTNhNWY1ZDJjN2U5YmJkMjAwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkphcmVuIDcwIEJhbGxhZHMiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTA3LTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MDFaOGY3MVpEUFVVelBSREtEOWNPWSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd6MXphT2VXaUhwbDRTRDJOOVpCZ2sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3oxemFPZVdpSHBsNFNEMk45WkJnayIsImlkIjoiN3oxemFPZVdpSHBsNFNEMk45WkJnayIsIm5hbWUiOiJCbG9vZHN0b25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd6MXphT2VXaUhwbDRTRDJOOVpCZ2sifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ5MDkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDEwMjAwMTk1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zVjhISHBsUUxuUERWbmRIV1pMbHVyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM1Y4SEhwbFFMblBEVm5kSFdaTGx1ciIsImlkIjoiM1Y4SEhwbFFMblBEVm5kSFdaTGx1ciIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOYXR1cmFsIEhpZ2giLCJ0cmFja19udW1iZXIiOjQxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aQ==", + "Znk6dHJhY2s6M1Y4SEhwbFFMblBEVm5kSFdaTGx1ciJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wSFdUVW1yQ3FYajZaQmlZYzB5bjBlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMEhXVFVtckNxWGo2WkJpWWMweW4wZSIsImlkIjoiMEhXVFVtckNxWGo2WkJpWWMweW4wZSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2ZThjY2ZhZGViZjUzZGI2NDY4OWUwNDgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNmU4Y2NmYWRlYmY1M2RiNjQ2ODllMDQ4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2ZThjY2ZhZGViZjUzZGI2NDY4OWUwNDgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWFhayBtZSB3YWtrZXIgbWV0IG11emllayB1aXQgZGUgamFyZW4gNzAiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA4LTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6ODAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MEhXVFVtckNxWGo2WkJpWWMweW4wZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNaWFZOWWNWYkFLTExqakpJUXk5YUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM1pYVk5ZY1ZiQUtMTGpqSklReTlhRyIsImlkIjoiM1pYVk5ZY1ZiQUtMTGpqSklReTlhRyIsIm5hbWUiOiJCbG9vZHN0b25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNaWFZOWWNWYkFLTExqakpJUXk5YUcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ5MDkzLCJleHBsaWNpdCI6Zg==", + "YWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTAyMDAxOTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzI2UkJocXJVMzVZYXMxODdWb3h1OFIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yNlJCaHFyVTM1WWFzMTg3Vm94dThSIiwiaWQiOiIyNlJCaHFyVTM1WWFzMTg3Vm94dThSIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5hdHVyYWwgSGlnaCIsInRyYWNrX251bWJlciI6NTcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MjZSQmhxclUzNVlhczE4N1ZveHU4UiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xRnZyUHlnVHNNeTRBWGMxREdzUDJ5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUZ2clB5Z1RzTXk0QVhjMURHc1AyeSIsImlkIjoiMUZ2clB5Z1RzTXk0QVhjMURHc1AyeSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzZjgzMWRkMzQ0ZTQ4OGE0ODVmYTJhODYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyM2Y4MzFkZDM0NGU0ODhhNDg1ZmEyYTg2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzZjgzMWRkMzQ0ZTQ4OGE0ODVmYTJhODYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTG93IFJpZGVyIE9sZGllcyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDktMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxRnZyUHlnVHNNeTRBWGMxREdzUDJ5In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybA==", + "cyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80V0NwMlRGSlJrQjlseklPTk9pdzcxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRXQ3AyVEZKUmtCOWx6SU9OT2l3NzEiLCJpZCI6IjRXQ3AyVEZKUmtCOWx6SU9OT2l3NzEiLCJuYW1lIjoiQmxvb2RzdG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0V0NwMlRGSlJrQjlseklPTk9pdzcxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0OTA5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMDIwMDE5NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVA3bkNhdVFNRkZ6UXE5WWRRUGhmUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVQN25DYXVRTUZGelFxOVlkUVBoZlMiLCJpZCI6IjVQN25DYXVRTUZGelFxOVlkUVBoZlMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmF0dXJhbCBIaWdoIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVQN25DYXVRTUZGelFxOVlkUVBoZlMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMUVydGl6OHJwTDExS0pybWxuQlBvNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFFcnRpejhycEwxMUtKcm1sbkJQbzciLCJpZCI6IjFFcnRpejhycEwxMUtKcm1sbkJQbzciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjBiMDNiODZjYTIzZmE1ZWFjMjMxMGVkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmYwYjAzYjg2Y2EyM2ZhNWVhYzIzMTBlZCJ9LHsiaGVpZw==", + "aHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmMGIwM2I4NmNhMjNmYTVlYWMyMzEwZWQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU29mdCBTb3VsIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wNy0wNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFFcnRpejhycEwxMUtKcm1sbkJQbzcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83ejF6YU9lV2lIcGw0U0QyTjlaQmdrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd6MXphT2VXaUhwbDRTRDJOOVpCZ2siLCJpZCI6Ijd6MXphT2VXaUhwbDRTRDJOOVpCZ2siLCJuYW1lIjoiQmxvb2RzdG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3ejF6YU9lV2lIcGw0U0QyTjlaQmdrIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0OTA5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMDIwMDE5NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMEYxMjh4VVV2MndxSE5YQzQ3dlVRYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBGMTI4eFVVdjJ3cUhOWEM0N3ZVUWEiLCJpZCI6IjBGMTI4eFVVdjJ3cUhOWEM0N3ZVUWEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmF0dXJhbCBIaWdoIiwidHJhY2tfbnVtYmVyIjoyNCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowRjEyOHhVVXYyd3FITlhDNDd2VVFhIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZTUkRmQW1HOFhUd1lFWk5Td2FLVFkifSwiaHJlZiI6Imh0dHBzOi8vYQ==", + "cGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZTUkRmQW1HOFhUd1lFWk5Td2FLVFkiLCJpZCI6IjZTUkRmQW1HOFhUd1lFWk5Td2FLVFkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzM1ZWViNDgzMjhmMjg2OWM5Nzk5YzY1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjMzNWVlYjQ4MzI4ZjI4NjljOTc5OWM2NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzM1ZWViNDgzMjhmMjg2OWM5Nzk5YzY1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNldmVudGllcyBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMi0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjgwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZTUkRmQW1HOFhUd1lFWk5Td2FLVFkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zWlhWTlljVmJBS0xMampKSVF5OWFHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNaWFZOWWNWYkFLTExqakpJUXk5YUciLCJpZCI6IjNaWFZOWWNWYkFLTExqakpJUXk5YUciLCJuYW1lIjoiQmxvb2RzdG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozWlhWTlljVmJBS0xMampKSVF5OWFHIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0OTA5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMDIwMDE5NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNk56UDJDNXU2VGpFOEY0Mkduek0zdiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZOelAyQzV1NlRqRThGNDJHbnpNM3YiLCJpZCI6IjZOelAyQzV1NlRqRThGNDJHbnpNM3YiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmF0dXJhbCBIaWdoIiwidHJhY2tfbnVtYmVyIjo3MCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2TnpQMkM1dTZUakU4RjQyR256TTN2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYQ==", + "ZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUVGTzJneHE3dmRBWnhnMldOaTR5aiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVFRk8yZ3hxN3ZkQVp4ZzJXTmk0eWoiLCJpZCI6IjVFRk8yZ3hxN3ZkQVp4ZzJXTmk0eWoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTZiZTZhOGNmYTZiOTBkYmRjODRmOGQ1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjk2YmU2YThjZmE2YjkwZGJkYzg0ZjhkNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOTZiZTZhOGNmYTZiOTBkYmRjODRmOGQ1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNldmVudGllcyBCYWxsYWRzIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0xMi0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjU1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVFRk8yZ3hxN3ZkQVp4ZzJXTmk0eWoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zWlhWTlljVmJBS0xMampKSVF5OWFHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNaWFZOWWNWYkFLTExqakpJUXk5YUciLCJpZCI6IjNaWFZOWWNWYkFLTExqakpJUXk5YUciLCJuYW1lIjoiQmxvb2RzdG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozWlhWTlljVmJBS0xMampKSVF5OWFHIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0OTA5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMDIwMDE5NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnQzUThoa1pBZVUxS2VtckZDcHNNbCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ0M1E4aGtaQQ==", + "ZVUxS2VtckZDcHNNbCIsImlkIjoiNnQzUThoa1pBZVUxS2VtckZDcHNNbCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOYXR1cmFsIEhpZ2giLCJ0cmFja19udW1iZXIiOjMyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZ0M1E4aGtaQWVVMUtlbXJGQ3BzTWwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMHFMTzRTQ1lBTHVHYUEyT2lzS29xRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBxTE80U0NZQUx1R2FBMk9pc0tvcUUiLCJpZCI6IjBxTE80U0NZQUx1R2FBMk9pc0tvcUUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjI4ZjcyOTc1NzA2MmUxMDg4NGUzMWQwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmIyOGY3Mjk3NTcwNjJlMTA4ODRlMzFkMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjI4ZjcyOTc1NzA2MmUxMDg4NGUzMWQwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjcwcyBIaXRzIC0gMTAwIFRvcCBTb25ncyIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDktMjQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MHFMTzRTQ1lBTHVHYUEyT2lzS29xRSJ9LCJhcnRpc3RzIjpbeyJl", + "eHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNaWFZOWWNWYkFLTExqakpJUXk5YUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM1pYVk5ZY1ZiQUtMTGpqSklReTlhRyIsImlkIjoiM1pYVk5ZY1ZiQUtMTGpqSklReTlhRyIsIm5hbWUiOiJCbG9vZHN0b25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNaWFZOWWNWYkFLTExqakpJUXk5YUcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ5MDkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDEwMjAwMTk1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xclJ2ZFIxamNBYVFZNmdsbG5YTFR5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMXJSdmRSMWpjQWFRWTZnbGxuWExUeSIsImlkIjoiMXJSdmRSMWpjQWFRWTZnbGxuWExUeSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOYXR1cmFsIEhpZ2giLCJ0cmFja19udW1iZXIiOjMyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFyUnZkUjFqY0FhUVk2Z2xsblhMVHkifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Natural+High%22+artist%3A%22Bloodstone%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Son%20of%20a%20Preacher%20Man%22%20artist%3A%22Dusty%20Springfield%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"external_urls":{"spotify":"https://open.spotify.com/album/5FRB5oQaHxlDNe6gMGuzu2"},"href":"https://api.spotify.com/v1/albums/5FRB5oQaHxlDNe6gMGuzu2","id":"5FRB5oQaHxlDNe6gMGuzu2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e20037311210924b3c386f00"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e20037311210924b3c386f00"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e20037311210924b3c386f00"}],"is_playable":true,"name":"Dusty In Memphis","release_date":"1969-03-31","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:5FRB5oQaHxlDNe6gMGuzu2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"disc_number":1,"duration_ms":148053,"explicit":false,"external_ids":{"isrc":"GBF080201245"},"external_urls":{"spotify":"https://open.spotify.com/track/6ek9SiEj5a65WIs2EV7qiM"},"href":"https://api.spotify.com/v1/tracks/6ek9SiEj5a65WIs2EV7qiM","id":"6ek9SiEj5a65WIs2EV7qiM","is_local":false,"is_playable":true,"name":"Son Of A Preacher Man","track_number":12,"type":"track","uri":"spotify:track:6ek9SiEj5a65WIs2EV7qiM"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"external_urls":{"spotify":"https://open.spotify.com/album/6t4BECovfkgGTrtbqmTlZf"},"href":"https://api.spotify.com/v1/albums/6t4BECovfkgGTrtbqmTlZf","id":"6t4BECovfkgGTrtbqmTlZf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735827c499129d9d9b4eaa536a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025827c499129d9d9b4eaa536a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515827c499129d9d9b4eaa536a"}],"is_playable":true,"name":"The Silver Collection","release_date":"1988-01-01","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:6t4BECovfkgGTrtbqmTlZf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"disc_number":1,"duration_ms":146626,"explicit":false,"external_ids":{"isrc":"GBF086800754"},"external_urls":{"spotify":"https://open.spotify.com/track/0scrtPmtlIVwwk9s4LXJ8n"},"href":"https://api.spotify.com/v1/tracks/0scrtPmtlIVwwk9s4LXJ8n","id":"0scrtPmtlIVwwk9s4LXJ8n","is_local":false,"is_playable":true,"name":"Son Of A Preacher Man","track_number":10,"type":"track","uri":"spotify:track:0scrtPmtlIVwwk9s4LXJ8n"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"external_urls":{"spotify":"https://open.spotify.com/album/3BXGTueWqjo8aHecLaWZp2"},"href":"https://api.spotify.com/v1/albums/3BXGTueWqjo8aHecLaWZp2","id":"3BXGTueWqjo8aHecLaWZp2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27337237b9c11073905f8c5c3ba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0237237b9c11073905f8c5c3ba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485137237b9c11073905f8c5c3ba"}],"is_playable":true,"name":"Dusty In Memphis","release_date":"1969-03-31","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:3BXGTueWqjo8aHecLaWZp2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"disc_number":1,"duration_ms":144333,"explicit":false,"external_ids":{"isrc":"GBF086800754"},"external_urls":{"spotify":"https://open.spotify.com/track/5TbLONSGZsR8cbhNEodCH6"},"href":"https://api.spotify.com/v1/tracks/5TbLONSGZsR8cbhNEodCH6","id":"5TbLONSGZsR8cbhNEodCH6","is_local":false,"is_playable":true,"name":"Son Of A Preacher Man","track_number":3,"type":"track","uri":"spotify:track:5TbLONSGZsR8cbhNEodCH6"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"external_urls":{"spotify":"https://open.spotify.com/album/5FRB5oQaHxlDNe6gMGuzu2"},"href":"https://api.spotify.com/v1/albums/5FRB5oQaHxlDNe6gMGuzu2","id":"5FRB5oQaHxlDNe6gMGuzu2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e20037311210924b3c386f00"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e20037311210924b3c386f00"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e20037311210924b3c386f00"}],"is_playable":true,"name":"Dusty In Memphis","release_date":"1969-03-31","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:5FRB5oQaHxlDNe6gMGuzu2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"disc_number":1,"duration_ms":145093,"explicit":false,"external_ids":{"isrc":"GBF086800754"},"external_urls":{"spotify":"https://open.spotify.com/track/28jBolSSfkXDYYOZWTcHDE"},"href":"https://api.spotify.com/v1/tracks/28jBolSSfkXDYYOZWTcHDE","id":"28jBolSSfkXDYYOZWTcHDE","is_local":false,"is_playable":true,"name":"Son Of A Preacher Man","track_number":3,"type":"track","uri":"spotify:track:28jBolSSfkXDYYOZWTcHDE"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4mb8ZVI5MmAApY7909j5YK"},"href":"https://api.spotify.com/v1/albums/4mb8ZVI5MmAApY7909j5YK","id":"4mb8ZVI5MmAApY7909j5YK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273080bd84d8a74c8e1eaaead6a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02080bd84d8a74c8e1eaaead6a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851080bd84d8a74c8e1eaaead6a"}],"is_playable":true,"name":"De Zwarte Lijst","release_date":"2012-01-01","release_date_precision":"day","total_tracks":54,"type":"album","uri":"spotify:album:4mb8ZVI5MmAApY7909j5YK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"disc_number":1,"duration_ms":144293,"explicit":false,"external_ids":{"isrc":"GBF086800754"},"external_urls":{"spotify":"https://open.spotify.com/track/1ETHk8ErqDOrnYBHVlob53"},"href":"https://api.spotify.com/v1/tracks/1ETHk8ErqDOrnYBHVlob53","id":"1ETHk8ErqDOrnYBHVlob53","is_local":false,"is_playable":true,"name":"Son Of A Preacher Man","track_number":2,"type":"track","uri":"spotify:track:1ETHk8ErqDOrnYBHVlob53"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3skIYvBBPqebmVwvc5comu"},"href":"https://api.spotify.com/v1/albums/3skIYvBBPqebmVwvc5comu","id":"3skIYvBBPqebmVwvc5comu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730dd6041db01724380752e525"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020dd6041db01724380752e525"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510dd6041db01724380752e525"}],"is_playable":true,"name":"Golden Oldies","release_date":"2021-04-09","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:3skIYvBBPqebmVwvc5comu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"disc_number":1,"duration_ms":148053,"explicit":false,"external_ids":{"isrc":"GBF080201245"},"external_urls":{"spotify":"https://open.spotify.com/track/5JapSu79SFbjBQJTM5dYCw"},"href":"https://api.spotify.com/v1/tracks/5JapSu79SFbjBQJTM5dYCw","id":"5JapSu79SFbjBQJTM5dYCw","is_local":false,"is_playable":true,"name":"Son Of A Preacher Man","track_number":6,"type":"track","uri":"spotify:track:5JapSu79SFbjBQJTM5dYCw"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"external_urls":{"spotify":"https://open.spotify.com/album/7JYg1zawhhgCxwGkB7DkgK"},"href":"https://api.spotify.com/v1/albums/7JYg1zawhhgCxwGkB7DkgK","id":"7JYg1zawhhgCxwGkB7DkgK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737845e65afa406b09f25e35fa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027845e65afa406b09f25e35fa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517845e65afa406b09f25e35fa"}],"is_playable":true,"name":"The Magic of Dusty Springfield","release_date":"2011-01-01","release_date_precision":"day","total_tracks":92,"type":"album","uri":"spotify:album:7JYg1zawhhgCxwGkB7DkgK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"disc_number":1,"duration_ms":146133,"explicit":false,"external_ids":{"isrc":"GBF086800754"},"external_urls":{"spotify":"https://open.spotify.com/track/3iDaK0Vsw1jRfuGjGBVU25"},"href":"https://api.spotify.com/v1/tracks/3iDaK0Vsw1jRfuGjGBVU25","id":"3iDaK0Vsw1jRfuGjGBVU25","is_local":false,"is_playable":true,"name":"Son Of A Preacher Man","track_number":19,"type":"track","uri":"spotify:track:3iDaK0Vsw1jRfuGjGBVU25"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"external_urls":{"spotify":"https://open.spotify.com/album/1nqFVeqOlIVan8xkKX0O6j"},"href":"https://api.spotify.com/v1/albums/1nqFVeqOlIVan8xkKX0O6j","id":"1nqFVeqOlIVan8xkKX0O6j","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731f64431de67310e745c5e327"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021f64431de67310e745c5e327"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511f64431de67310e745c5e327"}],"is_playable":true,"name":"Complete A And B Sides 1963 - 1970","release_date":"2006-01-01","release_date_precision":"day","total_tracks":41,"type":"album","uri":"spotify:album:1nqFVeqOlIVan8xkKX0O6j"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"disc_number":1,"duration_ms":146226,"explicit":false,"external_ids":{"isrc":"GBF080201245"},"external_urls":{"spotify":"https://open.spotify.com/track/6zJGnMyuSo1qBmujaVWVBj"},"href":"https://api.spotify.com/v1/tracks/6zJGnMyuSo1qBmujaVWVBj","id":"6zJGnMyuSo1qBmujaVWVBj","is_local":false,"is_playable":true,"name":"Son Of A Preacher Man","track_number":17,"type":"track","uri":"spotify:track:6zJGnMyuSo1qBmujaVWVBj"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3FxKnSu0AwZCVimULvmlUj"},"href":"https://api.spotify.com/v1/albums/3FxKnSu0AwZCVimULvmlUj","id":"3FxKnSu0AwZCVimULvmlUj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273582976602d46cb16b9c3002d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02582976602d46cb16b9c3002d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851582976602d46cb16b9c3002d"}],"is_playable":true,"name":"Movie Ballads","release_date":"2002-01-01","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:3FxKnSu0AwZCVimULvmlUj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5zaXYwewAXedKNCff45U5l"},"href":"https://api.spotify.com/v1/artists/5zaXYwewAXedKNCff45U5l","id":"5zaXYwewAXedKNCff45U5l","name":"Dusty Springfield","type":"artist","uri":"spotify:artist:5zaXYwewAXedKNCff45U5l"}],"disc_number":1,"duration_ms":146866,"explicit":false,"external_ids":{"isrc":"GBF086800754"},"external_urls":{"spotify":"https://open.spotify.com/track/4gYl9m2oErJgwY2cu2TsuB"},"href":"https://api.spotify.com/v1/tracks/4gYl9m2oErJgwY2cu2TsuB","id":"4gYl9m2oErJgwY2cu2TsuB","is_local":false,"is_playable":true,"name":"Son Of A Preacher Man","track_number":11,"type":"track","uri":"spotify:track:4gYl9m2oErJgwY2cu2TsuB"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNvbiUyMG9mJTIwYSUyMFByZWFjaGVyJTIwTWFuJTIyJTIwYXJ0aXN0JTNBJTIyRHVzdHklMjBTcHJpbmdmaWVsZCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81emFYWXdld0FYZWRLTkNmZjQ1VTVsIiwiaWQiOiI1emFYWXdld0FYZWRLTkNmZjQ1VTVsIiwibmFtZSI6IkR1c3R5IFNwcmluZ2ZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81RlJCNW9RYUh4bEROZTZnTUd1enUyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUZSQjVvUWFIeGxETmU2Z01HdXp1MiIsImlkIjoiNUZSQjVvUWFIeGxETmU2Z01HdXp1MiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlMjAwMzczMTEyMTA5MjRiM2MzODZmMDAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTIwMDM3MzExMjEwOTI0YjNjMzg2ZjAwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlMjAwMzczMTEyMTA5MjRiM2MzODZmMDAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRHVzdHkgSW4gTWVtcGhpcyIsInJlbGVhc2VfZGF0ZSI6IjE5NjktMDMtMzEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1RlJCNW9RYUh4bEROZTZnTUd1enUyIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81emFYWXdld0FYZQ==", + "ZEtOQ2ZmNDVVNWwiLCJpZCI6IjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJuYW1lIjoiRHVzdHkgU3ByaW5nZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDgwNTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkYwODAyMDEyNDUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZlazlTaUVqNWE2NVdJczJFVjdxaU0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82ZWs5U2lFajVhNjVXSXMyRVY3cWlNIiwiaWQiOiI2ZWs5U2lFajVhNjVXSXMyRVY3cWlNIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvbiBPZiBBIFByZWFjaGVyIE1hbiIsInRyYWNrX251bWJlciI6MTIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NmVrOVNpRWo1YTY1V0lzMkVWN3FpTSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81emFYWXdld0FYZWRLTkNmZjQ1VTVsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJpZCI6IjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJuYW1lIjoiRHVzdHkgU3ByaW5nZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ0NEJFQ292ZmtnR1RydGJxbVRsWmYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82dDRCRUNvdmZrZ0dUcnRicW1UbFpmIiwiaWQiOiI2dDRCRUNvdmZrZ0dUcnRicW1UbFpmIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzU4MjdjNDk5MTI5ZDlkOWI0ZWFhNTM2YSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1ODI3YzQ5OTEyOWQ5ZDliNGVhYTUzNmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTU4MjdjNDk5MTI5ZDlkOWI0ZWFhNTM2YSJ9XSwiaXNfcGxheWFibGUiOg==", + "dHJ1ZSwibmFtZSI6IlRoZSBTaWx2ZXIgQ29sbGVjdGlvbiIsInJlbGVhc2VfZGF0ZSI6IjE5ODgtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2dDRCRUNvdmZrZ0dUcnRicW1UbFpmIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81emFYWXdld0FYZWRLTkNmZjQ1VTVsIiwiaWQiOiI1emFYWXdld0FYZWRLTkNmZjQ1VTVsIiwibmFtZSI6IkR1c3R5IFNwcmluZ2ZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQ2NjI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JGMDg2ODAwNzU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wc2NydFBtdGxJVnd3azlzNExYSjhuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMHNjcnRQbXRsSVZ3d2s5czRMWEo4biIsImlkIjoiMHNjcnRQbXRsSVZ3d2s5czRMWEo4biIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb24gT2YgQSBQcmVhY2hlciBNYW4iLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBzY3J0UG10bElWd3drOXM0TFhKOG4ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81emFYWXdld0FYZWRLTkNmZjQ1VTVsIiwiaWQiOiI1emFYWXdld0FYZWRLTkNmZjQ1VTVsIiwibmFtZSI6IkR1c3R5IFNwcmluZ2ZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zQlhHVHVlV3FqbzhhSGVjTGFXWnAyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0JYR1R1ZVdxam84YUhlY0xhV1pwMiIsImlkIjoiM0JYR1R1ZVdxam84YUhlY0xhV1pwMiIsImltYQ==", + "Z2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzM3MjM3YjljMTEwNzM5MDVmOGM1YzNiYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzNzIzN2I5YzExMDczOTA1ZjhjNWMzYmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTM3MjM3YjljMTEwNzM5MDVmOGM1YzNiYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEdXN0eSBJbiBNZW1waGlzIiwicmVsZWFzZV9kYXRlIjoiMTk2OS0wMy0zMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNCWEdUdWVXcWpvOGFIZWNMYVdacDIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81emFYWXdld0FYZWRLTkNmZjQ1VTVsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJpZCI6IjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJuYW1lIjoiRHVzdHkgU3ByaW5nZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDQzMzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkYwODY4MDA3NTQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVUYkxPTlNHWnNSOGNiaE5Fb2RDSDYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81VGJMT05TR1pzUjhjYmhORW9kQ0g2IiwiaWQiOiI1VGJMT05TR1pzUjhjYmhORW9kQ0g2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvbiBPZiBBIFByZWFjaGVyIE1hbiIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1VGJMT05TR1pzUjhjYmhORW9kQ0g2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXphWFl3ZXdBWGVkS05DZg==", + "ZjQ1VTVsIiwiaWQiOiI1emFYWXdld0FYZWRLTkNmZjQ1VTVsIiwibmFtZSI6IkR1c3R5IFNwcmluZ2ZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81RlJCNW9RYUh4bEROZTZnTUd1enUyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUZSQjVvUWFIeGxETmU2Z01HdXp1MiIsImlkIjoiNUZSQjVvUWFIeGxETmU2Z01HdXp1MiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlMjAwMzczMTEyMTA5MjRiM2MzODZmMDAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTIwMDM3MzExMjEwOTI0YjNjMzg2ZjAwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlMjAwMzczMTEyMTA5MjRiM2MzODZmMDAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRHVzdHkgSW4gTWVtcGhpcyIsInJlbGVhc2VfZGF0ZSI6IjE5NjktMDMtMzEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1RlJCNW9RYUh4bEROZTZnTUd1enUyIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81emFYWXdld0FYZWRLTkNmZjQ1VTVsIiwiaWQiOiI1emFYWXdld0FYZWRLTkNmZjQ1VTVsIiwibmFtZSI6IkR1c3R5IFNwcmluZ2ZpZWxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQ1MDkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JGMDg2ODAwNzU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yOGpCb2xTU2ZrWERZWU9aV1RjSERFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMjhqQm9sU1Nma1hEWVlPWldUY0hERSIsImlkIjoiMjhqQm9sU1Nma1hEWVlPWldUY0hERSIsImlzX2xvY2FsIjpmYWxzZSwiaQ==", + "c19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvbiBPZiBBIFByZWFjaGVyIE1hbiIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyOGpCb2xTU2ZrWERZWU9aV1RjSERFIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRtYjhaVkk1TW1BQXBZNzkwOWo1WUsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80bWI4WlZJNU1tQUFwWTc5MDlqNVlLIiwiaWQiOiI0bWI4WlZJNU1tQUFwWTc5MDlqNVlLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzA4MGJkODRkOGE3NGM4ZTFlYWFlYWQ2YSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwODBiZDg0ZDhhNzRjOGUxZWFhZWFkNmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTA4MGJkODRkOGE3NGM4ZTFlYWFlYWQ2YSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZSBad2FydGUgTGlqc3QiLCJyZWxlYXNlX2RhdGUiOiIyMDEyLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NG1iOFpWSTVNbUFBcFk3OTA5ajVZSyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXphWFl3ZXdBWGVkS05DZmY0NVU1bCIsImlkIjoiNXphWFl3ZXdBWGVkS05DZmY0NVU1bCIsIm5hbWUiOiJEdXN0eSBTcHJpbmdmaWVsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1eg==", + "YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQ0MjkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JGMDg2ODAwNzU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xRVRIazhFcnFET3JuWUJIVmxvYjUzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMUVUSGs4RXJxRE9ybllCSFZsb2I1MyIsImlkIjoiMUVUSGs4RXJxRE9ybllCSFZsb2I1MyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb24gT2YgQSBQcmVhY2hlciBNYW4iLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUVUSGs4RXJxRE9ybllCSFZsb2I1MyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zc2tJWXZCQlBxZWJtVnd2YzVjb211In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM3NrSVl2QkJQcWVibVZ3dmM1Y29tdSIsImlkIjoiM3NrSVl2QkJQcWVibVZ3dmM1Y29tdSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZGQ2MDQxZGIwMTcyNDM4MDc1MmU1MjUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGRkNjA0MWRiMDE3MjQzODA3NTJlNTI1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwZGQ2MDQxZGIwMTcyNDM4MDc1MmU1MjUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR29sZGVuIE9sZGllcyIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDQtMDkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyOCwidHlwZSI6Ig==", + "YWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNza0lZdkJCUHFlYm1Wd3ZjNWNvbXUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81emFYWXdld0FYZWRLTkNmZjQ1VTVsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJpZCI6IjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJuYW1lIjoiRHVzdHkgU3ByaW5nZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDgwNTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkYwODAyMDEyNDUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVKYXBTdTc5U0ZiakJRSlRNNWRZQ3cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81SmFwU3U3OVNGYmpCUUpUTTVkWUN3IiwiaWQiOiI1SmFwU3U3OVNGYmpCUUpUTTVkWUN3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvbiBPZiBBIFByZWFjaGVyIE1hbiIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1SmFwU3U3OVNGYmpCUUpUTTVkWUN3In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXphWFl3ZXdBWGVkS05DZmY0NVU1bCIsImlkIjoiNXphWFl3ZXdBWGVkS05DZmY0NVU1bCIsIm5hbWUiOiJEdXN0eSBTcHJpbmdmaWVsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1emFYWXdld0FYZWRLTkNmZjQ1VTVsIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN0pZZzF6YXdoaGdDeHdHa0I3RGtnSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdKWWcxemF3aGhnQ3h3R2tCN0RrZ0siLCJpZCI6IjdKWWcxemF3aGhnQ3h3R2tCN0RrZ0siLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzg0NWU2NWFmYTQwNmIwOWYyNWUzNWZhIn0seyJoZWlnaHQiOg==", + "MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzg0NWU2NWFmYTQwNmIwOWYyNWUzNWZhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3ODQ1ZTY1YWZhNDA2YjA5ZjI1ZTM1ZmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIE1hZ2ljIG9mIER1c3R5IFNwcmluZ2ZpZWxkIiwicmVsZWFzZV9kYXRlIjoiMjAxMS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjkyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdKWWcxemF3aGhnQ3h3R2tCN0RrZ0sifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81emFYWXdld0FYZWRLTkNmZjQ1VTVsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJpZCI6IjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJuYW1lIjoiRHVzdHkgU3ByaW5nZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXphWFl3ZXdBWGVkS05DZmY0NVU1bCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDYxMzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkYwODY4MDA3NTQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNpRGFLMFZzdzFqUmZ1R2pHQlZVMjUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zaURhSzBWc3cxalJmdUdqR0JWVTI1IiwiaWQiOiIzaURhSzBWc3cxalJmdUdqR0JWVTI1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvbiBPZiBBIFByZWFjaGVyIE1hbiIsInRyYWNrX251bWJlciI6MTksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2lEYUswVnN3MWpSZnVHakdCVlUyNSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81emFYWXdld0FYZWRLTkNmZjQ1VTVsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJpZCI6IjV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwiLCJuYW1lIjoiRHVzdHkgU3ByaW5nZmllbGQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeQ==", + "OmFydGlzdDo1emFYWXdld0FYZWRLTkNmZjQ1VTVsIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMW5xRlZlcU9sSVZhbjh4a0tYME82aiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFucUZWZXFPbElWYW44eGtLWDBPNmoiLCJpZCI6IjFucUZWZXFPbElWYW44eGtLWDBPNmoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMWY2NDQzMWRlNjczMTBlNzQ1YzVlMzI3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjFmNjQ0MzFkZTY3MzEwZTc0NWM1ZTMyNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMWY2NDQzMWRlNjczMTBlNzQ1YzVlMzI3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNvbXBsZXRlIEEgQW5kIEIgU2lkZXMgMTk2MyAtIDE5NzAiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MW5xRlZlcU9sSVZhbjh4a0tYME82aiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXphWFl3ZXdBWGVkS05DZmY0NVU1bCIsImlkIjoiNXphWFl3ZXdBWGVkS05DZmY0NVU1bCIsIm5hbWUiOiJEdXN0eSBTcHJpbmdmaWVsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1emFYWXdld0FYZWRLTkNmZjQ1VTVsIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0NjIyNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCRjA4MDIwMTI0NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnpKR25NeXVTbzFxQm11amFWV1ZCaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ6SkduTXl1U28xcUJtdWphVldWQmoiLCJpZCI6IjZ6SkduTXl1U28xcUJtdWphVldWQmoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU29uIE9mIEEgUHJlYWNoZXIgTWFuIiwidHJhY2tfbnVtYmVyIjoxNywidHlwZSI6InRyYQ==", + "Y2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZ6SkduTXl1U28xcUJtdWphVldWQmoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM0Z4S25TdTBBd1pDVmltVUx2bWxVaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNGeEtuU3UwQXdaQ1ZpbVVMdm1sVWoiLCJpZCI6IjNGeEtuU3UwQXdaQ1ZpbVVMdm1sVWoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTgyOTc2NjAyZDQ2Y2IxNmI5YzMwMDJkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjU4Mjk3NjYwMmQ0NmNiMTZiOWMzMDAyZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTgyOTc2NjAyZDQ2Y2IxNmI5YzMwMDJkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1vdmllIEJhbGxhZHMiLCJyZWxlYXNlX2RhdGUiOiIyMDAyLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0Z4S25TdTBBd1pDVmltVUx2bWxVaiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV6YVhZd2V3QVhlZEtOQ2ZmNDVVNWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXphWFl3ZXdBWGVkS05DZmY0NVU1bCIsImlkIjoiNXphWFl3ZXdBWGVkS05DZmY0NVU1bCIsIm5hbWUiOiJEdXN0eSBTcHJpbmdmaWVsZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1emFYWXdld0FYZWRLTkNmZjQ1VTVsIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0Njg2NiwiZXhwbGljaXQiOmZhbHNlLA==", + "ImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JGMDg2ODAwNzU0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80Z1lsOW0yb0VySmd3WTJjdTJUc3VCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGdZbDltMm9Fckpnd1kyY3UyVHN1QiIsImlkIjoiNGdZbDltMm9Fckpnd1kyY3UyVHN1QiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb24gT2YgQSBQcmVhY2hlciBNYW4iLCJ0cmFja19udW1iZXIiOjExLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRnWWw5bTJvRXJKZ3dZMmN1MlRzdUIifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Son+of+a+Preacher+Man%22+artist%3A%22Dusty+Springfield%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Didn%27t%20I%20Blow%20Your%20Mind%20This%20Time%22%20artist%3A%22The%20Delfonics%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Ie6D0KslXxrbkOAr5sbyX"},"href":"https://api.spotify.com/v1/albums/6Ie6D0KslXxrbkOAr5sbyX","id":"6Ie6D0KslXxrbkOAr5sbyX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f606a66ae319776c0dc86ce8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f606a66ae319776c0dc86ce8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f606a66ae319776c0dc86ce8"}],"is_playable":true,"name":"The Delfonics","release_date":"1970","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:6Ie6D0KslXxrbkOAr5sbyX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":201066,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/1NeKY4qWsCnhY8fvhwQa7q"},"href":"https://api.spotify.com/v1/tracks/1NeKY4qWsCnhY8fvhwQa7q","id":"1NeKY4qWsCnhY8fvhwQa7q","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":1,"type":"track","uri":"spotify:track:1NeKY4qWsCnhY8fvhwQa7q"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/661re5NCCdkxHaCG3xv8k5"},"href":"https://api.spotify.com/v1/albums/661re5NCCdkxHaCG3xv8k5","id":"661re5NCCdkxHaCG3xv8k5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738f94e3897d30ea450e10558f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028f94e3897d30ea450e10558f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518f94e3897d30ea450e10558f"}],"is_playable":true,"name":"La-La Means I Love You","release_date":"1997-08-25","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:661re5NCCdkxHaCG3xv8k5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":201293,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/0mJc5rDPSctw9RY46TOm5A"},"href":"https://api.spotify.com/v1/tracks/0mJc5rDPSctw9RY46TOm5A","id":"0mJc5rDPSctw9RY46TOm5A","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":9,"type":"track","uri":"spotify:track:0mJc5rDPSctw9RY46TOm5A"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/47I69OChJY93PaFpCRhS31"},"href":"https://api.spotify.com/v1/albums/47I69OChJY93PaFpCRhS31","id":"47I69OChJY93PaFpCRhS31","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dfbdf98869da083c15e52998"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dfbdf98869da083c15e52998"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dfbdf98869da083c15e52998"}],"is_playable":true,"name":"Love Songs","release_date":"2005-01-11","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:47I69OChJY93PaFpCRhS31"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":202960,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/3siowA42NaMMsPGF5lxi3T"},"href":"https://api.spotify.com/v1/tracks/3siowA42NaMMsPGF5lxi3T","id":"3siowA42NaMMsPGF5lxi3T","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":5,"type":"track","uri":"spotify:track:3siowA42NaMMsPGF5lxi3T"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1WzKyOIFW45U8ZSuLVHGLq"},"href":"https://api.spotify.com/v1/albums/1WzKyOIFW45U8ZSuLVHGLq","id":"1WzKyOIFW45U8ZSuLVHGLq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bba5e4bfeadbe0950c12a26f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bba5e4bfeadbe0950c12a26f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bba5e4bfeadbe0950c12a26f"}],"is_playable":true,"name":"Sunday Morning","release_date":"2010-12-17","release_date_precision":"day","total_tracks":60,"type":"album","uri":"spotify:album:1WzKyOIFW45U8ZSuLVHGLq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":202960,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/2WIJDjBIQvHJc7REEwNkUX"},"href":"https://api.spotify.com/v1/tracks/2WIJDjBIQvHJc7REEwNkUX","id":"2WIJDjBIQvHJc7REEwNkUX","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":36,"type":"track","uri":"spotify:track:2WIJDjBIQvHJc7REEwNkUX"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/1wpMIDLFtpz8xrm37qY5MG"},"href":"https://api.spotify.com/v1/albums/1wpMIDLFtpz8xrm37qY5MG","id":"1wpMIDLFtpz8xrm37qY5MG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27338c72ef83fe47f29c5cfb886"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0238c72ef83fe47f29c5cfb886"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485138c72ef83fe47f29c5cfb886"}],"is_playable":true,"name":"The Very Best Of","release_date":"2003-05-05","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1wpMIDLFtpz8xrm37qY5MG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":199200,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/3l4YrJeHWK3E6Xf7q0YKWa"},"href":"https://api.spotify.com/v1/tracks/3l4YrJeHWK3E6Xf7q0YKWa","id":"3l4YrJeHWK3E6Xf7q0YKWa","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":4,"type":"track","uri":"spotify:track:3l4YrJeHWK3E6Xf7q0YKWa"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3cceuam4ZfqSSC4uVchxvx"},"href":"https://api.spotify.com/v1/albums/3cceuam4ZfqSSC4uVchxvx","id":"3cceuam4ZfqSSC4uVchxvx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c59e912a41f34db94c75c828"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c59e912a41f34db94c75c828"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c59e912a41f34db94c75c828"}],"is_playable":true,"name":"Pure... '60s","release_date":"2012-03-26","release_date_precision":"day","total_tracks":68,"type":"album","uri":"spotify:album:3cceuam4ZfqSSC4uVchxvx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":2,"duration_ms":200253,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/0gaGF4jHKazwQYDbDvTjcq"},"href":"https://api.spotify.com/v1/tracks/0gaGF4jHKazwQYDbDvTjcq","id":"0gaGF4jHKazwQYDbDvTjcq","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":15,"type":"track","uri":"spotify:track:0gaGF4jHKazwQYDbDvTjcq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ozDtdDznuECwLlFboqv0W"},"href":"https://api.spotify.com/v1/albums/4ozDtdDznuECwLlFboqv0W","id":"4ozDtdDznuECwLlFboqv0W","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e6fd36043f93d03beb39006"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e6fd36043f93d03beb39006"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e6fd36043f93d03beb39006"}],"is_playable":true,"name":"Woodstock Generation","release_date":"2009-07-23","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:4ozDtdDznuECwLlFboqv0W"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":202960,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/3AJZCjr4QSYUcGsTEkOOUT"},"href":"https://api.spotify.com/v1/tracks/3AJZCjr4QSYUcGsTEkOOUT","id":"3AJZCjr4QSYUcGsTEkOOUT","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":37,"type":"track","uri":"spotify:track:3AJZCjr4QSYUcGsTEkOOUT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/0yBRZK5b6TmZGJ7sCm23jQ"},"href":"https://api.spotify.com/v1/albums/0yBRZK5b6TmZGJ7sCm23jQ","id":"0yBRZK5b6TmZGJ7sCm23jQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27316bcc9d8f788dd02394f697e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0216bcc9d8f788dd02394f697e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485116bcc9d8f788dd02394f697e"}],"is_playable":true,"name":"The Essential Delfonics","release_date":"2015-03-06","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:0yBRZK5b6TmZGJ7sCm23jQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":2,"duration_ms":199093,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/3I6jdRTTxZPG6aXiaLUp5R"},"href":"https://api.spotify.com/v1/tracks/3I6jdRTTxZPG6aXiaLUp5R","id":"3I6jdRTTxZPG6aXiaLUp5R","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":6,"type":"track","uri":"spotify:track:3I6jdRTTxZPG6aXiaLUp5R"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/3goVF87cZyNdWjL5FqBFDk"},"href":"https://api.spotify.com/v1/albums/3goVF87cZyNdWjL5FqBFDk","id":"3goVF87cZyNdWjL5FqBFDk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eec851e2feec4206c6d44248"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eec851e2feec4206c6d44248"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eec851e2feec4206c6d44248"}],"is_playable":true,"name":"The Definitive Collection","release_date":"1999","release_date_precision":"year","total_tracks":20,"type":"album","uri":"spotify:album:3goVF87cZyNdWjL5FqBFDk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":201466,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/2s68kd2jgdQW6kdlIFDnDS"},"href":"https://api.spotify.com/v1/tracks/2s68kd2jgdQW6kdlIFDnDS","id":"2s68kd2jgdQW6kdlIFDnDS","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":9,"type":"track","uri":"spotify:track:2s68kd2jgdQW6kdlIFDnDS"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRpZG4lMjd0JTIwSSUyMEJsb3clMjBZb3VyJTIwTWluZCUyMFRoaXMlMjBUaW1lJTIyJTIwYXJ0aXN0JTNBJTIyVGhlJTIwRGVsZm9uaWNzJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo5LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82WVBSWHUxZGF6R1ljU1p2NEhKRUg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJpZCI6IjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJuYW1lIjoiVGhlIERlbGZvbmljcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2WVBSWHUxZGF6R1ljU1p2NEhKRUg0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkllNkQwS3NsWHhyYmtPQXI1c2J5WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZJZTZEMEtzbFh4cmJrT0FyNXNieVgiLCJpZCI6IjZJZTZEMEtzbFh4cmJrT0FyNXNieVgiLCJpbWFnZXMiOlt7ImhlaWdodCI6", + "NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjYwNmE2NmFlMzE5Nzc2YzBkYzg2Y2U4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY2MDZhNjZhZTMxOTc3NmMwZGM4NmNlOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjYwNmE2NmFlMzE5Nzc2YzBkYzg2Y2U4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBEZWxmb25pY3MiLCJyZWxlYXNlX2RhdGUiOiIxOTcwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZJZTZEMEtzbFh4cmJrT0FyNXNieVgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82WVBSWHUxZGF6R1ljU1p2NEhKRUg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJpZCI6IjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJuYW1lIjoiVGhlIERlbGZvbmljcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2WVBSWHUxZGF6R1ljU1p2NEhKRUg0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwMTA2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQVIxOTcwMDI3MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMU5lS1k0cVdzQ25oWThmdmh3UWE3cSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFOZUtZNHFXc0NuaFk4ZnZod1FhN3EiLCJpZCI6IjFOZUtZNHFXc0NuaFk4ZnZod1FhN3EiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGlkbid0IEkgKEJsb3cgWW91ciBNaW5kIFRoaXMgVGltZSkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MU5lS1k0cVdzQ25oWThmdmh3UWE3cSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82WVBSWHUxZGF6R1ljU1p2NEhKRUg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLA==", + "ImlkIjoiNllQUlh1MWRhekdZY1NadjRISkVINCIsIm5hbWUiOiJUaGUgRGVsZm9uaWNzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82NjFyZTVOQ0Nka3hIYUNHM3h2OGs1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjYxcmU1TkNDZGt4SGFDRzN4djhrNSIsImlkIjoiNjYxcmU1TkNDZGt4SGFDRzN4djhrNSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4Zjk0ZTM4OTdkMzBlYTQ1MGUxMDU1OGYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOGY5NGUzODk3ZDMwZWE0NTBlMTA1NThmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4Zjk0ZTM4OTdkMzBlYTQ1MGUxMDU1OGYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGEtTGEgTWVhbnMgSSBMb3ZlIFlvdSIsInJlbGVhc2VfZGF0ZSI6IjE5OTctMDgtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2NjFyZTVOQ0Nka3hIYUNHM3h2OGs1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNllQUlh1MWRhekdZY1NadjRISkVINCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82WVBSWHUxZGF6R1ljU1p2NEhKRUg0IiwiaWQiOiI2WVBSWHUxZGF6R1ljU1p2NEhKRUg0IiwibmFtZSI6IlRoZSBEZWxmb25pY3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NllQUlh1MWRhekdZY1NadjRISkVINCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDEyOTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FSMTk3MDAyNzEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBtSmM1ckRQU2N0dzlSWTQ2VE9tNUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wbUpjNXJEUFNjdHc5Ulk0NlRPbTVBIiwiaWQiOiIwbUpjNXJEUFNjdHc5Ulk0NlRPbTVBIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZQ==", + "Ijp0cnVlLCJuYW1lIjoiRGlkbid0IEkgKEJsb3cgWW91ciBNaW5kIFRoaXMgVGltZSkiLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MG1KYzVyRFBTY3R3OVJZNDZUT201QSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82WVBSWHUxZGF6R1ljU1p2NEhKRUg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJpZCI6IjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJuYW1lIjoiVGhlIERlbGZvbmljcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2WVBSWHUxZGF6R1ljU1p2NEhKRUg0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNDdJNjlPQ2hKWTkzUGFGcENSaFMzMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzQ3STY5T0NoSlk5M1BhRnBDUmhTMzEiLCJpZCI6IjQ3STY5T0NoSlk5M1BhRnBDUmhTMzEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZGZiZGY5ODg2OWRhMDgzYzE1ZTUyOTk4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmRmYmRmOTg4NjlkYTA4M2MxNWU1Mjk5OCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZGZiZGY5ODg2OWRhMDgzYzE1ZTUyOTk4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxvdmUgU29uZ3MiLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTAxLTExIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NDdJNjlPQ2hKWTkzUGFGcENSaFMzMSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNllQUlh1MWRhekdZY1NadjRISkVINCIsImlkIjoiNllQUlh1MWRhekdZY1NadjRISkVINCIsIm5hbWUiOiJUaGUgRGVsZm9uaWNzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZZUFJYdTFkYQ==", + "ekdZY1NadjRISkVINCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDI5NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FSMTk3MDAwNzcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNzaW93QTQyTmFNTXNQR0Y1bHhpM1QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zc2lvd0E0Mk5hTU1zUEdGNWx4aTNUIiwiaWQiOiIzc2lvd0E0Mk5hTU1zUEdGNWx4aTNUIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpZG4ndCBJIChCbG93IFlvdXIgTWluZCBUaGlzIFRpbWUpIiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNzaW93QTQyTmFNTXNQR0Y1bHhpM1QifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMVd6S3lPSUZXNDVVOFpTdUxWSEdMcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFXekt5T0lGVzQ1VThaU3VMVkhHTHEiLCJpZCI6IjFXekt5T0lGVzQ1VThaU3VMVkhHTHEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYmJhNWU0YmZlYWRiZTA5NTBjMTJhMjZmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJiYTVlNGJmZWFkYmUwOTUwYzEyYTI2ZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYmJhNWU0YmZlYWRiZTA5NTBjMTJhMjZmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bmRheSBNb3JuaW5nIiwicmVsZWFzZV9kYXRlIjoiMjAxMC0xMi0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjYwLA==", + "InR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVd6S3lPSUZXNDVVOFpTdUxWSEdMcSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNllQUlh1MWRhekdZY1NadjRISkVINCIsImlkIjoiNllQUlh1MWRhekdZY1NadjRISkVINCIsIm5hbWUiOiJUaGUgRGVsZm9uaWNzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjAyOTYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBUjE5NzAwMDc3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yV0lKRGpCSVF2SEpjN1JFRXdOa1VYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMldJSkRqQklRdkhKYzdSRUV3TmtVWCIsImlkIjoiMldJSkRqQklRdkhKYzdSRUV3TmtVWCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaWRuJ3QgSSAoQmxvdyBZb3VyIE1pbmQgVGhpcyBUaW1lKSIsInRyYWNrX251bWJlciI6MzYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MldJSkRqQklRdkhKYzdSRUV3TmtVWCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82WVBSWHUxZGF6R1ljU1p2NEhKRUg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJpZCI6IjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJuYW1lIjoiVGhlIERlbGZvbmljcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2WVBSWHUxZGF6R1ljU1p2NEhKRUg0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMXdwTUlETEZ0cHo4eHJtMzdxWTVNRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzF3cE1JRExGdHB6OHhybTM3cVk1TUciLCJpZCI6IjF3cE1JRExGdHB6OHhybTM3cVk1TUciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzhjNzJlZjgzZmU0N2YyOWM1Y2ZiOA==", + "ODYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzhjNzJlZjgzZmU0N2YyOWM1Y2ZiODg2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzOGM3MmVmODNmZTQ3ZjI5YzVjZmI4ODYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIFZlcnkgQmVzdCBPZiIsInJlbGVhc2VfZGF0ZSI6IjIwMDMtMDUtMDUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxd3BNSURMRnRwejh4cm0zN3FZNU1HIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNllQUlh1MWRhekdZY1NadjRISkVINCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82WVBSWHUxZGF6R1ljU1p2NEhKRUg0IiwiaWQiOiI2WVBSWHUxZGF6R1ljU1p2NEhKRUg0IiwibmFtZSI6IlRoZSBEZWxmb25pY3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NllQUlh1MWRhekdZY1NadjRISkVINCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTkyMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FSMTk3MDAyNzEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNsNFlySmVIV0szRTZYZjdxMFlLV2EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zbDRZckplSFdLM0U2WGY3cTBZS1dhIiwiaWQiOiIzbDRZckplSFdLM0U2WGY3cTBZS1dhIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpZG4ndCBJIChCbG93IFlvdXIgTWluZCBUaGlzIFRpbWUpIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNsNFlySmVIV0szRTZYZjdxMFlLV2EifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOg==", + "InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zY2NldWFtNFpmcVNTQzR1VmNoeHZ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2NjZXVhbTRaZnFTU0M0dVZjaHh2eCIsImlkIjoiM2NjZXVhbTRaZnFTU0M0dVZjaHh2eCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjNTllOTEyYTQxZjM0ZGI5NGM3NWM4MjgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzU5ZTkxMmE0MWYzNGRiOTRjNzVjODI4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjNTllOTEyYTQxZjM0ZGI5NGM3NWM4MjgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUHVyZS4uLiAnNjBzIiwicmVsZWFzZV9kYXRlIjoiMjAxMi0wMy0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjY4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNjY2V1YW00WmZxU1NDNHVWY2h4dngifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82WVBSWHUxZGF6R1ljU1p2NEhKRUg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJpZCI6IjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJuYW1lIjoiVGhlIERlbGZvbmljcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2WVBSWHUxZGF6R1ljU1p2NEhKRUg0In1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjIwMDI1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQVIxOTcwMDA3NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMGdhR0Y0akhLYXp3UVlEYkR2VGpjcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBnYUdGNGpIS2F6d1FZRGJEdlRqY3EiLCJpZCI6IjBnYUdGNGpIS2F6d1FZRGJEdlRqY3EiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGlkbid0IEkgKEJsb3cgWW91ciBNaW5kIFRoaXMgVGltZSkiLCJ0cmFja19udW1iZXIiOjE1LCJ0eXBlIjoidHJhY2siLA==", + "InVyaSI6InNwb3RpZnk6dHJhY2s6MGdhR0Y0akhLYXp3UVlEYkR2VGpjcSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80b3pEdGREem51RUN3TGxGYm9xdjBXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNG96RHRkRHpudUVDd0xsRmJvcXYwVyIsImlkIjoiNG96RHRkRHpudUVDd0xsRmJvcXYwVyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3ZTZmZDM2MDQzZjkzZDAzYmViMzkwMDYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyN2U2ZmQzNjA0M2Y5M2QwM2JlYjM5MDA2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3ZTZmZDM2MDQzZjkzZDAzYmViMzkwMDYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV29vZHN0b2NrIEdlbmVyYXRpb24iLCJyZWxlYXNlX2RhdGUiOiIyMDA5LTA3LTIzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRvekR0ZER6bnVFQ3dMbEZib3F2MFcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82WVBSWHUxZGF6R1ljU1p2NEhKRUg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJpZCI6IjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJuYW1lIjoiVGhlIERlbGZvbmljcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2WVBSWHUxZGF6R1ljU1p2NEhKRUg0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwMjk2MCwiZXhwbGljaXQiOmZhbHNlLA==", + "ImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBUjE5NzAwMDc3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zQUpaQ2pyNFFTWVVjR3NURWtPT1VUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0FKWkNqcjRRU1lVY0dzVEVrT09VVCIsImlkIjoiM0FKWkNqcjRRU1lVY0dzVEVrT09VVCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaWRuJ3QgSSAoQmxvdyBZb3VyIE1pbmQgVGhpcyBUaW1lKSIsInRyYWNrX251bWJlciI6MzcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0FKWkNqcjRRU1lVY0dzVEVrT09VVCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82WVBSWHUxZGF6R1ljU1p2NEhKRUg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJpZCI6IjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQiLCJuYW1lIjoiVGhlIERlbGZvbmljcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2WVBSWHUxZGF6R1ljU1p2NEhKRUg0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMHlCUlpLNWI2VG1aR0o3c0NtMjNqUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzB5QlJaSzViNlRtWkdKN3NDbTIzalEiLCJpZCI6IjB5QlJaSzViNlRtWkdKN3NDbTIzalEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMTZiY2M5ZDhmNzg4ZGQwMjM5NGY2OTdlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE2YmNjOWQ4Zjc4OGRkMDIzOTRmNjk3ZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTZiY2M5ZDhmNzg4ZGQwMjM5NGY2OTdlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBFc3NlbnRpYWwgRGVsZm9uaWNzIiwicmVsZWFzZV9kYXRlIjoiMjAxNS0wMy0wNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjB5QlJaSzViNlRtWkdKN3NDbTIzalEifSwiYQ==", + "cnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNllQUlh1MWRhekdZY1NadjRISkVINCIsImlkIjoiNllQUlh1MWRhekdZY1NadjRISkVINCIsIm5hbWUiOiJUaGUgRGVsZm9uaWNzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MTk5MDkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBUjE5NzAwMjcxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zSTZqZFJUVHhaUEc2YVhpYUxVcDVSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0k2amRSVFR4WlBHNmFYaWFMVXA1UiIsImlkIjoiM0k2amRSVFR4WlBHNmFYaWFMVXA1UiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaWRuJ3QgSSAoQmxvdyBZb3VyIE1pbmQgVGhpcyBUaW1lKSIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozSTZqZFJUVHhaUEc2YVhpYUxVcDVSIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZZUFJYdTFkYXpHWWNTWnY0SEpFSDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNllQUlh1MWRhekdZY1NadjRISkVINCIsImlkIjoiNllQUlh1MWRhekdZY1NadjRISkVINCIsIm5hbWUiOiJUaGUgRGVsZm9uaWNzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZZUFJYdTFkYXpHWWNTWnY0SEpFSDQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zZ29WRjg3Y1p5TmRXakw1RnFCRkRrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2dvVkY4N2NaeU5kV2pMNUZxQkZEayIsImlkIjoiM2dvVkY4N2NaeU5kV2pMNUZxQkZEayIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlZWM4NTFlMmZlZWM0MjA2YzZkNDQyNDgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYg==", + "Njc2MTZkMDAwMDFlMDJlZWM4NTFlMmZlZWM0MjA2YzZkNDQyNDgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVlYzg1MWUyZmVlYzQyMDZjNmQ0NDI0OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgRGVmaW5pdGl2ZSBDb2xsZWN0aW9uIiwicmVsZWFzZV9kYXRlIjoiMTk5OSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoyMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozZ29WRjg3Y1p5TmRXakw1RnFCRkRrIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNllQUlh1MWRhekdZY1NadjRISkVINCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82WVBSWHUxZGF6R1ljU1p2NEhKRUg0IiwiaWQiOiI2WVBSWHUxZGF6R1ljU1p2NEhKRUg0IiwibmFtZSI6IlRoZSBEZWxmb25pY3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NllQUlh1MWRhekdZY1NadjRISkVINCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDE0NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FSMTk3MDAwNzcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJzNjhrZDJqZ2RRVzZrZGxJRkRuRFMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yczY4a2QyamdkUVc2a2RsSUZEbkRTIiwiaWQiOiIyczY4a2QyamdkUVc2a2RsSUZEbkRTIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmE=", + "bWUiOiJEaWRuJ3QgSSAoQmxvdyBZb3VyIE1pbmQgVGhpcyBUaW1lKSIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyczY4a2QyamdkUVc2a2RsSUZEbkRTIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Didn%27t+I+Blow+Your+Mind+This+Time%22+artist%3A%22The+Delfonics%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Gypsy%22%20artist%3A%22Fleetwood%20Mac%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/0LfM3PGkXE6KvJEE1HkOnz"},"href":"https://api.spotify.com/v1/albums/0LfM3PGkXE6KvJEE1HkOnz","id":"0LfM3PGkXE6KvJEE1HkOnz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eb832efe061888ee7ef10456"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eb832efe061888ee7ef10456"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eb832efe061888ee7ef10456"}],"is_playable":true,"name":"Greatest Hits","release_date":"1988-11-22","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0LfM3PGkXE6KvJEE1HkOnz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":264906,"explicit":false,"external_ids":{"isrc":"USWB19900203"},"external_urls":{"spotify":"https://open.spotify.com/track/19Ym5Sg0YyOCa6ao21bdoG"},"href":"https://api.spotify.com/v1/tracks/19Ym5Sg0YyOCa6ao21bdoG","id":"19Ym5Sg0YyOCa6ao21bdoG","is_local":false,"is_playable":true,"name":"Gypsy","track_number":6,"type":"track","uri":"spotify:track:19Ym5Sg0YyOCa6ao21bdoG"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/1dZNgJ3Gh3wp6ohzk29JUG"},"href":"https://api.spotify.com/v1/albums/1dZNgJ3Gh3wp6ohzk29JUG","id":"1dZNgJ3Gh3wp6ohzk29JUG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27306a0a0ab1f8d31eafa7704e4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0206a0a0ab1f8d31eafa7704e4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485106a0a0ab1f8d31eafa7704e4"}],"is_playable":true,"name":"Mirage (Deluxe Edition)","release_date":"1982-06-18","release_date_precision":"day","total_tracks":45,"type":"album","uri":"spotify:album:1dZNgJ3Gh3wp6ohzk29JUG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":267033,"explicit":false,"external_ids":{"isrc":"USRH11602231"},"external_urls":{"spotify":"https://open.spotify.com/track/5J0aNEUTxJWKXnQmyY3vUp"},"href":"https://api.spotify.com/v1/tracks/5J0aNEUTxJWKXnQmyY3vUp","id":"5J0aNEUTxJWKXnQmyY3vUp","is_local":false,"is_playable":true,"name":"Gypsy - 2016 Remaster","track_number":5,"type":"track","uri":"spotify:track:5J0aNEUTxJWKXnQmyY3vUp"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/2962eYkQa0R7EnIGZqeARS"},"href":"https://api.spotify.com/v1/albums/2962eYkQa0R7EnIGZqeARS","id":"2962eYkQa0R7EnIGZqeARS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b1751ac18b2596c1c870611f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b1751ac18b2596c1c870611f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b1751ac18b2596c1c870611f"}],"is_playable":true,"name":"Mirage (2016 Remaster)","release_date":"1982-06-18","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:2962eYkQa0R7EnIGZqeARS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":267033,"explicit":false,"external_ids":{"isrc":"USRH11602231"},"external_urls":{"spotify":"https://open.spotify.com/track/1A4atcphOI8vxrgp1YJjuf"},"href":"https://api.spotify.com/v1/tracks/1A4atcphOI8vxrgp1YJjuf","id":"1A4atcphOI8vxrgp1YJjuf","is_local":false,"is_playable":true,"name":"Gypsy - 2016 Remaster","track_number":5,"type":"track","uri":"spotify:track:1A4atcphOI8vxrgp1YJjuf"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/5YzOUVdLMrItgSP3lMxReH"},"href":"https://api.spotify.com/v1/albums/5YzOUVdLMrItgSP3lMxReH","id":"5YzOUVdLMrItgSP3lMxReH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27318c0cb6bcd7bfecee189242f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0218c0cb6bcd7bfecee189242f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485118c0cb6bcd7bfecee189242f"}],"is_playable":true,"name":"Greatest Hits (Deluxe Edition)","release_date":"1988-11-22","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:5YzOUVdLMrItgSP3lMxReH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":263693,"explicit":false,"external_ids":{"isrc":"USWB22600013"},"external_urls":{"spotify":"https://open.spotify.com/track/4dl07Wkmc9boGPp57QYgLZ"},"href":"https://api.spotify.com/v1/tracks/4dl07Wkmc9boGPp57QYgLZ","id":"4dl07Wkmc9boGPp57QYgLZ","is_local":false,"is_playable":true,"name":"Gypsy","track_number":6,"type":"track","uri":"spotify:track:4dl07Wkmc9boGPp57QYgLZ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/06JqOkwwy91OxrApXclzYf"},"href":"https://api.spotify.com/v1/albums/06JqOkwwy91OxrApXclzYf","id":"06JqOkwwy91OxrApXclzYf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273470a57c2dc8710171d4783df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02470a57c2dc8710171d4783df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851470a57c2dc8710171d4783df"}],"is_playable":true,"name":"50 Years - Don't Stop","release_date":"2018-11-16","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:06JqOkwwy91OxrApXclzYf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":263866,"explicit":false,"external_ids":{"isrc":"USRH11802591"},"external_urls":{"spotify":"https://open.spotify.com/track/5nTnApD6zNvuHJe0fXU5Jg"},"href":"https://api.spotify.com/v1/tracks/5nTnApD6zNvuHJe0fXU5Jg","id":"5nTnApD6zNvuHJe0fXU5Jg","is_local":false,"is_playable":true,"name":"Gypsy - 2018 Remaster","track_number":12,"type":"track","uri":"spotify:track:5nTnApD6zNvuHJe0fXU5Jg"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/7A0defNYClzfQHV8ifOBv0"},"href":"https://api.spotify.com/v1/albums/7A0defNYClzfQHV8ifOBv0","id":"7A0defNYClzfQHV8ifOBv0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27353dd2d2264885e16b3315516"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0253dd2d2264885e16b3315516"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485153dd2d2264885e16b3315516"}],"is_playable":true,"name":"The Very Best Of Fleetwood Mac","release_date":"2002-10-12","release_date_precision":"day","total_tracks":36,"type":"album","uri":"spotify:album:7A0defNYClzfQHV8ifOBv0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":2,"duration_ms":262866,"explicit":false,"external_ids":{"isrc":"USWB10202621"},"external_urls":{"spotify":"https://open.spotify.com/track/6fSB2a32s34JmYkx725NA7"},"href":"https://api.spotify.com/v1/tracks/6fSB2a32s34JmYkx725NA7","id":"6fSB2a32s34JmYkx725NA7","is_local":false,"is_playable":true,"name":"Gypsy - 2002 Remaster","track_number":4,"type":"track","uri":"spotify:track:6fSB2a32s34JmYkx725NA7"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4GF7EtCkl4O73kpNcjrOh5"},"href":"https://api.spotify.com/v1/albums/4GF7EtCkl4O73kpNcjrOh5","id":"4GF7EtCkl4O73kpNcjrOh5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738caa720ac5ba7c3b9b0571e0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028caa720ac5ba7c3b9b0571e0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518caa720ac5ba7c3b9b0571e0"}],"is_playable":true,"name":"Chill Tracks - 80s & 90s","release_date":"2024-10-09","release_date_precision":"day","total_tracks":65,"type":"album","uri":"spotify:album:4GF7EtCkl4O73kpNcjrOh5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":263866,"explicit":false,"external_ids":{"isrc":"USRH11802591"},"external_urls":{"spotify":"https://open.spotify.com/track/688rOlYs2WZwHpTzOMGBn7"},"href":"https://api.spotify.com/v1/tracks/688rOlYs2WZwHpTzOMGBn7","id":"688rOlYs2WZwHpTzOMGBn7","is_local":false,"is_playable":true,"name":"Gypsy - 2018 Remaster","track_number":4,"type":"track","uri":"spotify:track:688rOlYs2WZwHpTzOMGBn7"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkd5cHN5JTIyJTIwYXJ0aXN0JTNBJTIyRmxlZXR3b29kJTIwTWFjJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo3LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMExmTTNQR2tYRTZLdkpFRTFIa09ueiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBMZk0zUEdrWEU2S3ZKRUUxSGtPbnoiLCJpZCI6IjBMZk0zUEdrWEU2S3ZKRUUxSGtPbnoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nk", + "bi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZWI4MzJlZmUwNjE4ODhlZTdlZjEwNDU2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmViODMyZWZlMDYxODg4ZWU3ZWYxMDQ1NiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZWI4MzJlZmUwNjE4ODhlZTdlZjEwNDU2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdyZWF0ZXN0IEhpdHMiLCJyZWxlYXNlX2RhdGUiOiIxOTg4LTExLTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MExmTTNQR2tYRTZLdkpFRTFIa09ueiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY0OTA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNXQjE5OTAwMjAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xOVltNVNnMFl5T0NhNmFvMjFiZG9HIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMTlZbTVTZzBZeU9DYTZhbzIxYmRvRyIsImlkIjoiMTlZbTVTZzBZeU9DYTZhbzIxYmRvRyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHeXBzeSIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxOVltNVNnMFl5T0NhNmFvMjFiZG9HIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdA==", + "IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFkWk5nSjNHaDN3cDZvaHprMjlKVUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xZFpOZ0ozR2gzd3A2b2h6azI5SlVHIiwiaWQiOiIxZFpOZ0ozR2gzd3A2b2h6azI5SlVHIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzA2YTBhMGFiMWY4ZDMxZWFmYTc3MDRlNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwNmEwYTBhYjFmOGQzMWVhZmE3NzA0ZTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTA2YTBhMGFiMWY4ZDMxZWFmYTc3MDRlNCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNaXJhZ2UgKERlbHV4ZSBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjE5ODItMDYtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0NSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxZFpOZ0ozR2gzd3A2b2h6azI5SlVHIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjcwMzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTE2MDIyMzEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVKMGFORVVUeEpXS1huUW15WTN2VXAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81SjBhTkVVVHhKV0tYblFteVkzdlVwIiwiaWQiOiI1SjBhTkVVVHhKV0tYblFteVkzdlVwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikd5cHN5IC0gMjAxNiBSZW1hc3RlciIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYQ==", + "Y2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVKMGFORVVUeEpXS1huUW15WTN2VXAifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzI5NjJlWWtRYTBSN0VuSUdacWVBUlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yOTYyZVlrUWEwUjdFbklHWnFlQVJTIiwiaWQiOiIyOTYyZVlrUWEwUjdFbklHWnFlQVJTIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2IxNzUxYWMxOGIyNTk2YzFjODcwNjExZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiMTc1MWFjMThiMjU5NmMxYzg3MDYxMWYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWIxNzUxYWMxOGIyNTk2YzFjODcwNjExZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNaXJhZ2UgKDIwMTYgUmVtYXN0ZXIpIiwicmVsZWFzZV9kYXRlIjoiMTk4Mi0wNi0xOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjI5NjJlWWtRYTBSN0VuSUdacWVBUlMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2NzAzMywiZXhwbGljaXQiOmZhbHNlLCJleA==", + "dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDExNjAyMjMxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xQTRhdGNwaE9JOHZ4cmdwMVlKanVmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMUE0YXRjcGhPSTh2eHJncDFZSmp1ZiIsImlkIjoiMUE0YXRjcGhPSTh2eHJncDFZSmp1ZiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHeXBzeSAtIDIwMTYgUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUE0YXRjcGhPSTh2eHJncDFZSmp1ZiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVl6T1VWZExNckl0Z1NQM2xNeFJlSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVZek9VVmRMTXJJdGdTUDNsTXhSZUgiLCJpZCI6IjVZek9VVmRMTXJJdGdTUDNsTXhSZUgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMThjMGNiNmJjZDdiZmVjZWUxODkyNDJmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE4YzBjYjZiY2Q3YmZlY2VlMTg5MjQyZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMThjMGNiNmJjZDdiZmVjZWUxODkyNDJmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdyZWF0ZXN0IEhpdHMgKERlbHV4ZSBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjE5ODgtMTEtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1WXpPVVZkTE1ySXRnU1AzbE14UmVIIn0sImFydGlzdHMiOlt7Ig==", + "ZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2MzY5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTV0IyMjYwMDAxMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGRsMDdXa21jOWJvR1BwNTdRWWdMWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRkbDA3V2ttYzlib0dQcDU3UVlnTFoiLCJpZCI6IjRkbDA3V2ttYzlib0dQcDU3UVlnTFoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3lwc3kiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGRsMDdXa21jOWJvR1BwNTdRWWdMWiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMDZKcU9rd3d5OTFPeHJBcFhjbHpZZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzA2SnFPa3d3eTkxT3hyQXBYY2x6WWYiLCJpZCI6IjA2SnFPa3d3eTkxT3hyQXBYY2x6WWYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDcwYTU3YzJkYzg3MTAxNzFkNDc4M2RmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQ3MGE1N2MyZGM4NzEwMTcxZDQ3ODNkZiJ9LA==", + "eyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0NzBhNTdjMmRjODcxMDE3MWQ0NzgzZGYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiNTAgWWVhcnMgLSBEb24ndCBTdG9wIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0xMS0xNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjA2SnFPa3d3eTkxT3hyQXBYY2x6WWYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2Mzg2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMTgwMjU5MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNW5UbkFwRDZ6TnZ1SEplMGZYVTVKZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVuVG5BcEQ2ek52dUhKZTBmWFU1SmciLCJpZCI6IjVuVG5BcEQ2ek52dUhKZTBmWFU1SmciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3lwc3kgLSAyMDE4IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1blRuQXBENnpOdnVISmUwZlhVNUpnIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83QTBkZWZOWUNsemZRSA==", + "VjhpZk9CdjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83QTBkZWZOWUNsemZRSFY4aWZPQnYwIiwiaWQiOiI3QTBkZWZOWUNsemZRSFY4aWZPQnYwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzUzZGQyZDIyNjQ4ODVlMTZiMzMxNTUxNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1M2RkMmQyMjY0ODg1ZTE2YjMzMTU1MTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTUzZGQyZDIyNjQ4ODVlMTZiMzMxNTUxNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgVmVyeSBCZXN0IE9mIEZsZWV0d29vZCBNYWMiLCJyZWxlYXNlX2RhdGUiOiIyMDAyLTEwLTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0EwZGVmTllDbHpmUUhWOGlmT0J2MCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MjYyODY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNXQjEwMjAyNjIxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82ZlNCMmEzMnMzNEptWWt4NzI1TkE3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmZTQjJhMzJzMzRKbVlreDcyNU5BNyIsImlkIjoiNmZTQjJhMzJzMzRKbVlreDcyNU5BNyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHeXBzeSAtIDIwMDIgUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NmZTQjJhMzJzMzRKbVlreDcyNU5BNyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6ew==", + "InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRHRjdFdENrbDRPNzNrcE5janJPaDUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80R0Y3RXRDa2w0Tzcza3BOY2pyT2g1IiwiaWQiOiI0R0Y3RXRDa2w0Tzcza3BOY2pyT2g1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzhjYWE3MjBhYzViYTdjM2I5YjA1NzFlMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4Y2FhNzIwYWM1YmE3YzNiOWIwNTcxZTAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MThjYWE3MjBhYzViYTdjM2I5YjA1NzFlMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDaGlsbCBUcmFja3MgLSA4MHMgJiA5MHMiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTEwLTA5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEdGN0V0Q2tsNE83M2twTmNqck9oNSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjYzODY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDExODAyNTkxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82ODhyT2xZczJXWg==", + "d0hwVHpPTUdCbjcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82ODhyT2xZczJXWndIcFR6T01HQm43IiwiaWQiOiI2ODhyT2xZczJXWndIcFR6T01HQm43IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikd5cHN5IC0gMjAxOCBSZW1hc3RlciIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2ODhyT2xZczJXWndIcFR6T01HQm43In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Gypsy%22+artist%3A%22Fleetwood+Mac%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Your%20Song%22%20artist%3A%22Elton%20John%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":5,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3PhoLpVuITZKcymswpck5b"},"href":"https://api.spotify.com/v1/artists/3PhoLpVuITZKcymswpck5b","id":"3PhoLpVuITZKcymswpck5b","name":"Elton John","type":"artist","uri":"spotify:artist:3PhoLpVuITZKcymswpck5b"}],"external_urls":{"spotify":"https://open.spotify.com/album/69P9Ro0W286yLFgYwrGVN0"},"href":"https://api.spotify.com/v1/albums/69P9Ro0W286yLFgYwrGVN0","id":"69P9Ro0W286yLFgYwrGVN0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734b292ed7c7360a04d3d6b74a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024b292ed7c7360a04d3d6b74a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514b292ed7c7360a04d3d6b74a"}],"is_playable":true,"name":"Elton John","release_date":"1970-04-10","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:69P9Ro0W286yLFgYwrGVN0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3PhoLpVuITZKcymswpck5b"},"href":"https://api.spotify.com/v1/artists/3PhoLpVuITZKcymswpck5b","id":"3PhoLpVuITZKcymswpck5b","name":"Elton John","type":"artist","uri":"spotify:artist:3PhoLpVuITZKcymswpck5b"}],"disc_number":1,"duration_ms":241786,"explicit":false,"external_ids":{"isrc":"GBAMB9500072"},"external_urls":{"spotify":"https://open.spotify.com/track/38zsOOcu31XbbYj9BIPUF1"},"href":"https://api.spotify.com/v1/tracks/38zsOOcu31XbbYj9BIPUF1","id":"38zsOOcu31XbbYj9BIPUF1","is_local":false,"is_playable":true,"name":"Your Song","track_number":1,"type":"track","uri":"spotify:track:38zsOOcu31XbbYj9BIPUF1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2H6DPjcMaPbCZzxINySIQD"},"href":"https://api.spotify.com/v1/albums/2H6DPjcMaPbCZzxINySIQD","id":"2H6DPjcMaPbCZzxINySIQD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bb01568108f9156dbfe59684"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bb01568108f9156dbfe59684"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bb01568108f9156dbfe59684"}],"is_playable":true,"name":"Het Beste Uit De Top 2000 (Editie 2017)","release_date":"2017-11-17","release_date_precision":"day","total_tracks":36,"type":"album","uri":"spotify:album:2H6DPjcMaPbCZzxINySIQD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3PhoLpVuITZKcymswpck5b"},"href":"https://api.spotify.com/v1/artists/3PhoLpVuITZKcymswpck5b","id":"3PhoLpVuITZKcymswpck5b","name":"Elton John","type":"artist","uri":"spotify:artist:3PhoLpVuITZKcymswpck5b"}],"disc_number":1,"duration_ms":241600,"explicit":false,"external_ids":{"isrc":"GBAMB9500072"},"external_urls":{"spotify":"https://open.spotify.com/track/4S0nYZi2iGg724TiO8Yrsa"},"href":"https://api.spotify.com/v1/tracks/4S0nYZi2iGg724TiO8Yrsa","id":"4S0nYZi2iGg724TiO8Yrsa","is_local":false,"is_playable":true,"name":"Your Song","track_number":8,"type":"track","uri":"spotify:track:4S0nYZi2iGg724TiO8Yrsa"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3PhoLpVuITZKcymswpck5b"},"href":"https://api.spotify.com/v1/artists/3PhoLpVuITZKcymswpck5b","id":"3PhoLpVuITZKcymswpck5b","name":"Elton John","type":"artist","uri":"spotify:artist:3PhoLpVuITZKcymswpck5b"}],"external_urls":{"spotify":"https://open.spotify.com/album/0C2grVR8DnJnL8rg7OP6Zm"},"href":"https://api.spotify.com/v1/albums/0C2grVR8DnJnL8rg7OP6Zm","id":"0C2grVR8DnJnL8rg7OP6Zm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c05ee7800dca138ffb6274ff"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c05ee7800dca138ffb6274ff"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c05ee7800dca138ffb6274ff"}],"is_playable":true,"name":"Elton John","release_date":"1970-04-10","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:0C2grVR8DnJnL8rg7OP6Zm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3PhoLpVuITZKcymswpck5b"},"href":"https://api.spotify.com/v1/artists/3PhoLpVuITZKcymswpck5b","id":"3PhoLpVuITZKcymswpck5b","name":"Elton John","type":"artist","uri":"spotify:artist:3PhoLpVuITZKcymswpck5b"}],"disc_number":1,"duration_ms":244226,"explicit":false,"external_ids":{"isrc":"GBAMB9500072"},"external_urls":{"spotify":"https://open.spotify.com/track/7gCeodIXjhCLDWC5H1LOmT"},"href":"https://api.spotify.com/v1/tracks/7gCeodIXjhCLDWC5H1LOmT","id":"7gCeodIXjhCLDWC5H1LOmT","is_local":false,"is_playable":true,"name":"Your Song","track_number":1,"type":"track","uri":"spotify:track:7gCeodIXjhCLDWC5H1LOmT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3PhoLpVuITZKcymswpck5b"},"href":"https://api.spotify.com/v1/artists/3PhoLpVuITZKcymswpck5b","id":"3PhoLpVuITZKcymswpck5b","name":"Elton John","type":"artist","uri":"spotify:artist:3PhoLpVuITZKcymswpck5b"}],"external_urls":{"spotify":"https://open.spotify.com/album/7iKDBfOFUtg8E8RbuDhiux"},"href":"https://api.spotify.com/v1/albums/7iKDBfOFUtg8E8RbuDhiux","id":"7iKDBfOFUtg8E8RbuDhiux","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27310a2dbd14d14e7495e7bf7e5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0210a2dbd14d14e7495e7bf7e5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485110a2dbd14d14e7495e7bf7e5"}],"is_playable":true,"name":"To Be Continued...","release_date":"1990-11-08","release_date_precision":"day","total_tracks":67,"type":"album","uri":"spotify:album:7iKDBfOFUtg8E8RbuDhiux"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3PhoLpVuITZKcymswpck5b"},"href":"https://api.spotify.com/v1/artists/3PhoLpVuITZKcymswpck5b","id":"3PhoLpVuITZKcymswpck5b","name":"Elton John","type":"artist","uri":"spotify:artist:3PhoLpVuITZKcymswpck5b"}],"disc_number":1,"duration_ms":240800,"explicit":false,"external_ids":{"isrc":"GBAMB9500072"},"external_urls":{"spotify":"https://open.spotify.com/track/747fyAuUDG3feXRd6pILnx"},"href":"https://api.spotify.com/v1/tracks/747fyAuUDG3feXRd6pILnx","id":"747fyAuUDG3feXRd6pILnx","is_local":false,"is_playable":true,"name":"Your Song","track_number":7,"type":"track","uri":"spotify:track:747fyAuUDG3feXRd6pILnx"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3PhoLpVuITZKcymswpck5b"},"href":"https://api.spotify.com/v1/artists/3PhoLpVuITZKcymswpck5b","id":"3PhoLpVuITZKcymswpck5b","name":"Elton John","type":"artist","uri":"spotify:artist:3PhoLpVuITZKcymswpck5b"}],"external_urls":{"spotify":"https://open.spotify.com/album/1hBowxbDuRdbm5NouddGgq"},"href":"https://api.spotify.com/v1/albums/1hBowxbDuRdbm5NouddGgq","id":"1hBowxbDuRdbm5NouddGgq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736a6f89f35e04efc652b5df01"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026a6f89f35e04efc652b5df01"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516a6f89f35e04efc652b5df01"}],"is_playable":true,"name":"Songs From The West Coast (Expanded Edition)","release_date":"2001-10-01","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:1hBowxbDuRdbm5NouddGgq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3PhoLpVuITZKcymswpck5b"},"href":"https://api.spotify.com/v1/artists/3PhoLpVuITZKcymswpck5b","id":"3PhoLpVuITZKcymswpck5b","name":"Elton John","type":"artist","uri":"spotify:artist:3PhoLpVuITZKcymswpck5b"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5ITJs06INM9JWxK5hROEj3"},"href":"https://api.spotify.com/v1/artists/5ITJs06INM9JWxK5hROEj3","id":"5ITJs06INM9JWxK5hROEj3","name":"Alessandro Safina","type":"artist","uri":"spotify:artist:5ITJs06INM9JWxK5hROEj3"}],"disc_number":2,"duration_ms":261093,"explicit":false,"external_ids":{"isrc":"GBF080201127"},"external_urls":{"spotify":"https://open.spotify.com/track/27WrXmQPPyRYySuPoBgCbG"},"href":"https://api.spotify.com/v1/tracks/27WrXmQPPyRYySuPoBgCbG","id":"27WrXmQPPyRYySuPoBgCbG","is_local":false,"is_playable":true,"name":"Your Song","track_number":1,"type":"track","uri":"spotify:track:27WrXmQPPyRYySuPoBgCbG"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMllvdXIlMjBTb25nJTIyJTIwYXJ0aXN0JTNBJTIyRWx0b24lMjBKb2huJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo1LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zUGhvTHBWdUlUWktjeW1zd3BjazViIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJpZCI6IjNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJuYW1lIjoiRWx0b24gSm9obiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozUGhvTHBWdUlUWktjeW1zd3BjazViIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNjlQOVJvMFcyODZ5TEZnWXdyR1ZOMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzY5UDlSbzBXMjg2eUxGZ1l3ckdWTjAiLCJpZCI6IjY5UDlSbzBXMjg2eUxGZ1l3ckdWTjAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbQ==", + "YWdlL2FiNjc2MTZkMDAwMGIyNzM0YjI5MmVkN2M3MzYwYTA0ZDNkNmI3NGEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNGIyOTJlZDdjNzM2MGEwNGQzZDZiNzRhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0YjI5MmVkN2M3MzYwYTA0ZDNkNmI3NGEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRWx0b24gSm9obiIsInJlbGVhc2VfZGF0ZSI6IjE5NzAtMDQtMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2OVA5Um8wVzI4NnlMRmdZd3JHVk4wIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1Bob0xwVnVJVFpLY3ltc3dwY2s1YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zUGhvTHBWdUlUWktjeW1zd3BjazViIiwiaWQiOiIzUGhvTHBWdUlUWktjeW1zd3BjazViIiwibmFtZSI6IkVsdG9uIEpvaG4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1Bob0xwVnVJVFpLY3ltc3dwY2s1YiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDE3ODYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFNQjk1MDAwNzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzM4enNPT2N1MzFYYmJZajlCSVBVRjEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zOHpzT09jdTMxWGJiWWo5QklQVUYxIiwiaWQiOiIzOHpzT09jdTMxWGJiWWo5QklQVUYxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IllvdXIgU29uZyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozOHpzT09jdTMxWGJiWWo5QklQVUYxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0Ig==", + "LCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkg2RFBqY01hUGJDWnp4SU55U0lRRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJINkRQamNNYVBiQ1p6eElOeVNJUUQiLCJpZCI6IjJINkRQamNNYVBiQ1p6eElOeVNJUUQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYmIwMTU2ODEwOGY5MTU2ZGJmZTU5Njg0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJiMDE1NjgxMDhmOTE1NmRiZmU1OTY4NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYmIwMTU2ODEwOGY5MTU2ZGJmZTU5Njg0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhldCBCZXN0ZSBVaXQgRGUgVG9wIDIwMDAgKEVkaXRpZSAyMDE3KSIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMTEtMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToySDZEUGpjTWFQYkNaenhJTnlTSVFEIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1Bob0xwVnVJVFpLY3ltc3dwY2s1YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zUGhvTHBWdUlUWktjeW1zd3BjazViIiwiaWQiOiIzUGhvTHBWdUlUWktjeW1zd3BjazViIiwibmFtZSI6IkVsdG9uIEpvaG4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1Bob0xwVnVJVFpLY3ltc3dwY2s1YiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDE2MDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFNQjk1MDAwNzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRTMG5ZWmkyaUdnNzI0VGlPOFlyc2EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80UzBuWVppMmlHZzcyNFRpTzhZcnNhIiwiaWQiOiI0UzBuWVppMmlHZzcyNFRpTzhZcnNhIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IllvdXIgU29uZyIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYQ==", + "Y2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRTMG5ZWmkyaUdnNzI0VGlPOFlyc2EifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1Bob0xwVnVJVFpLY3ltc3dwY2s1YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zUGhvTHBWdUlUWktjeW1zd3BjazViIiwiaWQiOiIzUGhvTHBWdUlUWktjeW1zd3BjazViIiwibmFtZSI6IkVsdG9uIEpvaG4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1Bob0xwVnVJVFpLY3ltc3dwY2s1YiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBDMmdyVlI4RG5Kbkw4cmc3T1A2Wm0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wQzJnclZSOERuSm5MOHJnN09QNlptIiwiaWQiOiIwQzJnclZSOERuSm5MOHJnN09QNlptIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2MwNWVlNzgwMGRjYTEzOGZmYjYyNzRmZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjMDVlZTc4MDBkY2ExMzhmZmI2Mjc0ZmYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWMwNWVlNzgwMGRjYTEzOGZmYjYyNzRmZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJFbHRvbiBKb2huIiwicmVsZWFzZV9kYXRlIjoiMTk3MC0wNC0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBDMmdyVlI4RG5Kbkw4cmc3T1A2Wm0ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zUGhvTHBWdUlUWktjeW1zd3BjazViIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJpZCI6IjNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJuYW1lIjoiRWx0b24gSm9obiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozUGhvTHBWdUlUWktjeW1zd3BjazViIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NDIyNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYw==", + "IjoiR0JBTUI5NTAwMDcyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83Z0Nlb2RJWGpoQ0xEV0M1SDFMT21UIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2dDZW9kSVhqaENMRFdDNUgxTE9tVCIsImlkIjoiN2dDZW9kSVhqaENMRFdDNUgxTE9tVCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJZb3VyIFNvbmciLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2dDZW9kSVhqaENMRFdDNUgxTE9tVCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zUGhvTHBWdUlUWktjeW1zd3BjazViIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJpZCI6IjNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJuYW1lIjoiRWx0b24gSm9obiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozUGhvTHBWdUlUWktjeW1zd3BjazViIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN2lLREJmT0ZVdGc4RThSYnVEaGl1eCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdpS0RCZk9GVXRnOEU4UmJ1RGhpdXgiLCJpZCI6IjdpS0RCZk9GVXRnOEU4UmJ1RGhpdXgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMTBhMmRiZDE0ZDE0ZTc0OTVlN2JmN2U1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjEwYTJkYmQxNGQxNGU3NDk1ZTdiZjdlNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTBhMmRiZDE0ZDE0ZTc0OTVlN2JmN2U1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvIEJlIENvbnRpbnVlZC4uLiIsInJlbGVhc2VfZGF0ZSI6IjE5OTAtMTEtMDgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3aUtEQmZPRlV0ZzhFOFJidURoaXV4In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aQ==", + "ZnkuY29tL2FydGlzdC8zUGhvTHBWdUlUWktjeW1zd3BjazViIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJpZCI6IjNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJuYW1lIjoiRWx0b24gSm9obiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozUGhvTHBWdUlUWktjeW1zd3BjazViIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDgwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQU1COTUwMDA3MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNzQ3ZnlBdVVERzNmZVhSZDZwSUxueCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzc0N2Z5QXVVREczZmVYUmQ2cElMbngiLCJpZCI6Ijc0N2Z5QXVVREczZmVYUmQ2cElMbngiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWW91ciBTb25nIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjc0N2Z5QXVVREczZmVYUmQ2cElMbngifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1Bob0xwVnVJVFpLY3ltc3dwY2s1YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zUGhvTHBWdUlUWktjeW1zd3BjazViIiwiaWQiOiIzUGhvTHBWdUlUWktjeW1zd3BjazViIiwibmFtZSI6IkVsdG9uIEpvaG4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1Bob0xwVnVJVFpLY3ltc3dwY2s1YiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFoQm93eGJEdVJkYm01Tm91ZGRHZ3EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xaEJvd3hiRHVSZGJtNU5vdWRkR2dxIiwiaWQiOiIxaEJvd3hiRHVSZGJtNU5vdWRkR2dxIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZhNmY4OWYzNWUwNGVmYzY1MmI1ZGYwMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2YTZmODlmMzVlMDRlZmM2NTJiNWRmMDEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZw==", + "ZS9hYjY3NjE2ZDAwMDA0ODUxNmE2Zjg5ZjM1ZTA0ZWZjNjUyYjVkZjAxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvbmdzIEZyb20gVGhlIFdlc3QgQ29hc3QgKEV4cGFuZGVkIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAwMS0xMC0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFoQm93eGJEdVJkYm01Tm91ZGRHZ3EifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zUGhvTHBWdUlUWktjeW1zd3BjazViIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJpZCI6IjNQaG9McFZ1SVRaS2N5bXN3cGNrNWIiLCJuYW1lIjoiRWx0b24gSm9obiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozUGhvTHBWdUlUWktjeW1zd3BjazViIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVJVEpzMDZJTk05Sld4SzVoUk9FajMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUlUSnMwNklOTTlKV3hLNWhST0VqMyIsImlkIjoiNUlUSnMwNklOTTlKV3hLNWhST0VqMyIsIm5hbWUiOiJBbGVzc2FuZHJvIFNhZmluYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1SVRKczA2SU5NOUpXeEs1aFJPRWozIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjI2MTA5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCRjA4MDIwMTEyNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMjdXclhtUVBQeVJZeVN1UG9CZ0NiRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzI3V3JYbVFQUHlSWXlTdVBvQmdDYkciLCJpZCI6IjI3V3JYbVFQUHlSWXlTdVBvQmdDYkciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWW91ciBTb25nIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjI3V3JYbVFQUHlSWXlTdVBvQmdDYkcifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Your+Song%22+artist%3A%22Elton+John%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Rich%20Girl%22%20artist%3A%22Daryl%20Hall%20%26%20John%20Oates%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"external_urls":{"spotify":"https://open.spotify.com/album/5TNzBp7QYsXIHrI5xxVuic"},"href":"https://api.spotify.com/v1/albums/5TNzBp7QYsXIHrI5xxVuic","id":"5TNzBp7QYsXIHrI5xxVuic","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733ebc5b9d8942069d3b920550"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023ebc5b9d8942069d3b920550"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513ebc5b9d8942069d3b920550"}],"is_playable":true,"name":"Bigger Than Both Of Us","release_date":"1976-08-01","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:5TNzBp7QYsXIHrI5xxVuic"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":1,"duration_ms":142786,"explicit":false,"external_ids":{"isrc":"USRC17607760"},"external_urls":{"spotify":"https://open.spotify.com/track/0qRR9d89hIS0MHRkQ0ejxX"},"href":"https://api.spotify.com/v1/tracks/0qRR9d89hIS0MHRkQ0ejxX","id":"0qRR9d89hIS0MHRkQ0ejxX","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":2,"type":"track","uri":"spotify:track:0qRR9d89hIS0MHRkQ0ejxX"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"external_urls":{"spotify":"https://open.spotify.com/album/0gCDvloPR42pZRZhmbGYVI"},"href":"https://api.spotify.com/v1/albums/0gCDvloPR42pZRZhmbGYVI","id":"0gCDvloPR42pZRZhmbGYVI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e49b4b79f376c0bc6e0c079b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e49b4b79f376c0bc6e0c079b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e49b4b79f376c0bc6e0c079b"}],"is_playable":true,"name":"The Essential Daryl Hall & John Oates","release_date":"2005-04-25","release_date_precision":"day","total_tracks":37,"type":"album","uri":"spotify:album:0gCDvloPR42pZRZhmbGYVI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":1,"duration_ms":144333,"explicit":false,"external_ids":{"isrc":"USRC10301815"},"external_urls":{"spotify":"https://open.spotify.com/track/5E3P9e1hvjyIOlFyqNB5eD"},"href":"https://api.spotify.com/v1/tracks/5E3P9e1hvjyIOlFyqNB5eD","id":"5E3P9e1hvjyIOlFyqNB5eD","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":7,"type":"track","uri":"spotify:track:5E3P9e1hvjyIOlFyqNB5eD"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"external_urls":{"spotify":"https://open.spotify.com/album/4tUyNf5dGXwY4TaMaxwhqF"},"href":"https://api.spotify.com/v1/albums/4tUyNf5dGXwY4TaMaxwhqF","id":"4tUyNf5dGXwY4TaMaxwhqF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f43547de689aabc4c44ab62d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f43547de689aabc4c44ab62d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f43547de689aabc4c44ab62d"}],"is_playable":true,"name":"The Very Best of Daryl Hall / John Oates","release_date":"2001-01-23","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:4tUyNf5dGXwY4TaMaxwhqF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":1,"duration_ms":144973,"explicit":false,"external_ids":{"isrc":"USRC10000821"},"external_urls":{"spotify":"https://open.spotify.com/track/6OkzvCIvK69VDFHq1G2jhN"},"href":"https://api.spotify.com/v1/tracks/6OkzvCIvK69VDFHq1G2jhN","id":"6OkzvCIvK69VDFHq1G2jhN","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":2,"type":"track","uri":"spotify:track:6OkzvCIvK69VDFHq1G2jhN"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"external_urls":{"spotify":"https://open.spotify.com/album/59SwH7Ez6Gztywrcnvmx6n"},"href":"https://api.spotify.com/v1/albums/59SwH7Ez6Gztywrcnvmx6n","id":"59SwH7Ez6Gztywrcnvmx6n","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733dd7d442806684ef3fc84b3f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023dd7d442806684ef3fc84b3f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513dd7d442806684ef3fc84b3f"}],"is_playable":true,"name":"Rock 'N Soul, Part 1 (Expanded Edition)","release_date":"1983","release_date_precision":"year","total_tracks":14,"type":"album","uri":"spotify:album:59SwH7Ez6Gztywrcnvmx6n"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":1,"duration_ms":144973,"explicit":false,"external_ids":{"isrc":"USRC17607760"},"external_urls":{"spotify":"https://open.spotify.com/track/5Gq5Ozgqqti42kNLVRfkRt"},"href":"https://api.spotify.com/v1/tracks/5Gq5Ozgqqti42kNLVRfkRt","id":"5Gq5Ozgqqti42kNLVRfkRt","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":4,"type":"track","uri":"spotify:track:5Gq5Ozgqqti42kNLVRfkRt"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"external_urls":{"spotify":"https://open.spotify.com/album/4JfdjLnYXZE050vPPj6FLU"},"href":"https://api.spotify.com/v1/albums/4JfdjLnYXZE050vPPj6FLU","id":"4JfdjLnYXZE050vPPj6FLU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27356ce6584f5f6e58b2237f5d9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0256ce6584f5f6e58b2237f5d9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485156ce6584f5f6e58b2237f5d9"}],"is_playable":true,"name":"The Very Best of Daryl Hall / John Oates","release_date":"2009-02-20","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:4JfdjLnYXZE050vPPj6FLU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":1,"duration_ms":144973,"explicit":false,"external_ids":{"isrc":"USRC10000821"},"external_urls":{"spotify":"https://open.spotify.com/track/0IkhaH9jifEX19uwDHk5h6"},"href":"https://api.spotify.com/v1/tracks/0IkhaH9jifEX19uwDHk5h6","id":"0IkhaH9jifEX19uwDHk5h6","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":2,"type":"track","uri":"spotify:track:0IkhaH9jifEX19uwDHk5h6"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1k7WkNHGPNPnri2tsowvtg"},"href":"https://api.spotify.com/v1/albums/1k7WkNHGPNPnri2tsowvtg","id":"1k7WkNHGPNPnri2tsowvtg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273871ab8561721e8967eda8269"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02871ab8561721e8967eda8269"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851871ab8561721e8967eda8269"}],"is_playable":true,"name":"70s 100 Hits","release_date":"2010-03-01","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:1k7WkNHGPNPnri2tsowvtg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":1,"duration_ms":143933,"explicit":false,"external_ids":{"isrc":"USRC19206280"},"external_urls":{"spotify":"https://open.spotify.com/track/3IMwTeQ15AjQpNi2IcF5jk"},"href":"https://api.spotify.com/v1/tracks/3IMwTeQ15AjQpNi2IcF5jk","id":"3IMwTeQ15AjQpNi2IcF5jk","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":24,"type":"track","uri":"spotify:track:3IMwTeQ15AjQpNi2IcF5jk"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Qk6OnOuvXwdDHLO6koIHQ"},"href":"https://api.spotify.com/v1/albums/6Qk6OnOuvXwdDHLO6koIHQ","id":"6Qk6OnOuvXwdDHLO6koIHQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732e3a2ad092091f6b8e792f56"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022e3a2ad092091f6b8e792f56"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512e3a2ad092091f6b8e792f56"}],"is_playable":true,"name":"Hall & Oates","release_date":"2006-05-15","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6Qk6OnOuvXwdDHLO6koIHQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":2,"duration_ms":142813,"explicit":false,"external_ids":{"isrc":"USRC17607760"},"external_urls":{"spotify":"https://open.spotify.com/track/3w08Pz5tzMyzRg8IyDgEtf"},"href":"https://api.spotify.com/v1/tracks/3w08Pz5tzMyzRg8IyDgEtf","id":"3w08Pz5tzMyzRg8IyDgEtf","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":4,"type":"track","uri":"spotify:track:3w08Pz5tzMyzRg8IyDgEtf"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"external_urls":{"spotify":"https://open.spotify.com/album/3LjCh3GXg9r9h4HORAUzXu"},"href":"https://api.spotify.com/v1/albums/3LjCh3GXg9r9h4HORAUzXu","id":"3LjCh3GXg9r9h4HORAUzXu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730320feb23e4090969b931fac"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020320feb23e4090969b931fac"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510320feb23e4090969b931fac"}],"is_playable":true,"name":"The Very Best Of","release_date":"2001-01-18","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:3LjCh3GXg9r9h4HORAUzXu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":1,"duration_ms":144866,"explicit":false,"external_ids":{"isrc":"USRC17607760"},"external_urls":{"spotify":"https://open.spotify.com/track/7J3B4iB1ScrQFewCmoagh7"},"href":"https://api.spotify.com/v1/tracks/7J3B4iB1ScrQFewCmoagh7","id":"7J3B4iB1ScrQFewCmoagh7","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":2,"type":"track","uri":"spotify:track:7J3B4iB1ScrQFewCmoagh7"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Q3XVKlwLGTcGVzR6bifaT"},"href":"https://api.spotify.com/v1/albums/6Q3XVKlwLGTcGVzR6bifaT","id":"6Q3XVKlwLGTcGVzR6bifaT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731476645ebb8a153ad9b31e16"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021476645ebb8a153ad9b31e16"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511476645ebb8a153ad9b31e16"}],"is_playable":true,"name":"The Ultimate Collection","release_date":"2014-08-01","release_date_precision":"day","total_tracks":49,"type":"album","uri":"spotify:album:6Q3XVKlwLGTcGVzR6bifaT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":1,"duration_ms":143760,"explicit":false,"external_ids":{"isrc":"USRC10301815"},"external_urls":{"spotify":"https://open.spotify.com/track/3CfjHEwjrJ9JxAbpvBJBmW"},"href":"https://api.spotify.com/v1/tracks/3CfjHEwjrJ9JxAbpvBJBmW","id":"3CfjHEwjrJ9JxAbpvBJBmW","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":3,"type":"track","uri":"spotify:track:3CfjHEwjrJ9JxAbpvBJBmW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"external_urls":{"spotify":"https://open.spotify.com/album/4MNKekfM3koGEGUl73w0ja"},"href":"https://api.spotify.com/v1/albums/4MNKekfM3koGEGUl73w0ja","id":"4MNKekfM3koGEGUl73w0ja","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27371b4c45552ad6fe7e91f10ef"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0271b4c45552ad6fe7e91f10ef"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485171b4c45552ad6fe7e91f10ef"}],"is_playable":true,"name":"Greatest Hits--Rock 'n' Soul, Part 1","release_date":"1983","release_date_precision":"year","total_tracks":12,"type":"album","uri":"spotify:album:4MNKekfM3koGEGUl73w0ja"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77tT1kLj6mCWtFNqiOmP9H"},"href":"https://api.spotify.com/v1/artists/77tT1kLj6mCWtFNqiOmP9H","id":"77tT1kLj6mCWtFNqiOmP9H","name":"Daryl Hall & John Oates","type":"artist","uri":"spotify:artist:77tT1kLj6mCWtFNqiOmP9H"}],"disc_number":1,"duration_ms":146666,"explicit":false,"external_ids":{"isrc":"USRC17607760"},"external_urls":{"spotify":"https://open.spotify.com/track/3xXsq3yGH6qt4B0wtkJC8O"},"href":"https://api.spotify.com/v1/tracks/3xXsq3yGH6qt4B0wtkJC8O","id":"3xXsq3yGH6qt4B0wtkJC8O","is_local":false,"is_playable":true,"name":"Rich Girl","track_number":4,"type":"track","uri":"spotify:track:3xXsq3yGH6qt4B0wtkJC8O"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJpY2glMjBHaXJsJTIyJTIwYXJ0aXN0JTNBJTIyRGFyeWwlMjBIYWxsJTIwJTI2JTIwSm9obiUyME9hdGVzJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJpZCI6Ijc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJuYW1lIjoiRGFyeWwgSGFsbCAmIEpvaG4gT2F0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVUTnpCcDdRWXNYSUhySTV4eFZ1aWMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81VE56QnA3UVlzWElIckk1eHhWdWljIiwiaWQiOiI1VE56QnA3UVlzWElIckk1eHhWdWljIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lk", + "dGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzNlYmM1YjlkODk0MjA2OWQzYjkyMDU1MCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzZWJjNWI5ZDg5NDIwNjlkM2I5MjA1NTAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTNlYmM1YjlkODk0MjA2OWQzYjkyMDU1MCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCaWdnZXIgVGhhbiBCb3RoIE9mIFVzIiwicmVsZWFzZV9kYXRlIjoiMTk3Ni0wOC0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVROekJwN1FZc1hJSHJJNXh4VnVpYyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3dFQxa0xqNm1DV3RGTnFpT21QOUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsImlkIjoiNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsIm5hbWUiOiJEYXJ5bCBIYWxsICYgSm9obiBPYXRlcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0Mjc4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkMxNzYwNzc2MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHFSUjlkODloSVMwTUhSa1EwZWp4WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBxUlI5ZDg5aElTME1IUmtRMGVqeFgiLCJpZCI6IjBxUlI5ZDg5aElTME1IUmtRMGVqeFgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmljaCBHaXJsIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBxUlI5ZDg5aElTME1IUmtRMGVqeFgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwiaWQiOiI3N3RUMQ==", + "a0xqNm1DV3RGTnFpT21QOUgiLCJuYW1lIjoiRGFyeWwgSGFsbCAmIEpvaG4gT2F0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBnQ0R2bG9QUjQycFpSWmhtYkdZVkkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wZ0NEdmxvUFI0MnBaUlpobWJHWVZJIiwiaWQiOiIwZ0NEdmxvUFI0MnBaUlpobWJHWVZJIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2U0OWI0Yjc5ZjM3NmMwYmM2ZTBjMDc5YiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlNDliNGI3OWYzNzZjMGJjNmUwYzA3OWIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWU0OWI0Yjc5ZjM3NmMwYmM2ZTBjMDc5YiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgRXNzZW50aWFsIERhcnlsIEhhbGwgJiBKb2huIE9hdGVzIiwicmVsZWFzZV9kYXRlIjoiMjAwNS0wNC0yNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBnQ0R2bG9QUjQycFpSWmhtYkdZVkkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJpZCI6Ijc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJuYW1lIjoiRGFyeWwgSGFsbCAmIEpvaG4gT2F0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDQzMzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JDMTAzMDE4MTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVFM1A5ZTFodmp5SU9sRnlxTkI1ZUQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81RTNQOWUxaHZqeUlPbEZ5cU5CNWVEIiwiaWQiOiI1RTNQOWUxaHZqeUlPbEZ5cU5CNWVEIiwiaXNfbA==", + "b2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmljaCBHaXJsIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVFM1A5ZTFodmp5SU9sRnlxTkI1ZUQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwiaWQiOiI3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwibmFtZSI6IkRhcnlsIEhhbGwgJiBKb2huIE9hdGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3dFQxa0xqNm1DV3RGTnFpT21QOUgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80dFV5TmY1ZEdYd1k0VGFNYXh3aHFGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHRVeU5mNWRHWHdZNFRhTWF4d2hxRiIsImlkIjoiNHRVeU5mNWRHWHdZNFRhTWF4d2hxRiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmNDM1NDdkZTY4OWFhYmM0YzQ0YWI2MmQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjQzNTQ3ZGU2ODlhYWJjNGM0NGFiNjJkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmNDM1NDdkZTY4OWFhYmM0YzQ0YWI2MmQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIFZlcnkgQmVzdCBvZiBEYXJ5bCBIYWxsIC8gSm9obiBPYXRlcyIsInJlbGVhc2VfZGF0ZSI6IjIwMDEtMDEtMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0dFV5TmY1ZEdYd1k0VGFNYXh3aHFGIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwiaWQiOiI3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwibmFtZSI6IkRhcnlsIEhhbGwgJiBKb2huIE9hdGVzIg==", + "LCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDQ5NzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JDMTAwMDA4MjEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZPa3p2Q0l2SzY5VkRGSHExRzJqaE4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82T2t6dkNJdks2OVZERkhxMUcyamhOIiwiaWQiOiI2T2t6dkNJdks2OVZERkhxMUcyamhOIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJpY2ggR2lybCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2T2t6dkNJdks2OVZERkhxMUcyamhOIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3dFQxa0xqNm1DV3RGTnFpT21QOUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsImlkIjoiNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsIm5hbWUiOiJEYXJ5bCBIYWxsICYgSm9obiBPYXRlcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNTlTd0g3RXo2R3p0eXdyY252bXg2biJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzU5U3dIN0V6Nkd6dHl3cmNudm14Nm4iLCJpZCI6IjU5U3dIN0V6Nkd6dHl3cmNudm14Nm4iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczM2RkN2Q0NDI4MDY2ODRlZjNmYzg0YjNmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjNkZDdkNDQyODA2Njg0ZWYzZmM4NGIzZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxM2RkN2Q0NDI4MDY2ODRlZjNmYzg0YjNmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvY2sgJ04gU291bCwgUGFydCAxIChFeHBhbmRlZCBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjE5ODMiLA==", + "InJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1OVN3SDdFejZHenR5d3JjbnZteDZuIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwiaWQiOiI3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwibmFtZSI6IkRhcnlsIEhhbGwgJiBKb2huIE9hdGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3dFQxa0xqNm1DV3RGTnFpT21QOUgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQ0OTczLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSQzE3NjA3NzYwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81R3E1T3pncXF0aTQya05MVlJma1J0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUdxNU96Z3FxdGk0MmtOTFZSZmtSdCIsImlkIjoiNUdxNU96Z3FxdGk0MmtOTFZSZmtSdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaWNoIEdpcmwiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUdxNU96Z3FxdGk0MmtOTFZSZmtSdCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJpZCI6Ijc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJuYW1lIjoiRGFyeWwgSGFsbCAmIEpvaG4gT2F0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRKZmRqTG5ZWFpFMDUwdlBQajZGTFUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80SmZkakxuWVhaRTA1MHZQUGo2RkxVIiwiaWQiOiI0SmZkakxuWVhaRTA1MHZQUGo2RkxVIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaQ==", + "bWFnZS9hYjY3NjE2ZDAwMDBiMjczNTZjZTY1ODRmNWY2ZTU4YjIyMzdmNWQ5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjU2Y2U2NTg0ZjVmNmU1OGIyMjM3ZjVkOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTZjZTY1ODRmNWY2ZTU4YjIyMzdmNWQ5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBWZXJ5IEJlc3Qgb2YgRGFyeWwgSGFsbCAvIEpvaG4gT2F0ZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDA5LTAyLTIwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEpmZGpMbllYWkUwNTB2UFBqNkZMVSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3dFQxa0xqNm1DV3RGTnFpT21QOUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsImlkIjoiNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsIm5hbWUiOiJEYXJ5bCBIYWxsICYgSm9obiBPYXRlcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0NDk3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkMxMDAwMDgyMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMElraGFIOWppZkVYMTl1d0RIazVoNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBJa2hhSDlqaWZFWDE5dXdESGs1aDYiLCJpZCI6IjBJa2hhSDlqaWZFWDE5dXdESGs1aDYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmljaCBHaXJsIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBJa2hhSDlqaWZFWDE5dXdESGs1aDYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOQ==", + "T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xazdXa05IR1BOUG5yaTJ0c293dnRnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWs3V2tOSEdQTlBucmkydHNvd3Z0ZyIsImlkIjoiMWs3V2tOSEdQTlBucmkydHNvd3Z0ZyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4NzFhYjg1NjE3MjFlODk2N2VkYTgyNjkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODcxYWI4NTYxNzIxZTg5NjdlZGE4MjY5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4NzFhYjg1NjE3MjFlODk2N2VkYTgyNjkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiNzBzIDEwMCBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMjAxMC0wMy0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxazdXa05IR1BOUG5yaTJ0c293dnRnIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwiaWQiOiI3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwibmFtZSI6IkRhcnlsIEhhbGwgJiBKb2huIE9hdGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3dFQxa0xqNm1DV3RGTnFpT21QOUgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQzOTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSQzE5MjA2MjgwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zSU13VGVRMTVBalFwTmkySWNGNWprIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0lNd1RlUTE1QWpRcE5pMkljRjVqayIsImlkIjoiM0lNd1RlUTE1QWpRcE5pMkljRjVqayIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaWNoIEdpcg==", + "bCIsInRyYWNrX251bWJlciI6MjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0lNd1RlUTE1QWpRcE5pMkljRjVqayJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJpZCI6Ijc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJuYW1lIjoiRGFyeWwgSGFsbCAmIEpvaG4gT2F0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZRazZPbk91dlh3ZERITE82a29JSFEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82UWs2T25PdXZYd2RESExPNmtvSUhRIiwiaWQiOiI2UWs2T25PdXZYd2RESExPNmtvSUhRIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzJlM2EyYWQwOTIwOTFmNmI4ZTc5MmY1NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyZTNhMmFkMDkyMDkxZjZiOGU3OTJmNTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJlM2EyYWQwOTIwOTFmNmI4ZTc5MmY1NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIYWxsICYgT2F0ZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTA1LTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlFrNk9uT3V2WHdkREhMTzZrb0lIUSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3dFQxa0xqNm1DV3RGTnFpT21QOUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsImlkIjoiNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsIm5hbWUiOiJEYXJ5bCBIYWxsICYgSm9obiBPYXRlcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn1dLCJkaXNjX251bQ==", + "YmVyIjoyLCJkdXJhdGlvbl9tcyI6MTQyODEzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSQzE3NjA3NzYwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zdzA4UHo1dHpNeXpSZzhJeURnRXRmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM3cwOFB6NXR6TXl6Umc4SXlEZ0V0ZiIsImlkIjoiM3cwOFB6NXR6TXl6Umc4SXlEZ0V0ZiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaWNoIEdpcmwiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M3cwOFB6NXR6TXl6Umc4SXlEZ0V0ZiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJpZCI6Ijc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJuYW1lIjoiRGFyeWwgSGFsbCAmIEpvaG4gT2F0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNMakNoM0dYZzlyOWg0SE9SQVV6WHUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zTGpDaDNHWGc5cjloNEhPUkFVelh1IiwiaWQiOiIzTGpDaDNHWGc5cjloNEhPUkFVelh1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzAzMjBmZWIyM2U0MDkwOTY5YjkzMWZhYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwMzIwZmViMjNlNDA5MDk2OWI5MzFmYWMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAzMjBmZWIyM2U0MDkwOTY5YjkzMWZhYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgVmVyeSBCZXN0IE9mIiwicmVsZWFzZV9kYXRlIjoiMjAwMS0wMS0xOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNMakNoMw==", + "R1hnOXI5aDRIT1JBVXpYdSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3dFQxa0xqNm1DV3RGTnFpT21QOUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsImlkIjoiNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsIm5hbWUiOiJEYXJ5bCBIYWxsICYgSm9obiBPYXRlcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0NDg2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkMxNzYwNzc2MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN0ozQjRpQjFTY3JRRmV3Q21vYWdoNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdKM0I0aUIxU2NyUUZld0Ntb2FnaDciLCJpZCI6IjdKM0I0aUIxU2NyUUZld0Ntb2FnaDciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmljaCBHaXJsIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdKM0I0aUIxU2NyUUZld0Ntb2FnaDcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwiaWQiOiI3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwibmFtZSI6IkRhcnlsIEhhbGwgJiBKb2huIE9hdGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3dFQxa0xqNm1DV3RGTnFpT21QOUgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82UTNYVktsd0xHVGNHVnpSNmJpZmFUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNlEzWFZLbHdMR1RjR1Z6UjZiaWZhVCIsImlkIjoiNlEzWFZLbHdMR1RjR1Z6UjZiaWZhVCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNDc2NjQ1ZWJiOGExNTNhZDliMzFlMTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kucw==", + "Y2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNDc2NjQ1ZWJiOGExNTNhZDliMzFlMTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE0NzY2NDVlYmI4YTE1M2FkOWIzMWUxNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgVWx0aW1hdGUgQ29sbGVjdGlvbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTQtMDgtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2UTNYVktsd0xHVGNHVnpSNmJpZmFUIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwiaWQiOiI3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIiwibmFtZSI6IkRhcnlsIEhhbGwgJiBKb2huIE9hdGVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3dFQxa0xqNm1DV3RGTnFpT21QOUgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTQzNzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSQzEwMzAxODE1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zQ2ZqSEV3anJKOUp4QWJwdkJKQm1XIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0NmakhFd2pySjlKeEFicHZCSkJtVyIsImlkIjoiM0NmakhFd2pySjlKeEFicHZCSkJtVyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaWNoIEdpcmwiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0NmakhFd2pySjlKeEFicHZCSkJtVyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJpZCI6Ijc3dFQxa0xqNm1DV3RGTnFpT21QOUgiLCJuYW1lIjoiRGFyeWwgSGFsbCAmIEpvaG4gT2F0ZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nzd0VDFrTGo2bUNXdEZOcWlPbVA5SCJ9XSwiZXh0ZXJuYQ==", + "bF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNE1OS2VrZk0za29HRUdVbDczdzBqYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRNTktla2ZNM2tvR0VHVWw3M3cwamEiLCJpZCI6IjRNTktla2ZNM2tvR0VHVWw3M3cwamEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzFiNGM0NTU1MmFkNmZlN2U5MWYxMGVmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjcxYjRjNDU1NTJhZDZmZTdlOTFmMTBlZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzFiNGM0NTU1MmFkNmZlN2U5MWYxMGVmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdyZWF0ZXN0IEhpdHMtLVJvY2sgJ24nIFNvdWwsIFBhcnQgMSIsInJlbGVhc2VfZGF0ZSI6IjE5ODMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NE1OS2VrZk0za29HRUdVbDczdzBqYSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3dFQxa0xqNm1DV3RGTnFpT21QOUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsImlkIjoiNzd0VDFrTGo2bUNXdEZOcWlPbVA5SCIsIm5hbWUiOiJEYXJ5bCBIYWxsICYgSm9obiBPYXRlcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N3RUMWtMajZtQ1d0Rk5xaU9tUDlIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE0NjY2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkMxNzYwNzc2MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM3hYc3EzeUdINnF0NEIwd3RrSkM4TyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzN4WHNxM3lHSDZxdDRCMHd0a0pDOE8iLCJpZCI6IjN4WHNxM3lHSDZxdDRCMHd0a0pDOE8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmljaCBHaXJsIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjN4WHNxM3lHSDZxdDRCMHd0a0pDOE8ifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Rich+Girl%22+artist%3A%22Daryl+Hall+%26+John+Oates%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Southern%20Nights%22%20artist%3A%22Glen%20Campbell%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"external_urls":{"spotify":"https://open.spotify.com/album/0R7Uw1tUUbWlV53BGKfjQ4"},"href":"https://api.spotify.com/v1/albums/0R7Uw1tUUbWlV53BGKfjQ4","id":"0R7Uw1tUUbWlV53BGKfjQ4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273461762c15f05e141fe6f3097"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02461762c15f05e141fe6f3097"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851461762c15f05e141fe6f3097"}],"is_playable":true,"name":"Southern Nights","release_date":"1977-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0R7Uw1tUUbWlV53BGKfjQ4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":1,"duration_ms":180026,"explicit":false,"external_ids":{"isrc":"USCN17600069"},"external_urls":{"spotify":"https://open.spotify.com/track/7kv7zBjMtVf0eIJle2VZxn"},"href":"https://api.spotify.com/v1/tracks/7kv7zBjMtVf0eIJle2VZxn","id":"7kv7zBjMtVf0eIJle2VZxn","is_local":false,"is_playable":true,"name":"Southern Nights","track_number":1,"type":"track","uri":"spotify:track:7kv7zBjMtVf0eIJle2VZxn"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"external_urls":{"spotify":"https://open.spotify.com/album/5MrXG5mhgenrHar4S8iQdy"},"href":"https://api.spotify.com/v1/albums/5MrXG5mhgenrHar4S8iQdy","id":"5MrXG5mhgenrHar4S8iQdy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27366aff06c0306e4c356bc99c8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0266aff06c0306e4c356bc99c8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485166aff06c0306e4c356bc99c8"}],"is_playable":true,"name":"Glen Campbell - The Capitol Years 1965 - 1977","release_date":"2011-01-01","release_date_precision":"day","total_tracks":46,"type":"album","uri":"spotify:album:5MrXG5mhgenrHar4S8iQdy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":2,"duration_ms":178640,"explicit":false,"external_ids":{"isrc":"USCN17600069"},"external_urls":{"spotify":"https://open.spotify.com/track/4c68Z9wLdHc36y3CNjwQKM"},"href":"https://api.spotify.com/v1/tracks/4c68Z9wLdHc36y3CNjwQKM","id":"4c68Z9wLdHc36y3CNjwQKM","is_local":false,"is_playable":true,"name":"Southern Nights","track_number":20,"type":"track","uri":"spotify:track:4c68Z9wLdHc36y3CNjwQKM"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"external_urls":{"spotify":"https://open.spotify.com/album/4OQKkIIp50FJvUd69vT0B4"},"href":"https://api.spotify.com/v1/albums/4OQKkIIp50FJvUd69vT0B4","id":"4OQKkIIp50FJvUd69vT0B4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730370021be80b47b8d9a7e3bb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020370021be80b47b8d9a7e3bb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510370021be80b47b8d9a7e3bb"}],"is_playable":true,"name":"Greatest Hits","release_date":"2009-01-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:4OQKkIIp50FJvUd69vT0B4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":1,"duration_ms":179586,"explicit":false,"external_ids":{"isrc":"USCN10802584"},"external_urls":{"spotify":"https://open.spotify.com/track/2sd8p89DvYBzJFWo97knsd"},"href":"https://api.spotify.com/v1/tracks/2sd8p89DvYBzJFWo97knsd","id":"2sd8p89DvYBzJFWo97knsd","is_local":false,"is_playable":true,"name":"Southern Nights","track_number":3,"type":"track","uri":"spotify:track:2sd8p89DvYBzJFWo97knsd"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"external_urls":{"spotify":"https://open.spotify.com/album/32Lf9kBHBFcTxhft0Y5Tid"},"href":"https://api.spotify.com/v1/albums/32Lf9kBHBFcTxhft0Y5Tid","id":"32Lf9kBHBFcTxhft0Y5Tid","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735c185b2aaa0c05b73e3ddd94"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025c185b2aaa0c05b73e3ddd94"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515c185b2aaa0c05b73e3ddd94"}],"is_playable":true,"name":"The Legacy (1961-2017)","release_date":"2019-06-21","release_date_precision":"day","total_tracks":78,"type":"album","uri":"spotify:album:32Lf9kBHBFcTxhft0Y5Tid"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":3,"duration_ms":179266,"explicit":false,"external_ids":{"isrc":"USCN10200414"},"external_urls":{"spotify":"https://open.spotify.com/track/0bcwSYiBUscYrRNaXXvdcB"},"href":"https://api.spotify.com/v1/tracks/0bcwSYiBUscYrRNaXXvdcB","id":"0bcwSYiBUscYrRNaXXvdcB","is_local":false,"is_playable":true,"name":"Southern Nights - Remastered","track_number":5,"type":"track","uri":"spotify:track:0bcwSYiBUscYrRNaXXvdcB"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"external_urls":{"spotify":"https://open.spotify.com/album/5T6EhtTQz2MaLVGj3bVtj3"},"href":"https://api.spotify.com/v1/albums/5T6EhtTQz2MaLVGj3bVtj3","id":"5T6EhtTQz2MaLVGj3bVtj3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e1bc92612665775f3e747c6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e1bc92612665775f3e747c6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e1bc92612665775f3e747c6"}],"is_playable":true,"name":"Rhinestone Cowboy","release_date":"2026-06-26","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:5T6EhtTQz2MaLVGj3bVtj3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":1,"duration_ms":177586,"explicit":false,"external_ids":{"isrc":"USCN17600069"},"external_urls":{"spotify":"https://open.spotify.com/track/3N0ugfazz5ZxXKsIAVzK7F"},"href":"https://api.spotify.com/v1/tracks/3N0ugfazz5ZxXKsIAVzK7F","id":"3N0ugfazz5ZxXKsIAVzK7F","is_local":false,"is_playable":true,"name":"Southern Nights","track_number":2,"type":"track","uri":"spotify:track:3N0ugfazz5ZxXKsIAVzK7F"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3RI5qzqfW75gfAAlCqZIYY"},"href":"https://api.spotify.com/v1/albums/3RI5qzqfW75gfAAlCqZIYY","id":"3RI5qzqfW75gfAAlCqZIYY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273075894c4f69419e81874461a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02075894c4f69419e81874461a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851075894c4f69419e81874461a"}],"is_playable":true,"name":"70s Rock","release_date":"2019-06-14","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:3RI5qzqfW75gfAAlCqZIYY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":1,"duration_ms":177586,"explicit":false,"external_ids":{"isrc":"USCN17600069"},"external_urls":{"spotify":"https://open.spotify.com/track/3YkqVF9WhibTSP5UCHwpuh"},"href":"https://api.spotify.com/v1/tracks/3YkqVF9WhibTSP5UCHwpuh","id":"3YkqVF9WhibTSP5UCHwpuh","is_local":false,"is_playable":true,"name":"Southern Nights","track_number":23,"type":"track","uri":"spotify:track:3YkqVF9WhibTSP5UCHwpuh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6XXeuda2TubGnTWzdEoMj4"},"href":"https://api.spotify.com/v1/albums/6XXeuda2TubGnTWzdEoMj4","id":"6XXeuda2TubGnTWzdEoMj4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273722b6ac18ef037a98b802268"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02722b6ac18ef037a98b802268"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851722b6ac18ef037a98b802268"}],"is_playable":true,"name":"70s Rock","release_date":"2019-06-14","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:6XXeuda2TubGnTWzdEoMj4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":1,"duration_ms":177586,"explicit":false,"external_ids":{"isrc":"USCN17600069"},"external_urls":{"spotify":"https://open.spotify.com/track/39lCP5wTDuUfiJXF1Yy9pL"},"href":"https://api.spotify.com/v1/tracks/39lCP5wTDuUfiJXF1Yy9pL","id":"39lCP5wTDuUfiJXF1Yy9pL","is_local":false,"is_playable":true,"name":"Southern Nights","track_number":25,"type":"track","uri":"spotify:track:39lCP5wTDuUfiJXF1Yy9pL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4N5ClMd8cyVAhRPhapc1HD"},"href":"https://api.spotify.com/v1/albums/4N5ClMd8cyVAhRPhapc1HD","id":"4N5ClMd8cyVAhRPhapc1HD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c551f4520e418eb88ee0bf8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c551f4520e418eb88ee0bf8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c551f4520e418eb88ee0bf8"}],"is_playable":true,"name":"70s Country","release_date":"2023-03-15","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:4N5ClMd8cyVAhRPhapc1HD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":1,"duration_ms":177586,"explicit":false,"external_ids":{"isrc":"USCN17600069"},"external_urls":{"spotify":"https://open.spotify.com/track/5F8q8tewWWCIrOez5Gpbhy"},"href":"https://api.spotify.com/v1/tracks/5F8q8tewWWCIrOez5Gpbhy","id":"5F8q8tewWWCIrOez5Gpbhy","is_local":false,"is_playable":true,"name":"Southern Nights","track_number":2,"type":"track","uri":"spotify:track:5F8q8tewWWCIrOez5Gpbhy"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3wTiOdK2OVnqNIWk4SAZtW"},"href":"https://api.spotify.com/v1/albums/3wTiOdK2OVnqNIWk4SAZtW","id":"3wTiOdK2OVnqNIWk4SAZtW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f97401d98884de3d639c6d22"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f97401d98884de3d639c6d22"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f97401d98884de3d639c6d22"}],"is_playable":true,"name":"The Best 70s Music Videos","release_date":"2024-05-17","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:3wTiOdK2OVnqNIWk4SAZtW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":1,"duration_ms":177586,"explicit":false,"external_ids":{"isrc":"USCN17600069"},"external_urls":{"spotify":"https://open.spotify.com/track/4zbdTTcOn09JnmcfPuvqKA"},"href":"https://api.spotify.com/v1/tracks/4zbdTTcOn09JnmcfPuvqKA","id":"4zbdTTcOn09JnmcfPuvqKA","is_local":false,"is_playable":true,"name":"Southern Nights","track_number":38,"type":"track","uri":"spotify:track:4zbdTTcOn09JnmcfPuvqKA"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/66CX4th4chb6HT7FjxopSx"},"href":"https://api.spotify.com/v1/albums/66CX4th4chb6HT7FjxopSx","id":"66CX4th4chb6HT7FjxopSx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273305c5b019485bf1c46f1f0e9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02305c5b019485bf1c46f1f0e9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851305c5b019485bf1c46f1f0e9"}],"is_playable":true,"name":"70s Mix","release_date":"2019-06-14","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:66CX4th4chb6HT7FjxopSx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/59hLmB5DrdihCYtNeFeW1U"},"href":"https://api.spotify.com/v1/artists/59hLmB5DrdihCYtNeFeW1U","id":"59hLmB5DrdihCYtNeFeW1U","name":"Glen Campbell","type":"artist","uri":"spotify:artist:59hLmB5DrdihCYtNeFeW1U"}],"disc_number":1,"duration_ms":177586,"explicit":false,"external_ids":{"isrc":"USCN17600069"},"external_urls":{"spotify":"https://open.spotify.com/track/31nLD2xSN0KzSV4AQI34yc"},"href":"https://api.spotify.com/v1/tracks/31nLD2xSN0KzSV4AQI34yc","id":"31nLD2xSN0KzSV4AQI34yc","is_local":false,"is_playable":true,"name":"Southern Nights","track_number":34,"type":"track","uri":"spotify:track:31nLD2xSN0KzSV4AQI34yc"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNvdXRoZXJuJTIwTmlnaHRzJTIyJTIwYXJ0aXN0JTNBJTIyR2xlbiUyMENhbXBiZWxsJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81OWhMbUI1RHJkaWhDWXROZUZlVzFVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU5aExtQjVEcmRpaENZdE5lRmVXMVUiLCJpZCI6IjU5aExtQjVEcmRpaENZdE5lRmVXMVUiLCJuYW1lIjoiR2xlbiBDYW1wYmVsbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OWhMbUI1RHJkaWhDWXROZUZlVzFVIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMFI3VXcxdFVVYldsVjUzQkdLZmpRNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBSN1V3MXRVVWJXbFY1M0JHS2ZqUTQiLCJpZCI6IjBSN1V3MXRVVWJXbFY1M0JHS2ZqUTQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDYxNzYyYzE1ZjA1ZTE0MWZlNmYzMDk3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQ2MTc2MmMxNWYwNWUxNDFmZTZmMzA5NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDYxNzYyYzE1ZjA1ZTE0MWZlNmYzMDk3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvdXRoZXJuIE5pZ2h0cyIsInJlbGVhc2VfZGF0ZSI6IjE5NzctMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowUjdVdzF0VVViV2xWNTNCR0tmalE0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81OWhMbUI1RHJkaWhDWXROZUZlVzFVIiwiaWQiOiI1OQ==", + "aExtQjVEcmRpaENZdE5lRmVXMVUiLCJuYW1lIjoiR2xlbiBDYW1wYmVsbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OWhMbUI1RHJkaWhDWXROZUZlVzFVIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4MDAyNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQ04xNzYwMDA2OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2t2N3pCak10VmYwZUlKbGUyVlp4biJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdrdjd6QmpNdFZmMGVJSmxlMlZaeG4iLCJpZCI6Ijdrdjd6QmpNdFZmMGVJSmxlMlZaeG4iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU291dGhlcm4gTmlnaHRzIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdrdjd6QmpNdFZmMGVJSmxlMlZaeG4ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81OWhMbUI1RHJkaWhDWXROZUZlVzFVIiwiaWQiOiI1OWhMbUI1RHJkaWhDWXROZUZlVzFVIiwibmFtZSI6IkdsZW4gQ2FtcGJlbGwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVNclhHNW1oZ2VuckhhcjRTOGlRZHkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81TXJYRzVtaGdlbnJIYXI0UzhpUWR5IiwiaWQiOiI1TXJYRzVtaGdlbnJIYXI0UzhpUWR5IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzY2YWZmMDZjMDMwNmU0YzM1NmJjOTljOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2NmFmZjA2YzAzMDZlNGMzNTZiYzk5YzgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTY2YWZmMDZjMDMwNmU0YzM1NmJjOTljOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHbGVuIENhbXBiZWxsIC0gVGhlIENhcA==", + "aXRvbCBZZWFycyAxOTY1IC0gMTk3NyIsInJlbGVhc2VfZGF0ZSI6IjIwMTEtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0NiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1TXJYRzVtaGdlbnJIYXI0UzhpUWR5In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81OWhMbUI1RHJkaWhDWXROZUZlVzFVIiwiaWQiOiI1OWhMbUI1RHJkaWhDWXROZUZlVzFVIiwibmFtZSI6IkdsZW4gQ2FtcGJlbGwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjoxNzg2NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0NOMTc2MDAwNjkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRjNjhaOXdMZEhjMzZ5M0NOandRS00ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80YzY4Wjl3TGRIYzM2eTNDTmp3UUtNIiwiaWQiOiI0YzY4Wjl3TGRIYzM2eTNDTmp3UUtNIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvdXRoZXJuIE5pZ2h0cyIsInRyYWNrX251bWJlciI6MjAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGM2OFo5d0xkSGMzNnkzQ05qd1FLTSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81OWhMbUI1RHJkaWhDWXROZUZlVzFVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU5aExtQjVEcmRpaENZdE5lRmVXMVUiLCJpZCI6IjU5aExtQjVEcmRpaENZdE5lRmVXMVUiLCJuYW1lIjoiR2xlbiBDYW1wYmVsbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OWhMbUI1RHJkaWhDWXROZUZlVzFVIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNE9RS2tJSXA1MEZKdlVkNjl2VDBCNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRPUUtrSUlwNTBGSnZVZDY5dlQwQjQiLCJpZCI6IjRPUUtrSUlwNTBGSnZVZDY5dlQwQjQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLA==", + "IndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwMzcwMDIxYmU4MGI0N2I4ZDlhN2UzYmIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDM3MDAyMWJlODBiNDdiOGQ5YTdlM2JiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwMzcwMDIxYmU4MGI0N2I4ZDlhN2UzYmIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3JlYXRlc3QgSGl0cyIsInJlbGVhc2VfZGF0ZSI6IjIwMDktMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0T1FLa0lJcDUwRkp2VWQ2OXZUMEI0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81OWhMbUI1RHJkaWhDWXROZUZlVzFVIiwiaWQiOiI1OWhMbUI1RHJkaWhDWXROZUZlVzFVIiwibmFtZSI6IkdsZW4gQ2FtcGJlbGwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzk1ODYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0NOMTA4MDI1ODQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJzZDhwODlEdllCekpGV285N2tuc2QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yc2Q4cDg5RHZZQnpKRldvOTdrbnNkIiwiaWQiOiIyc2Q4cDg5RHZZQnpKRldvOTdrbnNkIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvdXRoZXJuIE5pZ2h0cyIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyc2Q4cDg5RHZZQnpKRldvOTdrbnNkIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU5aExtQjVEcmRpaENZdE5lRmVXMVUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsImlkIjoiNTloTG1CNURyZGloQw==", + "WXROZUZlVzFVIiwibmFtZSI6IkdsZW4gQ2FtcGJlbGwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzMyTGY5a0JIQkZjVHhoZnQwWTVUaWQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zMkxmOWtCSEJGY1R4aGZ0MFk1VGlkIiwiaWQiOiIzMkxmOWtCSEJGY1R4aGZ0MFk1VGlkIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzVjMTg1YjJhYWEwYzA1YjczZTNkZGQ5NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1YzE4NWIyYWFhMGMwNWI3M2UzZGRkOTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTVjMTg1YjJhYWEwYzA1YjczZTNkZGQ5NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgTGVnYWN5ICgxOTYxLTIwMTcpIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wNi0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjc4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjMyTGY5a0JIQkZjVHhoZnQwWTVUaWQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81OWhMbUI1RHJkaWhDWXROZUZlVzFVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU5aExtQjVEcmRpaENZdE5lRmVXMVUiLCJpZCI6IjU5aExtQjVEcmRpaENZdE5lRmVXMVUiLCJuYW1lIjoiR2xlbiBDYW1wYmVsbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OWhMbUI1RHJkaWhDWXROZUZlVzFVIn1dLCJkaXNjX251bWJlciI6MywiZHVyYXRpb25fbXMiOjE3OTI2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQ04xMDIwMDQxNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMGJjd1NZaUJVc2NZclJOYVhYdmRjQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBiY3dTWWlCVXNjWXJSTmFYWHZkY0IiLCJpZCI6IjBiY3dTWWlCVXNjWXJSTmFYWHZkY0IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU291dA==", + "aGVybiBOaWdodHMgLSBSZW1hc3RlcmVkIiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBiY3dTWWlCVXNjWXJSTmFYWHZkY0IifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU5aExtQjVEcmRpaENZdE5lRmVXMVUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsImlkIjoiNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsIm5hbWUiOiJHbGVuIENhbXBiZWxsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU5aExtQjVEcmRpaENZdE5lRmVXMVUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81VDZFaHRUUXoyTWFMVkdqM2JWdGozIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNVQ2RWh0VFF6Mk1hTFZHajNiVnRqMyIsImlkIjoiNVQ2RWh0VFF6Mk1hTFZHajNiVnRqMyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3ZTFiYzkyNjEyNjY1Nzc1ZjNlNzQ3YzYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyN2UxYmM5MjYxMjY2NTc3NWYzZTc0N2M2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3ZTFiYzkyNjEyNjY1Nzc1ZjNlNzQ3YzYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmhpbmVzdG9uZSBDb3dib3kiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA2LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1VDZFaHRUUXoyTWFMVkdqM2JWdGozIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81OWhMbUI1RHJkaWhDWXROZUZlVzFVIiwiaWQiOiI1OWhMbUI1RHJkaWhDWXROZUZlVzFVIiwibmFtZSI6IkdsZW4gQ2FtcGJlbGwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NTloTG1CNURyZGloQ1l0TmVGZVcxVSJ9XSwiZGlzY19udQ==", + "bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3NzU4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQ04xNzYwMDA2OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM04wdWdmYXp6NVp4WEtzSUFWeks3RiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNOMHVnZmF6ejVaeFhLc0lBVnpLN0YiLCJpZCI6IjNOMHVnZmF6ejVaeFhLc0lBVnpLN0YiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU291dGhlcm4gTmlnaHRzIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNOMHVnZmF6ejVaeFhLc0lBVnpLN0YifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM1JJNXF6cWZXNzVnZkFBbENxWklZWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNSSTVxenFmVzc1Z2ZBQWxDcVpJWVkiLCJpZCI6IjNSSTVxenFmVzc1Z2ZBQWxDcVpJWVkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDc1ODk0YzRmNjk0MTllODE4NzQ0NjFhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA3NTg5NGM0ZjY5NDE5ZTgxODc0NDYxYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDc1ODk0YzRmNjk0MTllODE4NzQ0NjFhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjcwcyBSb2NrIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wNi0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNSSTVxenFmVzc1Z2ZBQQ==", + "bENxWklZWSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU5aExtQjVEcmRpaENZdE5lRmVXMVUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsImlkIjoiNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsIm5hbWUiOiJHbGVuIENhbXBiZWxsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU5aExtQjVEcmRpaENZdE5lRmVXMVUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc3NTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNDTjE3NjAwMDY5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zWWtxVkY5V2hpYlRTUDVVQ0h3cHVoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM1lrcVZGOVdoaWJUU1A1VUNId3B1aCIsImlkIjoiM1lrcVZGOVdoaWJUU1A1VUNId3B1aCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb3V0aGVybiBOaWdodHMiLCJ0cmFja19udW1iZXIiOjIzLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNZa3FWRjlXaGliVFNQNVVDSHdwdWgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNlhYZXVkYTJUdWJHblRXemRFb01qNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZYWGV1ZGEyVHViR25UV3pkRW9NajQiLCJpZCI6IjZYWGV1ZGEyVHViR25UV3pkRW9NajQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzIyYjZhYzE4ZWYwMzdhOThiODAyMjY4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNg==", + "ZDAwMDAxZTAyNzIyYjZhYzE4ZWYwMzdhOThiODAyMjY4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3MjJiNmFjMThlZjAzN2E5OGI4MDIyNjgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiNzBzIFJvY2siLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA2LTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlhYZXVkYTJUdWJHblRXemRFb01qNCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU5aExtQjVEcmRpaENZdE5lRmVXMVUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsImlkIjoiNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsIm5hbWUiOiJHbGVuIENhbXBiZWxsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU5aExtQjVEcmRpaENZdE5lRmVXMVUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc3NTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNDTjE3NjAwMDY5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zOWxDUDV3VER1VWZpSlhGMVl5OXBMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzlsQ1A1d1REdVVmaUpYRjFZeTlwTCIsImlkIjoiMzlsQ1A1d1REdVVmaUpYRjFZeTlwTCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb3V0aGVybiBOaWdodHMiLCJ0cmFja19udW1iZXIiOjI1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjM5bENQNXdURHVVZmlKWEYxWXk5cEwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYQ==", + "bGJ1bS80TjVDbE1kOGN5VkFoUlBoYXBjMUhEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNE41Q2xNZDhjeVZBaFJQaGFwYzFIRCIsImlkIjoiNE41Q2xNZDhjeVZBaFJQaGFwYzFIRCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYzU1MWY0NTIwZTQxOGViODhlZTBiZjgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWM1NTFmNDUyMGU0MThlYjg4ZWUwYmY4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYzU1MWY0NTIwZTQxOGViODhlZTBiZjgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiNzBzIENvdW50cnkiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTAzLTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NE41Q2xNZDhjeVZBaFJQaGFwYzFIRCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU5aExtQjVEcmRpaENZdE5lRmVXMVUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsImlkIjoiNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsIm5hbWUiOiJHbGVuIENhbXBiZWxsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU5aExtQjVEcmRpaENZdE5lRmVXMVUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc3NTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNDTjE3NjAwMDY5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81RjhxOHRld1dXQ0lyT2V6NUdwYmh5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUY4cTh0ZXdXV0NJck9lejVHcGJoeSIsImlkIjoiNUY4cTh0ZXdXV0NJck9lejVHcGJoeSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb3V0aGVybiBOaWdodHMiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUY4cTh0ZXdXV0NJck9lejVHcGJoeSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aQ==", + "ZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzN3VGlPZEsyT1ZucU5JV2s0U0FadFcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zd1RpT2RLMk9WbnFOSVdrNFNBWnRXIiwiaWQiOiIzd1RpT2RLMk9WbnFOSVdrNFNBWnRXIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2Y5NzQwMWQ5ODg4NGRlM2Q2MzljNmQyMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmOTc0MDFkOTg4ODRkZTNkNjM5YzZkMjIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWY5NzQwMWQ5ODg4NGRlM2Q2MzljNmQyMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgQmVzdCA3MHMgTXVzaWMgVmlkZW9zIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wNS0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjN3VGlPZEsyT1ZucU5JV2s0U0FadFcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81OWhMbUI1RHJkaWhDWXROZUZlVzFVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU5aExtQjVEcmRpaENZdE5lRmVXMVUiLCJpZCI6IjU5aExtQjVEcmRpaENZdE5lRmVXMVUiLCJuYW1lIjoiR2xlbiBDYW1wYmVsbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OWhMbUI1RHJkaWhDWXROZUZlVzFVIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3NzU4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQ04xNzYwMDA2OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNHpiZFRUY09uMDlKbm1jZg==", + "UHV2cUtBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNHpiZFRUY09uMDlKbm1jZlB1dnFLQSIsImlkIjoiNHpiZFRUY09uMDlKbm1jZlB1dnFLQSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb3V0aGVybiBOaWdodHMiLCJ0cmFja19udW1iZXIiOjM4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjR6YmRUVGNPbjA5Sm5tY2ZQdXZxS0EifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNjZDWDR0aDRjaGI2SFQ3Rmp4b3BTeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzY2Q1g0dGg0Y2hiNkhUN0ZqeG9wU3giLCJpZCI6IjY2Q1g0dGg0Y2hiNkhUN0ZqeG9wU3giLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzA1YzViMDE5NDg1YmYxYzQ2ZjFmMGU5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjMwNWM1YjAxOTQ4NWJmMWM0NmYxZjBlOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzA1YzViMDE5NDg1YmYxYzQ2ZjFmMGU5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjcwcyBNaXgiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA2LTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6", + "YWxidW06NjZDWDR0aDRjaGI2SFQ3Rmp4b3BTeCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU5aExtQjVEcmRpaENZdE5lRmVXMVUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsImlkIjoiNTloTG1CNURyZGloQ1l0TmVGZVcxVSIsIm5hbWUiOiJHbGVuIENhbXBiZWxsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU5aExtQjVEcmRpaENZdE5lRmVXMVUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc3NTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNDTjE3NjAwMDY5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zMW5MRDJ4U04wS3pTVjRBUUkzNHljIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzFuTEQyeFNOMEt6U1Y0QVFJMzR5YyIsImlkIjoiMzFuTEQyeFNOMEt6U1Y0QVFJMzR5YyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb3V0aGVybiBOaWdodHMiLCJ0cmFja19udW1iZXIiOjM0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjMxbkxEMnhTTjBLelNWNEFRSTM0eWMifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Southern+Nights%22+artist%3A%22Glen+Campbell%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Everywhere%22%20artist%3A%22Fleetwood%20Mac%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/4AsXQ17Arq1cUVoa9dKJ3F"},"href":"https://api.spotify.com/v1/albums/4AsXQ17Arq1cUVoa9dKJ3F","id":"4AsXQ17Arq1cUVoa9dKJ3F","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aaba065944cd82a6f15c86b6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aaba065944cd82a6f15c86b6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aaba065944cd82a6f15c86b6"}],"is_playable":true,"name":"Tango In the Night (Deluxe Edition)","release_date":"1987-04-13","release_date_precision":"day","total_tracks":39,"type":"album","uri":"spotify:album:4AsXQ17Arq1cUVoa9dKJ3F"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":226653,"explicit":false,"external_ids":{"isrc":"USRH11602189"},"external_urls":{"spotify":"https://open.spotify.com/track/254bXAqt3zP6P50BdQvEsq"},"href":"https://api.spotify.com/v1/tracks/254bXAqt3zP6P50BdQvEsq","id":"254bXAqt3zP6P50BdQvEsq","is_local":false,"is_playable":true,"name":"Everywhere - 2017 Remaster","track_number":3,"type":"track","uri":"spotify:track:254bXAqt3zP6P50BdQvEsq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/0LfM3PGkXE6KvJEE1HkOnz"},"href":"https://api.spotify.com/v1/albums/0LfM3PGkXE6KvJEE1HkOnz","id":"0LfM3PGkXE6KvJEE1HkOnz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eb832efe061888ee7ef10456"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eb832efe061888ee7ef10456"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eb832efe061888ee7ef10456"}],"is_playable":true,"name":"Greatest Hits","release_date":"1988-11-22","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0LfM3PGkXE6KvJEE1HkOnz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":222733,"explicit":false,"external_ids":{"isrc":"USWB19900202"},"external_urls":{"spotify":"https://open.spotify.com/track/1prZ0pr6XoRCxcrC3MCL0M"},"href":"https://api.spotify.com/v1/tracks/1prZ0pr6XoRCxcrC3MCL0M","id":"1prZ0pr6XoRCxcrC3MCL0M","is_local":false,"is_playable":true,"name":"Everywhere","track_number":5,"type":"track","uri":"spotify:track:1prZ0pr6XoRCxcrC3MCL0M"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/5YzOUVdLMrItgSP3lMxReH"},"href":"https://api.spotify.com/v1/albums/5YzOUVdLMrItgSP3lMxReH","id":"5YzOUVdLMrItgSP3lMxReH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27318c0cb6bcd7bfecee189242f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0218c0cb6bcd7bfecee189242f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485118c0cb6bcd7bfecee189242f"}],"is_playable":true,"name":"Greatest Hits (Deluxe Edition)","release_date":"1988-11-22","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:5YzOUVdLMrItgSP3lMxReH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":221346,"explicit":false,"external_ids":{"isrc":"USWB22600012"},"external_urls":{"spotify":"https://open.spotify.com/track/5vSSE5xtzAYi5dmogC4HTH"},"href":"https://api.spotify.com/v1/tracks/5vSSE5xtzAYi5dmogC4HTH","id":"5vSSE5xtzAYi5dmogC4HTH","is_local":false,"is_playable":true,"name":"Everywhere","track_number":5,"type":"track","uri":"spotify:track:5vSSE5xtzAYi5dmogC4HTH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/7A0defNYClzfQHV8ifOBv0"},"href":"https://api.spotify.com/v1/albums/7A0defNYClzfQHV8ifOBv0","id":"7A0defNYClzfQHV8ifOBv0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27353dd2d2264885e16b3315516"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0253dd2d2264885e16b3315516"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485153dd2d2264885e16b3315516"}],"is_playable":true,"name":"The Very Best Of Fleetwood Mac","release_date":"2002-10-12","release_date_precision":"day","total_tracks":36,"type":"album","uri":"spotify:album:7A0defNYClzfQHV8ifOBv0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":2,"duration_ms":221973,"explicit":false,"external_ids":{"isrc":"USWB10202628"},"external_urls":{"spotify":"https://open.spotify.com/track/0CQ2EPgBXhJEnTaxbb4rWt"},"href":"https://api.spotify.com/v1/tracks/0CQ2EPgBXhJEnTaxbb4rWt","id":"0CQ2EPgBXhJEnTaxbb4rWt","is_local":false,"is_playable":true,"name":"Everywhere - 2002 Remaster","track_number":13,"type":"track","uri":"spotify:track:0CQ2EPgBXhJEnTaxbb4rWt"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/06JqOkwwy91OxrApXclzYf"},"href":"https://api.spotify.com/v1/albums/06JqOkwwy91OxrApXclzYf","id":"06JqOkwwy91OxrApXclzYf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273470a57c2dc8710171d4783df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02470a57c2dc8710171d4783df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851470a57c2dc8710171d4783df"}],"is_playable":true,"name":"50 Years - Don't Stop","release_date":"2018-11-16","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:06JqOkwwy91OxrApXclzYf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":223253,"explicit":false,"external_ids":{"isrc":"USRH11802597"},"external_urls":{"spotify":"https://open.spotify.com/track/7BRMVjSXolblx6ZXliSaMl"},"href":"https://api.spotify.com/v1/tracks/7BRMVjSXolblx6ZXliSaMl","id":"7BRMVjSXolblx6ZXliSaMl","is_local":false,"is_playable":true,"name":"Everywhere - 2018 Remaster","track_number":7,"type":"track","uri":"spotify:track:7BRMVjSXolblx6ZXliSaMl"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0xYPmjzRD0Ux122ilnKaKh"},"href":"https://api.spotify.com/v1/albums/0xYPmjzRD0Ux122ilnKaKh","id":"0xYPmjzRD0Ux122ilnKaKh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27381ed8a674e66f7055cc39481"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0281ed8a674e66f7055cc39481"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485181ed8a674e66f7055cc39481"}],"is_playable":true,"name":"100 Greatest Summer Songs","release_date":"2019-04-05","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0xYPmjzRD0Ux122ilnKaKh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":226653,"explicit":false,"external_ids":{"isrc":"USRH11602189"},"external_urls":{"spotify":"https://open.spotify.com/track/4J6Qs7dZq0ihNCZbyHIMP9"},"href":"https://api.spotify.com/v1/tracks/4J6Qs7dZq0ihNCZbyHIMP9","id":"4J6Qs7dZq0ihNCZbyHIMP9","is_local":false,"is_playable":true,"name":"Everywhere - 2017 Remaster","track_number":2,"type":"track","uri":"spotify:track:4J6Qs7dZq0ihNCZbyHIMP9"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3D5BaRZxngDIZP811L4p1N"},"href":"https://api.spotify.com/v1/albums/3D5BaRZxngDIZP811L4p1N","id":"3D5BaRZxngDIZP811L4p1N","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273709b8d3bc3c18372eceebede"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02709b8d3bc3c18372eceebede"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851709b8d3bc3c18372eceebede"}],"is_playable":true,"name":"100 Greatest Driving Songs","release_date":"2022-08-19","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:3D5BaRZxngDIZP811L4p1N"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":223253,"explicit":false,"external_ids":{"isrc":"USRH11802597"},"external_urls":{"spotify":"https://open.spotify.com/track/1waCiEO0msp9g3fbeFBUKe"},"href":"https://api.spotify.com/v1/tracks/1waCiEO0msp9g3fbeFBUKe","id":"1waCiEO0msp9g3fbeFBUKe","is_local":false,"is_playable":true,"name":"Everywhere - 2018 Remaster","track_number":11,"type":"track","uri":"spotify:track:1waCiEO0msp9g3fbeFBUKe"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkV2ZXJ5d2hlcmUlMjIlMjBhcnRpc3QlM0ElMjJGbGVldHdvb2QlMjBNYWMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjcsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80QXNYUTE3QXJxMWNVVm9hOWRLSjNGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNEFzWFExN0FycTFjVVZvYTlkS0ozRiIsImlkIjoiNEFzWFExN0FycTFjVVZvYTlkS0ozRiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2Ru", + "LmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhYWJhMDY1OTQ0Y2Q4MmE2ZjE1Yzg2YjYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWFiYTA2NTk0NGNkODJhNmYxNWM4NmI2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhYWJhMDY1OTQ0Y2Q4MmE2ZjE1Yzg2YjYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGFuZ28gSW4gdGhlIE5pZ2h0IChEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIxOTg3LTA0LTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEFzWFExN0FycTFjVVZvYTlkS0ozRiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI2NjUzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDExNjAyMTg5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yNTRiWEFxdDN6UDZQNTBCZFF2RXNxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMjU0YlhBcXQzelA2UDUwQmRRdkVzcSIsImlkIjoiMjU0YlhBcXQzelA2UDUwQmRRdkVzcSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJFdmVyeXdoZXJlIC0gMjAxNyBSZW1hc3RlciIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyNTRiWEFxdDN6UDZQNTBCZFF2RXNxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUg==", + "T0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBMZk0zUEdrWEU2S3ZKRUUxSGtPbnoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wTGZNM1BHa1hFNkt2SkVFMUhrT256IiwiaWQiOiIwTGZNM1BHa1hFNkt2SkVFMUhrT256IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ViODMyZWZlMDYxODg4ZWU3ZWYxMDQ1NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlYjgzMmVmZTA2MTg4OGVlN2VmMTA0NTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWViODMyZWZlMDYxODg4ZWU3ZWYxMDQ1NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHcmVhdGVzdCBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMTk4OC0xMS0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBMZk0zUEdrWEU2S3ZKRUUxSGtPbnoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMjczMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTV0IxOTkwMDIwMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXByWjBwcjZYb1JDeGNyQzNNQ0wwTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFwclowcHI2WG9SQ3hjckMzTUNMME0iLCJpZCI6IjFwclowcHI2WG9SQ3hjckMzTUNMME0iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRXZlcnl3aGVyZSIsIg==", + "dHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFwclowcHI2WG9SQ3hjckMzTUNMME0ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVZek9VVmRMTXJJdGdTUDNsTXhSZUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81WXpPVVZkTE1ySXRnU1AzbE14UmVIIiwiaWQiOiI1WXpPVVZkTE1ySXRnU1AzbE14UmVIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE4YzBjYjZiY2Q3YmZlY2VlMTg5MjQyZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxOGMwY2I2YmNkN2JmZWNlZTE4OTI0MmYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE4YzBjYjZiY2Q3YmZlY2VlMTg5MjQyZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHcmVhdGVzdCBIaXRzIChEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIxOTg4LTExLTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVl6T1VWZExNckl0Z1NQM2xNeFJlSCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLA==", + "ImR1cmF0aW9uX21zIjoyMjEzNDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1dCMjI2MDAwMTIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzV2U1NFNXh0ekFZaTVkbW9nQzRIVEgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81dlNTRTV4dHpBWWk1ZG1vZ0M0SFRIIiwiaWQiOiI1dlNTRTV4dHpBWWk1ZG1vZ0M0SFRIIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkV2ZXJ5d2hlcmUiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXZTU0U1eHR6QVlpNWRtb2dDNEhUSCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN0EwZGVmTllDbHpmUUhWOGlmT0J2MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdBMGRlZk5ZQ2x6ZlFIVjhpZk9CdjAiLCJpZCI6IjdBMGRlZk5ZQ2x6ZlFIVjhpZk9CdjAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTNkZDJkMjI2NDg4NWUxNmIzMzE1NTE2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUzZGQyZDIyNjQ4ODVlMTZiMzMxNTUxNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTNkZDJkMjI2NDg4NWUxNmIzMzE1NTE2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBWZXJ5IEJlc3QgT2YgRmxlZXR3b29kIE1hYyIsInJlbGVhc2VfZGF0ZSI6IjIwMDItMTAtMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3QTBkZWZOWQ==", + "Q2x6ZlFIVjhpZk9CdjAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjIyMTk3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTV0IxMDIwMjYyOCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMENRMkVQZ0JYaEpFblRheGJiNHJXdCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBDUTJFUGdCWGhKRW5UYXhiYjRyV3QiLCJpZCI6IjBDUTJFUGdCWGhKRW5UYXhiYjRyV3QiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRXZlcnl3aGVyZSAtIDIwMDIgUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjEzLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBDUTJFUGdCWGhKRW5UYXhiYjRyV3QifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzA2SnFPa3d3eTkxT3hyQXBYY2x6WWYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wNkpxT2t3d3k5MU94ckFwWGNsellmIiwiaWQiOiIwNkpxT2t3d3k5MU94ckFwWGNsellmIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzQ3MGE1N2MyZGM4NzEwMTcxZDQ3ODNkZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLg==", + "Y28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQ3MGE1N2MyZGM4NzEwMTcxZDQ3ODNkZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDcwYTU3YzJkYzg3MTAxNzFkNDc4M2RmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjUwIFllYXJzIC0gRG9uJ3QgU3RvcCIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMTEtMTYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1MCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowNkpxT2t3d3k5MU94ckFwWGNsellmIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjMyNTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTE4MDI1OTcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdCUk1WalNYb2xibHg2WlhsaVNhTWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83QlJNVmpTWG9sYmx4NlpYbGlTYU1sIiwiaWQiOiI3QlJNVmpTWG9sYmx4NlpYbGlTYU1sIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkV2ZXJ5d2hlcmUgLSAyMDE4IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdCUk1WalNYb2xibHg2WlhsaVNhTWwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIg==", + "Onsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8weFlQbWp6UkQwVXgxMjJpbG5LYUtoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMHhZUG1qelJEMFV4MTIyaWxuS2FLaCIsImlkIjoiMHhZUG1qelJEMFV4MTIyaWxuS2FLaCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4MWVkOGE2NzRlNjZmNzA1NWNjMzk0ODEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODFlZDhhNjc0ZTY2ZjcwNTVjYzM5NDgxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4MWVkOGE2NzRlNjZmNzA1NWNjMzk0ODEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMTAwIEdyZWF0ZXN0IFN1bW1lciBTb25ncyIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDQtMDUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MHhZUG1qelJEMFV4MTIyaWxuS2FLaCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI2NjUzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDExNjAyMTg5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80SjZRczdkWnEwaWhOQ1pieUhJTVA5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNEo2UXM3ZFpxMGloTkNaYnlISU1QOSIsImlkIjoiNEo2UXM3ZFpxMGloTkNaYnlISU1QOSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJFdmVyeXdoZXJlIC0gMjAxNyBSZW1hc3RlciIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0SjZRczdkWnEwaWhOQ1pieUhJTVA5In0seyJhbGJ1bQ==", + "Ijp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM0Q1QmFSWnhuZ0RJWlA4MTFMNHAxTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNENUJhUlp4bmdESVpQODExTDRwMU4iLCJpZCI6IjNENUJhUlp4bmdESVpQODExTDRwMU4iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzA5YjhkM2JjM2MxODM3MmVjZWViZWRlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjcwOWI4ZDNiYzNjMTgzNzJlY2VlYmVkZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzA5YjhkM2JjM2MxODM3MmVjZWViZWRlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjEwMCBHcmVhdGVzdCBEcml2aW5nIFNvbmdzIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0wOC0xOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozRDVCYVJaeG5nRElaUDgxMUw0cDFOIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjMyNTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTE4MDI1OTcifSwiZXh0ZXJuYQ==", + "bF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXdhQ2lFTzBtc3A5ZzNmYmVGQlVLZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzF3YUNpRU8wbXNwOWczZmJlRkJVS2UiLCJpZCI6IjF3YUNpRU8wbXNwOWczZmJlRkJVS2UiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRXZlcnl3aGVyZSAtIDIwMTggUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjExLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjF3YUNpRU8wbXNwOWczZmJlRkJVS2UifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Everywhere%22+artist%3A%22Fleetwood+Mac%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Walking%20On%20A%20Dream%22%20artist%3A%22Empire%20Of%20The%20Sun%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"external_urls":{"spotify":"https://open.spotify.com/album/5B6XfyHHYawyLkEvNvhSPh"},"href":"https://api.spotify.com/v1/albums/5B6XfyHHYawyLkEvNvhSPh","id":"5B6XfyHHYawyLkEvNvhSPh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f3aa0e6ca22a382007f61e4d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f3aa0e6ca22a382007f61e4d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f3aa0e6ca22a382007f61e4d"}],"is_playable":true,"name":"Walking On A Dream (10th Anniversary Edition)","release_date":"2008-10-03","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5B6XfyHHYawyLkEvNvhSPh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"disc_number":1,"duration_ms":198440,"explicit":false,"external_ids":{"isrc":"AUEI10800039"},"external_urls":{"spotify":"https://open.spotify.com/track/5r5cp9IpziiIsR6b93vcnQ"},"href":"https://api.spotify.com/v1/tracks/5r5cp9IpziiIsR6b93vcnQ","id":"5r5cp9IpziiIsR6b93vcnQ","is_local":false,"is_playable":true,"name":"Walking On A Dream","track_number":2,"type":"track","uri":"spotify:track:5r5cp9IpziiIsR6b93vcnQ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6zsJjoCtL1WByG0VsuFWzR"},"href":"https://api.spotify.com/v1/artists/6zsJjoCtL1WByG0VsuFWzR","id":"6zsJjoCtL1WByG0VsuFWzR","name":"BLOND:ISH","type":"artist","uri":"spotify:artist:6zsJjoCtL1WByG0VsuFWzR"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Fzl9coophjAezEV0v7tRu"},"href":"https://api.spotify.com/v1/albums/4Fzl9coophjAezEV0v7tRu","id":"4Fzl9coophjAezEV0v7tRu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739d63402160896b411c2a40a8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029d63402160896b411c2a40a8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519d63402160896b411c2a40a8"}],"is_playable":true,"name":"Walking On A Dream (BLOND:ISH Remix)","release_date":"2025-07-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4Fzl9coophjAezEV0v7tRu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6zsJjoCtL1WByG0VsuFWzR"},"href":"https://api.spotify.com/v1/artists/6zsJjoCtL1WByG0VsuFWzR","id":"6zsJjoCtL1WByG0VsuFWzR","name":"BLOND:ISH","type":"artist","uri":"spotify:artist:6zsJjoCtL1WByG0VsuFWzR"}],"disc_number":1,"duration_ms":191849,"explicit":false,"external_ids":{"isrc":"AU2DY2500210"},"external_urls":{"spotify":"https://open.spotify.com/track/5oOKU4RiAMyqUoOKICb92j"},"href":"https://api.spotify.com/v1/tracks/5oOKU4RiAMyqUoOKICb92j","id":"5oOKU4RiAMyqUoOKICb92j","is_local":false,"is_playable":true,"name":"Walking On A Dream - BLOND:ISH Remix","track_number":1,"type":"track","uri":"spotify:track:5oOKU4RiAMyqUoOKICb92j"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"external_urls":{"spotify":"https://open.spotify.com/album/1GoqBRUPZzBKvMKZxSQ1mp"},"href":"https://api.spotify.com/v1/albums/1GoqBRUPZzBKvMKZxSQ1mp","id":"1GoqBRUPZzBKvMKZxSQ1mp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fffbc6bb8f405c2dacf8d64b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fffbc6bb8f405c2dacf8d64b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fffbc6bb8f405c2dacf8d64b"}],"is_playable":true,"name":"Walking On A Dream (Special Edition)","release_date":"2009-01-01","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:1GoqBRUPZzBKvMKZxSQ1mp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"disc_number":1,"duration_ms":198440,"explicit":false,"external_ids":{"isrc":"AUEI10800039"},"external_urls":{"spotify":"https://open.spotify.com/track/6A6qBFJHid4WutQu6HHEZt"},"href":"https://api.spotify.com/v1/tracks/6A6qBFJHid4WutQu6HHEZt","id":"6A6qBFJHid4WutQu6HHEZt","is_local":false,"is_playable":true,"name":"Walking On A Dream","track_number":2,"type":"track","uri":"spotify:track:6A6qBFJHid4WutQu6HHEZt"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Bh3jkdfh2bp6KXiQq4yQp"},"href":"https://api.spotify.com/v1/albums/5Bh3jkdfh2bp6KXiQq4yQp","id":"5Bh3jkdfh2bp6KXiQq4yQp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27333d298bba1b6c7478ab3bd65"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0233d298bba1b6c7478ab3bd65"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485133d298bba1b6c7478ab3bd65"}],"is_playable":true,"name":"Walking On A Dream (Reimagined)","release_date":"2025-09-26","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:5Bh3jkdfh2bp6KXiQq4yQp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"disc_number":1,"duration_ms":196155,"explicit":false,"external_ids":{"isrc":"AUEI10800039"},"external_urls":{"spotify":"https://open.spotify.com/track/4uwhSIWl4AUkqOwhNaEOLn"},"href":"https://api.spotify.com/v1/tracks/4uwhSIWl4AUkqOwhNaEOLn","id":"4uwhSIWl4AUkqOwhNaEOLn","is_local":false,"is_playable":true,"name":"Walking On A Dream","track_number":1,"type":"track","uri":"spotify:track:4uwhSIWl4AUkqOwhNaEOLn"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6JvL8seFtZSaqM1LGDxT9z"},"href":"https://api.spotify.com/v1/albums/6JvL8seFtZSaqM1LGDxT9z","id":"6JvL8seFtZSaqM1LGDxT9z","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732f7fd5643fb79343ff93a29d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022f7fd5643fb79343ff93a29d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512f7fd5643fb79343ff93a29d"}],"is_playable":true,"name":"Dancing Songs For Kids","release_date":"2021-09-17","release_date_precision":"day","total_tracks":37,"type":"album","uri":"spotify:album:6JvL8seFtZSaqM1LGDxT9z"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"disc_number":1,"duration_ms":198440,"explicit":false,"external_ids":{"isrc":"AUEI10800039"},"external_urls":{"spotify":"https://open.spotify.com/track/01iHvqKwfP2cFS2xGi4rPj"},"href":"https://api.spotify.com/v1/tracks/01iHvqKwfP2cFS2xGi4rPj","id":"01iHvqKwfP2cFS2xGi4rPj","is_local":false,"is_playable":true,"name":"Walking On A Dream","track_number":16,"type":"track","uri":"spotify:track:01iHvqKwfP2cFS2xGi4rPj"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2Vvx3fP3zzdT7PkiJwUd1A"},"href":"https://api.spotify.com/v1/albums/2Vvx3fP3zzdT7PkiJwUd1A","id":"2Vvx3fP3zzdT7PkiJwUd1A","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb9e9e1744084ee655a592e0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb9e9e1744084ee655a592e0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb9e9e1744084ee655a592e0"}],"is_playable":true,"name":"Summer Vacation","release_date":"2025-05-07","release_date_precision":"day","total_tracks":46,"type":"album","uri":"spotify:album:2Vvx3fP3zzdT7PkiJwUd1A"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"disc_number":1,"duration_ms":198440,"explicit":false,"external_ids":{"isrc":"AUEI10800039"},"external_urls":{"spotify":"https://open.spotify.com/track/6pKWwJv86Ardkk6sy5KeJF"},"href":"https://api.spotify.com/v1/tracks/6pKWwJv86Ardkk6sy5KeJF","id":"6pKWwJv86Ardkk6sy5KeJF","is_local":false,"is_playable":true,"name":"Walking On A Dream","track_number":7,"type":"track","uri":"spotify:track:6pKWwJv86Ardkk6sy5KeJF"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/39BX2EjRCntJmynOMpSJsz"},"href":"https://api.spotify.com/v1/albums/39BX2EjRCntJmynOMpSJsz","id":"39BX2EjRCntJmynOMpSJsz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a47dc777d622879e33141ae2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a47dc777d622879e33141ae2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a47dc777d622879e33141ae2"}],"is_playable":true,"name":"00s House Party","release_date":"2019-06-14","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:39BX2EjRCntJmynOMpSJsz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"disc_number":1,"duration_ms":198440,"explicit":false,"external_ids":{"isrc":"AUEI10800039"},"external_urls":{"spotify":"https://open.spotify.com/track/1jkPXQbjYk7l1SQ6BEmIf6"},"href":"https://api.spotify.com/v1/tracks/1jkPXQbjYk7l1SQ6BEmIf6","id":"1jkPXQbjYk7l1SQ6BEmIf6","is_local":false,"is_playable":true,"name":"Walking On A Dream","track_number":17,"type":"track","uri":"spotify:track:1jkPXQbjYk7l1SQ6BEmIf6"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3BRZHiNQiv0t7x6kVuzFwq"},"href":"https://api.spotify.com/v1/albums/3BRZHiNQiv0t7x6kVuzFwq","id":"3BRZHiNQiv0t7x6kVuzFwq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273477a5480bf633b726de83b3f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02477a5480bf633b726de83b3f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851477a5480bf633b726de83b3f"}],"is_playable":true,"name":"House Party Jams","release_date":"2019-03-22","release_date_precision":"day","total_tracks":38,"type":"album","uri":"spotify:album:3BRZHiNQiv0t7x6kVuzFwq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/67hb7towEyKvt5Z8Bx306c"},"href":"https://api.spotify.com/v1/artists/67hb7towEyKvt5Z8Bx306c","id":"67hb7towEyKvt5Z8Bx306c","name":"Empire Of The Sun","type":"artist","uri":"spotify:artist:67hb7towEyKvt5Z8Bx306c"}],"disc_number":1,"duration_ms":198440,"explicit":false,"external_ids":{"isrc":"AUEI10800039"},"external_urls":{"spotify":"https://open.spotify.com/track/3xVaJfd27n4S6ZZoyGYX4H"},"href":"https://api.spotify.com/v1/tracks/3xVaJfd27n4S6ZZoyGYX4H","id":"3xVaJfd27n4S6ZZoyGYX4H","is_local":false,"is_playable":true,"name":"Walking On A Dream","track_number":36,"type":"track","uri":"spotify:track:3xVaJfd27n4S6ZZoyGYX4H"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhbGtpbmclMjBPbiUyMEElMjBEcmVhbSUyMiUyMGFydGlzdCUzQSUyMkVtcGlyZSUyME9mJTIwVGhlJTIwU3VuJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo4LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJpZCI6IjY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJuYW1lIjoiRW1waXJlIE9mIFRoZSBTdW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVCNlhmeUhIWWF3eUxrRXZOdmhTUGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81QjZYZnlISFlhd3lMa0V2TnZoU1BoIiwiaWQiOiI1QjZYZnlISFlhd3lMa0V2TnZoU1BoIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgi", + "OjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2YzYWEwZTZjYTIyYTM4MjAwN2Y2MWU0ZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmM2FhMGU2Y2EyMmEzODIwMDdmNjFlNGQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWYzYWEwZTZjYTIyYTM4MjAwN2Y2MWU0ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWxraW5nIE9uIEEgRHJlYW0gKDEwdGggQW5uaXZlcnNhcnkgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDA4LTEwLTAzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUI2WGZ5SEhZYXd5TGtFdk52aFNQaCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyIsImlkIjoiNjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyIsIm5hbWUiOiJFbXBpcmUgT2YgVGhlIFN1biIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5ODQ0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkFVRUkxMDgwMDAzOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNXI1Y3A5SXB6aWlJc1I2YjkzdmNuUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVyNWNwOUlwemlpSXNSNmI5M3ZjblEiLCJpZCI6IjVyNWNwOUlwemlpSXNSNmI5M3ZjblEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2Fsa2luZyBPbiBBIERyZWFtIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVyNWNwOUlwemlpSXNSNmI5M3ZjblEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjdoYjd0b3dFeUt2dDVaOA==", + "QngzMDZjIiwiaWQiOiI2N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIiwibmFtZSI6IkVtcGlyZSBPZiBUaGUgU3VuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjY3aGI3dG93RXlLdnQ1WjhCeDMwNmMifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnpzSmpvQ3RMMVdCeUcwVnN1Rld6UiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82enNKam9DdEwxV0J5RzBWc3VGV3pSIiwiaWQiOiI2enNKam9DdEwxV0J5RzBWc3VGV3pSIiwibmFtZSI6IkJMT05EOklTSCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2enNKam9DdEwxV0J5RzBWc3VGV3pSIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNEZ6bDljb29waGpBZXpFVjB2N3RSdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRGemw5Y29vcGhqQWV6RVYwdjd0UnUiLCJpZCI6IjRGemw5Y29vcGhqQWV6RVYwdjd0UnUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWQ2MzQwMjE2MDg5NmI0MTFjMmE0MGE4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjlkNjM0MDIxNjA4OTZiNDExYzJhNDBhOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWQ2MzQwMjE2MDg5NmI0MTFjMmE0MGE4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhbGtpbmcgT24gQSBEcmVhbSAoQkxPTkQ6SVNIIFJlbWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDctMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRGemw5Y29vcGhqQWV6RVYwdjd0UnUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJpZCI6IjY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJuYW1lIjoiRW1waXJlIE9mIFRoZSBTdW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyJ9LHsiZXh0ZXJuYQ==", + "bF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZ6c0pqb0N0TDFXQnlHMFZzdUZXelIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNnpzSmpvQ3RMMVdCeUcwVnN1Rld6UiIsImlkIjoiNnpzSmpvQ3RMMVdCeUcwVnN1Rld6UiIsIm5hbWUiOiJCTE9ORDpJU0giLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnpzSmpvQ3RMMVdCeUcwVnN1Rld6UiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTE4NDksImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJBVTJEWTI1MDAyMTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVvT0tVNFJpQU15cVVvT0tJQ2I5MmoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81b09LVTRSaUFNeXFVb09LSUNiOTJqIiwiaWQiOiI1b09LVTRSaUFNeXFVb09LSUNiOTJqIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhbGtpbmcgT24gQSBEcmVhbSAtIEJMT05EOklTSCBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1b09LVTRSaUFNeXFVb09LSUNiOTJqIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyIsImlkIjoiNjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyIsIm5hbWUiOiJFbXBpcmUgT2YgVGhlIFN1biIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMUdvcUJSVVBaekJLdk1LWnhTUTFtcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFHb3FCUlVQWnpCS3ZNS1p4U1ExbXAiLCJpZCI6IjFHb3FCUlVQWnpCS3ZNS1p4U1ExbXAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmZmYmM2YmI4ZjQwNWMyZGFjZjhkNjRiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZmZmJjNmJiOA==", + "ZjQwNWMyZGFjZjhkNjRiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmZmZiYzZiYjhmNDA1YzJkYWNmOGQ2NGIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2Fsa2luZyBPbiBBIERyZWFtIChTcGVjaWFsIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAwOS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFHb3FCUlVQWnpCS3ZNS1p4U1ExbXAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJpZCI6IjY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJuYW1lIjoiRW1waXJlIE9mIFRoZSBTdW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTg0NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJBVUVJMTA4MDAwMzkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZBNnFCRkpIaWQ0V3V0UXU2SEhFWnQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82QTZxQkZKSGlkNFd1dFF1NkhIRVp0IiwiaWQiOiI2QTZxQkZKSGlkNFd1dFF1NkhIRVp0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhbGtpbmcgT24gQSBEcmVhbSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2QTZxQkZKSGlkNFd1dFF1NkhIRVp0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJpZCI6IjY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJuYW1lIjoiRW1waXJlIE9mIFRoZSBTdW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLg==", + "c3BvdGlmeS5jb20vYWxidW0vNUJoM2prZGZoMmJwNktYaVFxNHlRcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVCaDNqa2RmaDJicDZLWGlRcTR5UXAiLCJpZCI6IjVCaDNqa2RmaDJicDZLWGlRcTR5UXAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzNkMjk4YmJhMWI2Yzc0NzhhYjNiZDY1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjMzZDI5OGJiYTFiNmM3NDc4YWIzYmQ2NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzNkMjk4YmJhMWI2Yzc0NzhhYjNiZDY1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhbGtpbmcgT24gQSBEcmVhbSAoUmVpbWFnaW5lZCkiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA5LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1QmgzamtkZmgyYnA2S1hpUXE0eVFwIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIiwiaWQiOiI2N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIiwibmFtZSI6IkVtcGlyZSBPZiBUaGUgU3VuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjY3aGI3dG93RXlLdnQ1WjhCeDMwNmMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk2MTU1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiQVVFSTEwODAwMDM5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80dXdoU0lXbDRBVWtxT3doTmFFT0xuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNHV3aFNJV2w0QVVrcU93aE5hRU9MbiIsImlkIjoiNHV3aFNJV2w0QVVrcU93aE5hRU9MbiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWxraW5nIE9uIEEgRHJlYW0iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NHV3aFNJV2w0QVVrcU93aE5hRU9MbiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aQ==", + "b24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZKdkw4c2VGdFpTYXFNMUxHRHhUOXoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82SnZMOHNlRnRaU2FxTTFMR0R4VDl6IiwiaWQiOiI2SnZMOHNlRnRaU2FxTTFMR0R4VDl6IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzJmN2ZkNTY0M2ZiNzkzNDNmZjkzYTI5ZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyZjdmZDU2NDNmYjc5MzQzZmY5M2EyOWQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJmN2ZkNTY0M2ZiNzkzNDNmZjkzYTI5ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEYW5jaW5nIFNvbmdzIEZvciBLaWRzIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wOS0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZKdkw4c2VGdFpTYXFNMUxHRHhUOXoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJpZCI6IjY3aGI3dG93RXlLdnQ1WjhCeDMwNmMiLCJuYW1lIjoiRW1waXJlIE9mIFRoZSBTdW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTg0NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJBVUVJMTA4MDAwMzkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Lw==", + "L29wZW4uc3BvdGlmeS5jb20vdHJhY2svMDFpSHZxS3dmUDJjRlMyeEdpNHJQaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzAxaUh2cUt3ZlAyY0ZTMnhHaTRyUGoiLCJpZCI6IjAxaUh2cUt3ZlAyY0ZTMnhHaTRyUGoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2Fsa2luZyBPbiBBIERyZWFtIiwidHJhY2tfbnVtYmVyIjoxNiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowMWlIdnFLd2ZQMmNGUzJ4R2k0clBqIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJWdngzZlAzenpkVDdQa2lKd1VkMUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yVnZ4M2ZQM3p6ZFQ3UGtpSndVZDFBIiwiaWQiOiIyVnZ4M2ZQM3p6ZFQ3UGtpSndVZDFBIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ZiOWU5ZTE3NDQwODRlZTY1NWE1OTJlMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmYjllOWUxNzQ0MDg0ZWU2NTVhNTkyZTAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWZiOWU5ZTE3NDQwODRlZTY1NWE1OTJlMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW1tZXIgVmFjYXRpb24iLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA1LTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MlZ2eDNmUDN6emRUN1BraUp3VWQxQSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMifSwiaA==", + "cmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIiwiaWQiOiI2N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIiwibmFtZSI6IkVtcGlyZSBPZiBUaGUgU3VuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjY3aGI3dG93RXlLdnQ1WjhCeDMwNmMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk4NDQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiQVVFSTEwODAwMDM5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82cEtXd0p2ODZBcmRrazZzeTVLZUpGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNnBLV3dKdjg2QXJka2s2c3k1S2VKRiIsImlkIjoiNnBLV3dKdjg2QXJka2s2c3k1S2VKRiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYWxraW5nIE9uIEEgRHJlYW0iLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NnBLV3dKdjg2QXJka2s2c3k1S2VKRiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zOUJYMkVqUkNudEpteW5PTXBTSnN6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMzlCWDJFalJDbnRKbXluT01wU0pzeiIsImlkIjoiMzlCWDJFalJDbnRKbXluT01wU0pzeiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhNDdkYzc3N2Q2MjI4NzllMzMxNDFhZTIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTQ3ZGM3NzdkNjIyODc5ZTMzMTQxYWUyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMA==", + "NDg1MWE0N2RjNzc3ZDYyMjg3OWUzMzE0MWFlMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiIwMHMgSG91c2UgUGFydHkiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA2LTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MzlCWDJFalJDbnRKbXluT01wU0pzeiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyIsImlkIjoiNjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyIsIm5hbWUiOiJFbXBpcmUgT2YgVGhlIFN1biIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5ODQ0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkFVRUkxMDgwMDAzOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMWprUFhRYmpZazdsMVNRNkJFbUlmNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFqa1BYUWJqWWs3bDFTUTZCRW1JZjYiLCJpZCI6IjFqa1BYUWJqWWs3bDFTUTZCRW1JZjYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2Fsa2luZyBPbiBBIERyZWFtIiwidHJhY2tfbnVtYmVyIjoxNywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxamtQWFFiallrN2wxU1E2QkVtSWY2In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNCUlpIaU5RaXYwdDd4NmtWdXpGd3EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zQlJaSGlOUWl2MHQ3eDZrVg==", + "dXpGd3EiLCJpZCI6IjNCUlpIaU5RaXYwdDd4NmtWdXpGd3EiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDc3YTU0ODBiZjYzM2I3MjZkZTgzYjNmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQ3N2E1NDgwYmY2MzNiNzI2ZGU4M2IzZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDc3YTU0ODBiZjYzM2I3MjZkZTgzYjNmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhvdXNlIFBhcnR5IEphbXMiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTAzLTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0JSWkhpTlFpdjB0N3g2a1Z1ekZ3cSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzY3aGI3dG93RXlLdnQ1WjhCeDMwNmMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyIsImlkIjoiNjdoYjd0b3dFeUt2dDVaOEJ4MzA2YyIsIm5hbWUiOiJFbXBpcmUgT2YgVGhlIFN1biIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2N2hiN3Rvd0V5S3Z0NVo4QngzMDZjIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5ODQ0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkFVRUkxMDgwMDAzOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM3hWYUpmZDI3bjRTNlpab3lHWVg0SCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzN4VmFKZmQyN240UzZaWm95R1lYNEgiLCJpZCI6IjN4VmFKZmQyN240UzZaWm95R1lYNEgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2Fsa2luZyBPbiBBIERyZWFtIiwidHJhY2tfbnVtYmVyIjozNiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozeFZhSmZkMjduNFM2WlpveUdZWDRIIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Walking+On+A+Dream%22+artist%3A%22Empire+Of+The+Sun%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Didn%27t%20I%20Blow%20Your%20Mind%20This%20Time%20The%20Delfonics&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Didn%27t%20I%20Blow%20Your%20Mind%20This%20Time%20The%20Delfonics&type=track","offset":0,"previous":null,"total":13,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Ie6D0KslXxrbkOAr5sbyX"},"href":"https://api.spotify.com/v1/albums/6Ie6D0KslXxrbkOAr5sbyX","id":"6Ie6D0KslXxrbkOAr5sbyX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f606a66ae319776c0dc86ce8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f606a66ae319776c0dc86ce8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f606a66ae319776c0dc86ce8"}],"is_playable":true,"name":"The Delfonics","release_date":"1970","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:6Ie6D0KslXxrbkOAr5sbyX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":201066,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/1NeKY4qWsCnhY8fvhwQa7q"},"href":"https://api.spotify.com/v1/tracks/1NeKY4qWsCnhY8fvhwQa7q","id":"1NeKY4qWsCnhY8fvhwQa7q","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":1,"type":"track","uri":"spotify:track:1NeKY4qWsCnhY8fvhwQa7q"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/661re5NCCdkxHaCG3xv8k5"},"href":"https://api.spotify.com/v1/albums/661re5NCCdkxHaCG3xv8k5","id":"661re5NCCdkxHaCG3xv8k5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738f94e3897d30ea450e10558f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028f94e3897d30ea450e10558f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518f94e3897d30ea450e10558f"}],"is_playable":true,"name":"La-La Means I Love You","release_date":"1997-08-25","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:661re5NCCdkxHaCG3xv8k5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":201293,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/0mJc5rDPSctw9RY46TOm5A"},"href":"https://api.spotify.com/v1/tracks/0mJc5rDPSctw9RY46TOm5A","id":"0mJc5rDPSctw9RY46TOm5A","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":9,"type":"track","uri":"spotify:track:0mJc5rDPSctw9RY46TOm5A"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/47I69OChJY93PaFpCRhS31"},"href":"https://api.spotify.com/v1/albums/47I69OChJY93PaFpCRhS31","id":"47I69OChJY93PaFpCRhS31","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dfbdf98869da083c15e52998"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dfbdf98869da083c15e52998"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dfbdf98869da083c15e52998"}],"is_playable":true,"name":"Love Songs","release_date":"2005-01-11","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:47I69OChJY93PaFpCRhS31"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":202960,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/3siowA42NaMMsPGF5lxi3T"},"href":"https://api.spotify.com/v1/tracks/3siowA42NaMMsPGF5lxi3T","id":"3siowA42NaMMsPGF5lxi3T","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":5,"type":"track","uri":"spotify:track:3siowA42NaMMsPGF5lxi3T"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/1wpMIDLFtpz8xrm37qY5MG"},"href":"https://api.spotify.com/v1/albums/1wpMIDLFtpz8xrm37qY5MG","id":"1wpMIDLFtpz8xrm37qY5MG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27338c72ef83fe47f29c5cfb886"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0238c72ef83fe47f29c5cfb886"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485138c72ef83fe47f29c5cfb886"}],"is_playable":true,"name":"The Very Best Of","release_date":"2003-05-05","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1wpMIDLFtpz8xrm37qY5MG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":199200,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/3l4YrJeHWK3E6Xf7q0YKWa"},"href":"https://api.spotify.com/v1/tracks/3l4YrJeHWK3E6Xf7q0YKWa","id":"3l4YrJeHWK3E6Xf7q0YKWa","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":4,"type":"track","uri":"spotify:track:3l4YrJeHWK3E6Xf7q0YKWa"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1WzKyOIFW45U8ZSuLVHGLq"},"href":"https://api.spotify.com/v1/albums/1WzKyOIFW45U8ZSuLVHGLq","id":"1WzKyOIFW45U8ZSuLVHGLq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bba5e4bfeadbe0950c12a26f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bba5e4bfeadbe0950c12a26f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bba5e4bfeadbe0950c12a26f"}],"is_playable":true,"name":"Sunday Morning","release_date":"2010-12-17","release_date_precision":"day","total_tracks":60,"type":"album","uri":"spotify:album:1WzKyOIFW45U8ZSuLVHGLq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":202960,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/2WIJDjBIQvHJc7REEwNkUX"},"href":"https://api.spotify.com/v1/tracks/2WIJDjBIQvHJc7REEwNkUX","id":"2WIJDjBIQvHJc7REEwNkUX","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":36,"type":"track","uri":"spotify:track:2WIJDjBIQvHJc7REEwNkUX"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3cceuam4ZfqSSC4uVchxvx"},"href":"https://api.spotify.com/v1/albums/3cceuam4ZfqSSC4uVchxvx","id":"3cceuam4ZfqSSC4uVchxvx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c59e912a41f34db94c75c828"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c59e912a41f34db94c75c828"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c59e912a41f34db94c75c828"}],"is_playable":true,"name":"Pure... '60s","release_date":"2012-03-26","release_date_precision":"day","total_tracks":68,"type":"album","uri":"spotify:album:3cceuam4ZfqSSC4uVchxvx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":2,"duration_ms":200253,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/0gaGF4jHKazwQYDbDvTjcq"},"href":"https://api.spotify.com/v1/tracks/0gaGF4jHKazwQYDbDvTjcq","id":"0gaGF4jHKazwQYDbDvTjcq","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":15,"type":"track","uri":"spotify:track:0gaGF4jHKazwQYDbDvTjcq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/04tK29LMKmr4HT2vQ8jFc2"},"href":"https://api.spotify.com/v1/albums/04tK29LMKmr4HT2vQ8jFc2","id":"04tK29LMKmr4HT2vQ8jFc2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273862fdb6694b395a35539a619"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02862fdb6694b395a35539a619"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851862fdb6694b395a35539a619"}],"is_playable":true,"name":"The Delfonics","release_date":"1970","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:04tK29LMKmr4HT2vQ8jFc2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":201066,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/0tgO0bgQzgzk07QSPYtqBl"},"href":"https://api.spotify.com/v1/tracks/0tgO0bgQzgzk07QSPYtqBl","id":"0tgO0bgQzgzk07QSPYtqBl","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":1,"type":"track","uri":"spotify:track:0tgO0bgQzgzk07QSPYtqBl"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5fbhwqYYh4YwUoEs582mq5"},"href":"https://api.spotify.com/v1/artists/5fbhwqYYh4YwUoEs582mq5","id":"5fbhwqYYh4YwUoEs582mq5","name":"The Spinners","type":"artist","uri":"spotify:artist:5fbhwqYYh4YwUoEs582mq5"}],"external_urls":{"spotify":"https://open.spotify.com/album/5PyOMtVxqztMvIKsJLV8bW"},"href":"https://api.spotify.com/v1/albums/5PyOMtVxqztMvIKsJLV8bW","id":"5PyOMtVxqztMvIKsJLV8bW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27371babe239c18fc21b5e2f0f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0271babe239c18fc21b5e2f0f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485171babe239c18fc21b5e2f0f5"}],"is_playable":true,"name":"The Rubberband Man / Now That We're Together","release_date":"1976","release_date_precision":"year","total_tracks":2,"type":"album","uri":"spotify:album:5PyOMtVxqztMvIKsJLV8bW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5fbhwqYYh4YwUoEs582mq5"},"href":"https://api.spotify.com/v1/artists/5fbhwqYYh4YwUoEs582mq5","id":"5fbhwqYYh4YwUoEs582mq5","name":"The Spinners","type":"artist","uri":"spotify:artist:5fbhwqYYh4YwUoEs582mq5"}],"disc_number":1,"duration_ms":213000,"explicit":false,"external_ids":{"isrc":"USAT20902284"},"external_urls":{"spotify":"https://open.spotify.com/track/13Mzsb8VzRSZ5w3pM48cn6"},"href":"https://api.spotify.com/v1/tracks/13Mzsb8VzRSZ5w3pM48cn6","id":"13Mzsb8VzRSZ5w3pM48cn6","is_local":false,"is_playable":true,"name":"The Rubberband Man","track_number":1,"type":"track","uri":"spotify:track:13Mzsb8VzRSZ5w3pM48cn6"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1HT9k1ZSUL9IczSstOAgWJ"},"href":"https://api.spotify.com/v1/artists/1HT9k1ZSUL9IczSstOAgWJ","id":"1HT9k1ZSUL9IczSstOAgWJ","name":"Roger Sanchez","type":"artist","uri":"spotify:artist:1HT9k1ZSUL9IczSstOAgWJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/1QOKjXA15loxIF16SoIDX1"},"href":"https://api.spotify.com/v1/albums/1QOKjXA15loxIF16SoIDX1","id":"1QOKjXA15loxIF16SoIDX1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27329aca3e1ca6d31e8d44e2b77"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0229aca3e1ca6d31e8d44e2b77"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485129aca3e1ca6d31e8d44e2b77"}],"is_playable":true,"name":"Again","release_date":"2006-06-27","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1QOKjXA15loxIF16SoIDX1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1HT9k1ZSUL9IczSstOAgWJ"},"href":"https://api.spotify.com/v1/artists/1HT9k1ZSUL9IczSstOAgWJ","id":"1HT9k1ZSUL9IczSstOAgWJ","name":"Roger Sanchez","type":"artist","uri":"spotify:artist:1HT9k1ZSUL9IczSstOAgWJ"}],"disc_number":1,"duration_ms":363426,"explicit":false,"external_ids":{"isrc":"NLQ200600031"},"external_urls":{"spotify":"https://open.spotify.com/track/1te1tkSJOUJwMxq6nNqie0"},"href":"https://api.spotify.com/v1/tracks/1te1tkSJOUJwMxq6nNqie0","id":"1te1tkSJOUJwMxq6nNqie0","is_local":false,"is_playable":true,"name":"Again","track_number":1,"type":"track","uri":"spotify:track:1te1tkSJOUJwMxq6nNqie0"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4tk2WUKBOS9nKZj7bPQIXT"},"href":"https://api.spotify.com/v1/artists/4tk2WUKBOS9nKZj7bPQIXT","id":"4tk2WUKBOS9nKZj7bPQIXT","name":"Na\u00efka","type":"artist","uri":"spotify:artist:4tk2WUKBOS9nKZj7bPQIXT"}],"external_urls":{"spotify":"https://open.spotify.com/album/0C4vvGEY9q6eUYBqfknbkv"},"href":"https://api.spotify.com/v1/albums/0C4vvGEY9q6eUYBqfknbkv","id":"0C4vvGEY9q6eUYBqfknbkv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cbdbcb5f5f207d4d4a0516b6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cbdbcb5f5f207d4d4a0516b6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cbdbcb5f5f207d4d4a0516b6"}],"is_playable":true,"name":"Lost in Parad\u00efse, Pt. 2","release_date":"2021-06-25","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:0C4vvGEY9q6eUYBqfknbkv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4tk2WUKBOS9nKZj7bPQIXT"},"href":"https://api.spotify.com/v1/artists/4tk2WUKBOS9nKZj7bPQIXT","id":"4tk2WUKBOS9nKZj7bPQIXT","name":"Na\u00efka","type":"artist","uri":"spotify:artist:4tk2WUKBOS9nKZj7bPQIXT"}],"disc_number":1,"duration_ms":126583,"explicit":true,"external_ids":{"isrc":"GBKPL2031414"},"external_urls":{"spotify":"https://open.spotify.com/track/4zVVvZIJSf4QjQYxXj95vp"},"href":"https://api.spotify.com/v1/tracks/4zVVvZIJSf4QjQYxXj95vp","id":"4zVVvZIJSf4QjQYxXj95vp","is_local":false,"is_playable":true,"name":"Sauce","track_number":1,"type":"track","uri":"spotify:track:4zVVvZIJSf4QjQYxXj95vp"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Didn%27t%20I%20Blow%20Your%20Mind%20This%20Time%20The%20Delfonics&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Didn%27t%20I%20Blow%20Your%20Mind%20This%20Time%20The%20Delfonics&type=track","offset":0,"previous":null,"total":13,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Ie6D0KslXxrbkOAr5sbyX"},"href":"https://api.spotify.com/v1/albums/6Ie6D0KslXxrbkOAr5sbyX","id":"6Ie6D0KslXxrbkOAr5sbyX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f606a66ae319776c0dc86ce8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f606a66ae319776c0dc86ce8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f606a66ae319776c0dc86ce8"}],"is_playable":true,"name":"The Delfonics","release_date":"1970","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:6Ie6D0KslXxrbkOAr5sbyX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":201066,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/1NeKY4qWsCnhY8fvhwQa7q"},"href":"https://api.spotify.com/v1/tracks/1NeKY4qWsCnhY8fvhwQa7q","id":"1NeKY4qWsCnhY8fvhwQa7q","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":1,"type":"track","uri":"spotify:track:1NeKY4qWsCnhY8fvhwQa7q"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/661re5NCCdkxHaCG3xv8k5"},"href":"https://api.spotify.com/v1/albums/661re5NCCdkxHaCG3xv8k5","id":"661re5NCCdkxHaCG3xv8k5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738f94e3897d30ea450e10558f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028f94e3897d30ea450e10558f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518f94e3897d30ea450e10558f"}],"is_playable":true,"name":"La-La Means I Love You","release_date":"1997-08-25","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:661re5NCCdkxHaCG3xv8k5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":201293,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/0mJc5rDPSctw9RY46TOm5A"},"href":"https://api.spotify.com/v1/tracks/0mJc5rDPSctw9RY46TOm5A","id":"0mJc5rDPSctw9RY46TOm5A","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":9,"type":"track","uri":"spotify:track:0mJc5rDPSctw9RY46TOm5A"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/47I69OChJY93PaFpCRhS31"},"href":"https://api.spotify.com/v1/albums/47I69OChJY93PaFpCRhS31","id":"47I69OChJY93PaFpCRhS31","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dfbdf98869da083c15e52998"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dfbdf98869da083c15e52998"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dfbdf98869da083c15e52998"}],"is_playable":true,"name":"Love Songs","release_date":"2005-01-11","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:47I69OChJY93PaFpCRhS31"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":202960,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/3siowA42NaMMsPGF5lxi3T"},"href":"https://api.spotify.com/v1/tracks/3siowA42NaMMsPGF5lxi3T","id":"3siowA42NaMMsPGF5lxi3T","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":5,"type":"track","uri":"spotify:track:3siowA42NaMMsPGF5lxi3T"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/1wpMIDLFtpz8xrm37qY5MG"},"href":"https://api.spotify.com/v1/albums/1wpMIDLFtpz8xrm37qY5MG","id":"1wpMIDLFtpz8xrm37qY5MG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27338c72ef83fe47f29c5cfb886"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0238c72ef83fe47f29c5cfb886"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485138c72ef83fe47f29c5cfb886"}],"is_playable":true,"name":"The Very Best Of","release_date":"2003-05-05","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1wpMIDLFtpz8xrm37qY5MG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":199200,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/3l4YrJeHWK3E6Xf7q0YKWa"},"href":"https://api.spotify.com/v1/tracks/3l4YrJeHWK3E6Xf7q0YKWa","id":"3l4YrJeHWK3E6Xf7q0YKWa","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":4,"type":"track","uri":"spotify:track:3l4YrJeHWK3E6Xf7q0YKWa"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1WzKyOIFW45U8ZSuLVHGLq"},"href":"https://api.spotify.com/v1/albums/1WzKyOIFW45U8ZSuLVHGLq","id":"1WzKyOIFW45U8ZSuLVHGLq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bba5e4bfeadbe0950c12a26f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bba5e4bfeadbe0950c12a26f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bba5e4bfeadbe0950c12a26f"}],"is_playable":true,"name":"Sunday Morning","release_date":"2010-12-17","release_date_precision":"day","total_tracks":60,"type":"album","uri":"spotify:album:1WzKyOIFW45U8ZSuLVHGLq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":202960,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/2WIJDjBIQvHJc7REEwNkUX"},"href":"https://api.spotify.com/v1/tracks/2WIJDjBIQvHJc7REEwNkUX","id":"2WIJDjBIQvHJc7REEwNkUX","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":36,"type":"track","uri":"spotify:track:2WIJDjBIQvHJc7REEwNkUX"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3cceuam4ZfqSSC4uVchxvx"},"href":"https://api.spotify.com/v1/albums/3cceuam4ZfqSSC4uVchxvx","id":"3cceuam4ZfqSSC4uVchxvx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c59e912a41f34db94c75c828"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c59e912a41f34db94c75c828"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c59e912a41f34db94c75c828"}],"is_playable":true,"name":"Pure... '60s","release_date":"2012-03-26","release_date_precision":"day","total_tracks":68,"type":"album","uri":"spotify:album:3cceuam4ZfqSSC4uVchxvx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":2,"duration_ms":200253,"explicit":false,"external_ids":{"isrc":"USAR19700077"},"external_urls":{"spotify":"https://open.spotify.com/track/0gaGF4jHKazwQYDbDvTjcq"},"href":"https://api.spotify.com/v1/tracks/0gaGF4jHKazwQYDbDvTjcq","id":"0gaGF4jHKazwQYDbDvTjcq","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":15,"type":"track","uri":"spotify:track:0gaGF4jHKazwQYDbDvTjcq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"external_urls":{"spotify":"https://open.spotify.com/album/04tK29LMKmr4HT2vQ8jFc2"},"href":"https://api.spotify.com/v1/albums/04tK29LMKmr4HT2vQ8jFc2","id":"04tK29LMKmr4HT2vQ8jFc2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273862fdb6694b395a35539a619"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02862fdb6694b395a35539a619"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851862fdb6694b395a35539a619"}],"is_playable":true,"name":"The Delfonics","release_date":"1970","release_date_precision":"year","total_tracks":10,"type":"album","uri":"spotify:album:04tK29LMKmr4HT2vQ8jFc2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6YPRXu1dazGYcSZv4HJEH4"},"href":"https://api.spotify.com/v1/artists/6YPRXu1dazGYcSZv4HJEH4","id":"6YPRXu1dazGYcSZv4HJEH4","name":"The Delfonics","type":"artist","uri":"spotify:artist:6YPRXu1dazGYcSZv4HJEH4"}],"disc_number":1,"duration_ms":201066,"explicit":false,"external_ids":{"isrc":"USAR19700271"},"external_urls":{"spotify":"https://open.spotify.com/track/0tgO0bgQzgzk07QSPYtqBl"},"href":"https://api.spotify.com/v1/tracks/0tgO0bgQzgzk07QSPYtqBl","id":"0tgO0bgQzgzk07QSPYtqBl","is_local":false,"is_playable":true,"name":"Didn't I (Blow Your Mind This Time)","track_number":1,"type":"track","uri":"spotify:track:0tgO0bgQzgzk07QSPYtqBl"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5fbhwqYYh4YwUoEs582mq5"},"href":"https://api.spotify.com/v1/artists/5fbhwqYYh4YwUoEs582mq5","id":"5fbhwqYYh4YwUoEs582mq5","name":"The Spinners","type":"artist","uri":"spotify:artist:5fbhwqYYh4YwUoEs582mq5"}],"external_urls":{"spotify":"https://open.spotify.com/album/5PyOMtVxqztMvIKsJLV8bW"},"href":"https://api.spotify.com/v1/albums/5PyOMtVxqztMvIKsJLV8bW","id":"5PyOMtVxqztMvIKsJLV8bW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27371babe239c18fc21b5e2f0f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0271babe239c18fc21b5e2f0f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485171babe239c18fc21b5e2f0f5"}],"is_playable":true,"name":"The Rubberband Man / Now That We're Together","release_date":"1976","release_date_precision":"year","total_tracks":2,"type":"album","uri":"spotify:album:5PyOMtVxqztMvIKsJLV8bW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5fbhwqYYh4YwUoEs582mq5"},"href":"https://api.spotify.com/v1/artists/5fbhwqYYh4YwUoEs582mq5","id":"5fbhwqYYh4YwUoEs582mq5","name":"The Spinners","type":"artist","uri":"spotify:artist:5fbhwqYYh4YwUoEs582mq5"}],"disc_number":1,"duration_ms":213000,"explicit":false,"external_ids":{"isrc":"USAT20902284"},"external_urls":{"spotify":"https://open.spotify.com/track/13Mzsb8VzRSZ5w3pM48cn6"},"href":"https://api.spotify.com/v1/tracks/13Mzsb8VzRSZ5w3pM48cn6","id":"13Mzsb8VzRSZ5w3pM48cn6","is_local":false,"is_playable":true,"name":"The Rubberband Man","track_number":1,"type":"track","uri":"spotify:track:13Mzsb8VzRSZ5w3pM48cn6"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1HT9k1ZSUL9IczSstOAgWJ"},"href":"https://api.spotify.com/v1/artists/1HT9k1ZSUL9IczSstOAgWJ","id":"1HT9k1ZSUL9IczSstOAgWJ","name":"Roger Sanchez","type":"artist","uri":"spotify:artist:1HT9k1ZSUL9IczSstOAgWJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/1QOKjXA15loxIF16SoIDX1"},"href":"https://api.spotify.com/v1/albums/1QOKjXA15loxIF16SoIDX1","id":"1QOKjXA15loxIF16SoIDX1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27329aca3e1ca6d31e8d44e2b77"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0229aca3e1ca6d31e8d44e2b77"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485129aca3e1ca6d31e8d44e2b77"}],"is_playable":true,"name":"Again","release_date":"2006-06-27","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1QOKjXA15loxIF16SoIDX1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1HT9k1ZSUL9IczSstOAgWJ"},"href":"https://api.spotify.com/v1/artists/1HT9k1ZSUL9IczSstOAgWJ","id":"1HT9k1ZSUL9IczSstOAgWJ","name":"Roger Sanchez","type":"artist","uri":"spotify:artist:1HT9k1ZSUL9IczSstOAgWJ"}],"disc_number":1,"duration_ms":363426,"explicit":false,"external_ids":{"isrc":"NLQ200600031"},"external_urls":{"spotify":"https://open.spotify.com/track/1te1tkSJOUJwMxq6nNqie0"},"href":"https://api.spotify.com/v1/tracks/1te1tkSJOUJwMxq6nNqie0","id":"1te1tkSJOUJwMxq6nNqie0","is_local":false,"is_playable":true,"name":"Again","track_number":1,"type":"track","uri":"spotify:track:1te1tkSJOUJwMxq6nNqie0"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4tk2WUKBOS9nKZj7bPQIXT"},"href":"https://api.spotify.com/v1/artists/4tk2WUKBOS9nKZj7bPQIXT","id":"4tk2WUKBOS9nKZj7bPQIXT","name":"Na\u00efka","type":"artist","uri":"spotify:artist:4tk2WUKBOS9nKZj7bPQIXT"}],"external_urls":{"spotify":"https://open.spotify.com/album/0C4vvGEY9q6eUYBqfknbkv"},"href":"https://api.spotify.com/v1/albums/0C4vvGEY9q6eUYBqfknbkv","id":"0C4vvGEY9q6eUYBqfknbkv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cbdbcb5f5f207d4d4a0516b6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cbdbcb5f5f207d4d4a0516b6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cbdbcb5f5f207d4d4a0516b6"}],"is_playable":true,"name":"Lost in Parad\u00efse, Pt. 2","release_date":"2021-06-25","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:0C4vvGEY9q6eUYBqfknbkv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4tk2WUKBOS9nKZj7bPQIXT"},"href":"https://api.spotify.com/v1/artists/4tk2WUKBOS9nKZj7bPQIXT","id":"4tk2WUKBOS9nKZj7bPQIXT","name":"Na\u00efka","type":"artist","uri":"spotify:artist:4tk2WUKBOS9nKZj7bPQIXT"}],"disc_number":1,"duration_ms":126583,"explicit":true,"external_ids":{"isrc":"GBKPL2031414"},"external_urls":{"spotify":"https://open.spotify.com/track/4zVVvZIJSf4QjQYxXj95vp"},"href":"https://api.spotify.com/v1/tracks/4zVVvZIJSf4QjQYxXj95vp","id":"4zVVvZIJSf4QjQYxXj95vp","is_local":false,"is_playable":true,"name":"Sauce","track_number":1,"type":"track","uri":"spotify:track:4zVVvZIJSf4QjQYxXj95vp"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Didn%27t+I+Blow+Your+Mind+This+Time+The+Delfonics&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRlcHRoJTIwQ29lZmZpY2llbnQlMjBBY2lkJTIyJTIwYXJ0aXN0JTNBJTIyQ0hSUyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1M3VmxpRTVvRVBuUlgwVU1qNzV5NSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zUzdWbGlFNW9FUG5SWDBVTWo3NXk1IiwiaWQiOiIzUzdWbGlFNW9FUG5SWDBVTWo3NXk1IiwibmFtZSI6IkNIUlMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1M3VmxpRTVvRVBuUlgwVU1qNzV5NSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBLdG1hNGx4TFVIQlZJTXZnTFZqd3EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wS3RtYTRseExVSEJWSU12Z0xWandxIiwiaWQiOiIwS3RtYTRseExVSEJWSU12Z0xWandxIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZA==", + "bi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmNkNWU3NjIwMWVkNmMyODZjY2E5MGFmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZjZDVlNzYyMDFlZDZjMjg2Y2NhOTBhZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmNkNWU3NjIwMWVkNmMyODZjY2E5MGFmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlcHRoIENvZWZmaWNpZW50IEFjaWQiLCJyZWxlYXNlX2RhdGUiOiIyMDIyLTAyLTE0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowS3RtYTRseExVSEJWSU12Z0xWandxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1M3VmxpRTVvRVBuUlgwVU1qNzV5NSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zUzdWbGlFNW9FUG5SWDBVTWo3NXk1IiwiaWQiOiIzUzdWbGlFNW9FUG5SWDBVTWo3NXk1IiwibmFtZSI6IkNIUlMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1M3VmxpRTVvRVBuUlgwVU1qNzV5NSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyODczNjgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWjVGTjIyMzkyOTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRubmFDQWk0SWp5WGtlMzlFZ1N1MDkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80bm5hQ0FpNElqeVhrZTM5RWdTdTA5IiwiaWQiOiI0bm5hQ0FpNElqeVhrZTM5RWdTdTA5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlcHRoIENvZWZmaWNpZW50IEFjaWQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NG5uYUNBaTRJanlYa2UzOUVnU3UwOSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Depth+Coefficient+Acid%22+artist%3A%22CHRS%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Twilight%22%20artist%3A%22Gray%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Ve4sev1tC5CGEeP5fUb5Y"},"href":"https://api.spotify.com/v1/artists/2Ve4sev1tC5CGEeP5fUb5Y","id":"2Ve4sev1tC5CGEeP5fUb5Y","name":"Gray","type":"artist","uri":"spotify:artist:2Ve4sev1tC5CGEeP5fUb5Y"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Jv2F8VFJsSr2XKte0vpbQ"},"href":"https://api.spotify.com/v1/artists/1Jv2F8VFJsSr2XKte0vpbQ","id":"1Jv2F8VFJsSr2XKte0vpbQ","name":"A Little Sound","type":"artist","uri":"spotify:artist:1Jv2F8VFJsSr2XKte0vpbQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/1TeqYcuFr4x3DHdypacMep"},"href":"https://api.spotify.com/v1/albums/1TeqYcuFr4x3DHdypacMep","id":"1TeqYcuFr4x3DHdypacMep","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27397f3dd2c4226d3f7228e6a13"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0297f3dd2c4226d3f7228e6a13"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485197f3dd2c4226d3f7228e6a13"}],"is_playable":true,"name":"Twilight","release_date":"2022-07-08","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1TeqYcuFr4x3DHdypacMep"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Ve4sev1tC5CGEeP5fUb5Y"},"href":"https://api.spotify.com/v1/artists/2Ve4sev1tC5CGEeP5fUb5Y","id":"2Ve4sev1tC5CGEeP5fUb5Y","name":"Gray","type":"artist","uri":"spotify:artist:2Ve4sev1tC5CGEeP5fUb5Y"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Jv2F8VFJsSr2XKte0vpbQ"},"href":"https://api.spotify.com/v1/artists/1Jv2F8VFJsSr2XKte0vpbQ","id":"1Jv2F8VFJsSr2XKte0vpbQ","name":"A Little Sound","type":"artist","uri":"spotify:artist:1Jv2F8VFJsSr2XKte0vpbQ"}],"disc_number":1,"duration_ms":207558,"explicit":false,"external_ids":{"isrc":"GB8KE2206756"},"external_urls":{"spotify":"https://open.spotify.com/track/2ezzmll94GbaXehnUx6j2h"},"href":"https://api.spotify.com/v1/tracks/2ezzmll94GbaXehnUx6j2h","id":"2ezzmll94GbaXehnUx6j2h","is_local":false,"is_playable":true,"name":"Twilight","track_number":1,"type":"track","uri":"spotify:track:2ezzmll94GbaXehnUx6j2h"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Ve4sev1tC5CGEeP5fUb5Y"},"href":"https://api.spotify.com/v1/artists/2Ve4sev1tC5CGEeP5fUb5Y","id":"2Ve4sev1tC5CGEeP5fUb5Y","name":"Gray","type":"artist","uri":"spotify:artist:2Ve4sev1tC5CGEeP5fUb5Y"}],"external_urls":{"spotify":"https://open.spotify.com/album/7wCwaXGg27kACIkAwEco3T"},"href":"https://api.spotify.com/v1/albums/7wCwaXGg27kACIkAwEco3T","id":"7wCwaXGg27kACIkAwEco3T","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27351afd09a355b61105fc88a6c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0251afd09a355b61105fc88a6c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485151afd09a355b61105fc88a6c"}],"is_playable":true,"name":"Digital Nomad","release_date":"2024-05-30","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:7wCwaXGg27kACIkAwEco3T"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Ve4sev1tC5CGEeP5fUb5Y"},"href":"https://api.spotify.com/v1/artists/2Ve4sev1tC5CGEeP5fUb5Y","id":"2Ve4sev1tC5CGEeP5fUb5Y","name":"Gray","type":"artist","uri":"spotify:artist:2Ve4sev1tC5CGEeP5fUb5Y"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Jv2F8VFJsSr2XKte0vpbQ"},"href":"https://api.spotify.com/v1/artists/1Jv2F8VFJsSr2XKte0vpbQ","id":"1Jv2F8VFJsSr2XKte0vpbQ","name":"A Little Sound","type":"artist","uri":"spotify:artist:1Jv2F8VFJsSr2XKte0vpbQ"}],"disc_number":1,"duration_ms":190588,"explicit":false,"external_ids":{"isrc":"GB8KE2411060"},"external_urls":{"spotify":"https://open.spotify.com/track/7dD07t89ZgChaFTfJkrEH3"},"href":"https://api.spotify.com/v1/tracks/7dD07t89ZgChaFTfJkrEH3","id":"7dD07t89ZgChaFTfJkrEH3","is_local":false,"is_playable":true,"name":"Twilight - Comedown Mix","track_number":9,"type":"track","uri":"spotify:track:7dD07t89ZgChaFTfJkrEH3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Ve4sev1tC5CGEeP5fUb5Y"},"href":"https://api.spotify.com/v1/artists/2Ve4sev1tC5CGEeP5fUb5Y","id":"2Ve4sev1tC5CGEeP5fUb5Y","name":"Gray","type":"artist","uri":"spotify:artist:2Ve4sev1tC5CGEeP5fUb5Y"}],"external_urls":{"spotify":"https://open.spotify.com/album/74F7XPsgjCODv6v3r20DiZ"},"href":"https://api.spotify.com/v1/albums/74F7XPsgjCODv6v3r20DiZ","id":"74F7XPsgjCODv6v3r20DiZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731796abaed6f16b0e235ac0e4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021796abaed6f16b0e235ac0e4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511796abaed6f16b0e235ac0e4"}],"is_playable":true,"name":"Twilight (Comedown Mix)","release_date":"2024-05-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:74F7XPsgjCODv6v3r20DiZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Ve4sev1tC5CGEeP5fUb5Y"},"href":"https://api.spotify.com/v1/artists/2Ve4sev1tC5CGEeP5fUb5Y","id":"2Ve4sev1tC5CGEeP5fUb5Y","name":"Gray","type":"artist","uri":"spotify:artist:2Ve4sev1tC5CGEeP5fUb5Y"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Jv2F8VFJsSr2XKte0vpbQ"},"href":"https://api.spotify.com/v1/artists/1Jv2F8VFJsSr2XKte0vpbQ","id":"1Jv2F8VFJsSr2XKte0vpbQ","name":"A Little Sound","type":"artist","uri":"spotify:artist:1Jv2F8VFJsSr2XKte0vpbQ"}],"disc_number":1,"duration_ms":190588,"explicit":false,"external_ids":{"isrc":"GB8KE2411060"},"external_urls":{"spotify":"https://open.spotify.com/track/4CkYOtK09cdD2zuLo7j1Ot"},"href":"https://api.spotify.com/v1/tracks/4CkYOtK09cdD2zuLo7j1Ot","id":"4CkYOtK09cdD2zuLo7j1Ot","is_local":false,"is_playable":true,"name":"Twilight - Comedown Mix","track_number":1,"type":"track","uri":"spotify:track:4CkYOtK09cdD2zuLo7j1Ot"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Xq9CIMYWK4RCrMVtfEOM0"},"href":"https://api.spotify.com/v1/artists/6Xq9CIMYWK4RCrMVtfEOM0","id":"6Xq9CIMYWK4RCrMVtfEOM0","name":"Grayscale","type":"artist","uri":"spotify:artist:6Xq9CIMYWK4RCrMVtfEOM0"}],"external_urls":{"spotify":"https://open.spotify.com/album/5j86yI68MjgZLKaYsL6Sd7"},"href":"https://api.spotify.com/v1/albums/5j86yI68MjgZLKaYsL6Sd7","id":"5j86yI68MjgZLKaYsL6Sd7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27307cc7f4b0ead2e9ad77c38e3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0207cc7f4b0ead2e9ad77c38e3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485107cc7f4b0ead2e9ad77c38e3"}],"is_playable":true,"name":"Nella Vita","release_date":"2019-09-06","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5j86yI68MjgZLKaYsL6Sd7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Xq9CIMYWK4RCrMVtfEOM0"},"href":"https://api.spotify.com/v1/artists/6Xq9CIMYWK4RCrMVtfEOM0","id":"6Xq9CIMYWK4RCrMVtfEOM0","name":"Grayscale","type":"artist","uri":"spotify:artist:6Xq9CIMYWK4RCrMVtfEOM0"}],"disc_number":1,"duration_ms":161853,"explicit":false,"external_ids":{"isrc":"US5261923164"},"external_urls":{"spotify":"https://open.spotify.com/track/3EkFeBY9RmLIKxkJdXpGvi"},"href":"https://api.spotify.com/v1/tracks/3EkFeBY9RmLIKxkJdXpGvi","id":"3EkFeBY9RmLIKxkJdXpGvi","is_local":false,"is_playable":true,"name":"Twilight (My Heaven)","track_number":5,"type":"track","uri":"spotify:track:3EkFeBY9RmLIKxkJdXpGvi"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7pCfNMcSlUWQgBXbyoEcyO"},"href":"https://api.spotify.com/v1/artists/7pCfNMcSlUWQgBXbyoEcyO","id":"7pCfNMcSlUWQgBXbyoEcyO","name":"Solomon Grey","type":"artist","uri":"spotify:artist:7pCfNMcSlUWQgBXbyoEcyO"}],"external_urls":{"spotify":"https://open.spotify.com/album/0IZtT0c3qcrOFMpRm4oZpj"},"href":"https://api.spotify.com/v1/albums/0IZtT0c3qcrOFMpRm4oZpj","id":"0IZtT0c3qcrOFMpRm4oZpj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c3619ce6d89776bbfdf1313e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c3619ce6d89776bbfdf1313e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c3619ce6d89776bbfdf1313e"}],"is_playable":true,"name":"Twilight","release_date":"2015-09-04","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0IZtT0c3qcrOFMpRm4oZpj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7pCfNMcSlUWQgBXbyoEcyO"},"href":"https://api.spotify.com/v1/artists/7pCfNMcSlUWQgBXbyoEcyO","id":"7pCfNMcSlUWQgBXbyoEcyO","name":"Solomon Grey","type":"artist","uri":"spotify:artist:7pCfNMcSlUWQgBXbyoEcyO"}],"disc_number":1,"duration_ms":489155,"explicit":false,"external_ids":{"isrc":"GBUM71504799"},"external_urls":{"spotify":"https://open.spotify.com/track/6tbMFkGkkzhw6ZCIm04HWK"},"href":"https://api.spotify.com/v1/tracks/6tbMFkGkkzhw6ZCIm04HWK","id":"6tbMFkGkkzhw6ZCIm04HWK","is_local":false,"is_playable":true,"name":"Twilight - John Monkman Remix","track_number":1,"type":"track","uri":"spotify:track:6tbMFkGkkzhw6ZCIm04HWK"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7J2lZBANizgPNfUzux31PV"},"href":"https://api.spotify.com/v1/artists/7J2lZBANizgPNfUzux31PV","id":"7J2lZBANizgPNfUzux31PV","name":"David Gray","type":"artist","uri":"spotify:artist:7J2lZBANizgPNfUzux31PV"}],"external_urls":{"spotify":"https://open.spotify.com/album/48UQyt1mH1E6n1jy41cya1"},"href":"https://api.spotify.com/v1/albums/48UQyt1mH1E6n1jy41cya1","id":"48UQyt1mH1E6n1jy41cya1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27323833bee17676242b2800d6a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0223833bee17676242b2800d6a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485123833bee17676242b2800d6a"}],"is_playable":true,"name":"Lost Songs 95-98","release_date":"2001-02-12","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:48UQyt1mH1E6n1jy41cya1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7J2lZBANizgPNfUzux31PV"},"href":"https://api.spotify.com/v1/artists/7J2lZBANizgPNfUzux31PV","id":"7J2lZBANizgPNfUzux31PV","name":"David Gray","type":"artist","uri":"spotify:artist:7J2lZBANizgPNfUzux31PV"}],"disc_number":1,"duration_ms":143426,"explicit":false,"external_ids":{"isrc":"GBDLY0000013"},"external_urls":{"spotify":"https://open.spotify.com/track/3DGi4EbETrrxxk5rQ8wjw8"},"href":"https://api.spotify.com/v1/tracks/3DGi4EbETrrxxk5rQ8wjw8","id":"3DGi4EbETrrxxk5rQ8wjw8","is_local":false,"is_playable":true,"name":"Twilight","track_number":2,"type":"track","uri":"spotify:track:3DGi4EbETrrxxk5rQ8wjw8"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7pCfNMcSlUWQgBXbyoEcyO"},"href":"https://api.spotify.com/v1/artists/7pCfNMcSlUWQgBXbyoEcyO","id":"7pCfNMcSlUWQgBXbyoEcyO","name":"Solomon Grey","type":"artist","uri":"spotify:artist:7pCfNMcSlUWQgBXbyoEcyO"}],"external_urls":{"spotify":"https://open.spotify.com/album/7xGT9M9GMparBG3mGrevu6"},"href":"https://api.spotify.com/v1/albums/7xGT9M9GMparBG3mGrevu6","id":"7xGT9M9GMparBG3mGrevu6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739b1dcdacfa6496a928f38697"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029b1dcdacfa6496a928f38697"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519b1dcdacfa6496a928f38697"}],"is_playable":true,"name":"Selected Features","release_date":"2015-09-11","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:7xGT9M9GMparBG3mGrevu6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7pCfNMcSlUWQgBXbyoEcyO"},"href":"https://api.spotify.com/v1/artists/7pCfNMcSlUWQgBXbyoEcyO","id":"7pCfNMcSlUWQgBXbyoEcyO","name":"Solomon Grey","type":"artist","uri":"spotify:artist:7pCfNMcSlUWQgBXbyoEcyO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4QNgF0TQ7EsDvvEXjU9C42"},"href":"https://api.spotify.com/v1/artists/4QNgF0TQ7EsDvvEXjU9C42","id":"4QNgF0TQ7EsDvvEXjU9C42","name":"Imogen Rose","type":"artist","uri":"spotify:artist:4QNgF0TQ7EsDvvEXjU9C42"}],"disc_number":1,"duration_ms":191080,"explicit":false,"external_ids":{"isrc":"GBUM71503884"},"external_urls":{"spotify":"https://open.spotify.com/track/3cGrX9RhHPI4ACfw8X5ru9"},"href":"https://api.spotify.com/v1/tracks/3cGrX9RhHPI4ACfw8X5ru9","id":"3cGrX9RhHPI4ACfw8X5ru9","is_local":false,"is_playable":true,"name":"Twilight - Night Mix","track_number":1,"type":"track","uri":"spotify:track:3cGrX9RhHPI4ACfw8X5ru9"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/053q0ukIDRgzwTr4vNSwab"},"href":"https://api.spotify.com/v1/artists/053q0ukIDRgzwTr4vNSwab","id":"053q0ukIDRgzwTr4vNSwab","name":"Grimes","type":"artist","uri":"spotify:artist:053q0ukIDRgzwTr4vNSwab"}],"external_urls":{"spotify":"https://open.spotify.com/album/1Cog6aZ6NwnJiuINc0LQEU"},"href":"https://api.spotify.com/v1/albums/1Cog6aZ6NwnJiuINc0LQEU","id":"1Cog6aZ6NwnJiuINc0LQEU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730cc1e6acf31389f29ef8554c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020cc1e6acf31389f29ef8554c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510cc1e6acf31389f29ef8554c"}],"is_playable":true,"name":"Darkbloom","release_date":"2011-04-18","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:1Cog6aZ6NwnJiuINc0LQEU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/053q0ukIDRgzwTr4vNSwab"},"href":"https://api.spotify.com/v1/artists/053q0ukIDRgzwTr4vNSwab","id":"053q0ukIDRgzwTr4vNSwab","name":"Grimes","type":"artist","uri":"spotify:artist:053q0ukIDRgzwTr4vNSwab"}],"disc_number":1,"duration_ms":255634,"explicit":false,"external_ids":{"isrc":"CA21O1100016"},"external_urls":{"spotify":"https://open.spotify.com/track/5EhZC8GFOVXrpiUW22jncE"},"href":"https://api.spotify.com/v1/tracks/5EhZC8GFOVXrpiUW22jncE","id":"5EhZC8GFOVXrpiUW22jncE","is_local":false,"is_playable":true,"name":"Urban Twilight","track_number":4,"type":"track","uri":"spotify:track:5EhZC8GFOVXrpiUW22jncE"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7J2lZBANizgPNfUzux31PV"},"href":"https://api.spotify.com/v1/artists/7J2lZBANizgPNfUzux31PV","id":"7J2lZBANizgPNfUzux31PV","name":"David Gray","type":"artist","uri":"spotify:artist:7J2lZBANizgPNfUzux31PV"}],"external_urls":{"spotify":"https://open.spotify.com/album/65sInXAGtPmlmAtF6XXMnT"},"href":"https://api.spotify.com/v1/albums/65sInXAGtPmlmAtF6XXMnT","id":"65sInXAGtPmlmAtF6XXMnT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273559554a393f0118da27472f8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02559554a393f0118da27472f8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851559554a393f0118da27472f8"}],"is_playable":true,"name":"The Best of David Gray (Deluxe Edition)","release_date":"2016-10-28","release_date_precision":"day","total_tracks":31,"type":"album","uri":"spotify:album:65sInXAGtPmlmAtF6XXMnT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7J2lZBANizgPNfUzux31PV"},"href":"https://api.spotify.com/v1/artists/7J2lZBANizgPNfUzux31PV","id":"7J2lZBANizgPNfUzux31PV","name":"David Gray","type":"artist","uri":"spotify:artist:7J2lZBANizgPNfUzux31PV"}],"disc_number":2,"duration_ms":142129,"explicit":false,"external_ids":{"isrc":"GBDLY1600029"},"external_urls":{"spotify":"https://open.spotify.com/track/5SPBMf7PmPZqotdp1o2riO"},"href":"https://api.spotify.com/v1/tracks/5SPBMf7PmPZqotdp1o2riO","id":"5SPBMf7PmPZqotdp1o2riO","is_local":false,"is_playable":true,"name":"Twilight","track_number":10,"type":"track","uri":"spotify:track:5SPBMf7PmPZqotdp1o2riO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3G7E7yPTDYS13ZBnw1YG36"},"href":"https://api.spotify.com/v1/artists/3G7E7yPTDYS13ZBnw1YG36","id":"3G7E7yPTDYS13ZBnw1YG36","name":"Matthew Goodman","type":"artist","uri":"spotify:artist:3G7E7yPTDYS13ZBnw1YG36"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5wYhGh0fsLEUp5mh4z6UCC"},"href":"https://api.spotify.com/v1/artists/5wYhGh0fsLEUp5mh4z6UCC","id":"5wYhGh0fsLEUp5mh4z6UCC","name":"Kimberly Anne Sutherland","type":"artist","uri":"spotify:artist:5wYhGh0fsLEUp5mh4z6UCC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3u0EQPPjWPNlJRY6InCZkK"},"href":"https://api.spotify.com/v1/artists/3u0EQPPjWPNlJRY6InCZkK","id":"3u0EQPPjWPNlJRY6InCZkK","name":"Rhiannon Mair Gray","type":"artist","uri":"spotify:artist:3u0EQPPjWPNlJRY6InCZkK"}],"external_urls":{"spotify":"https://open.spotify.com/album/3wEKPKOhHVtamvwlHXZBvg"},"href":"https://api.spotify.com/v1/albums/3wEKPKOhHVtamvwlHXZBvg","id":"3wEKPKOhHVtamvwlHXZBvg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad65c6e1c2c15c720cfb581a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad65c6e1c2c15c720cfb581a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad65c6e1c2c15c720cfb581a"}],"is_playable":true,"name":"Soultronic - Fresh Vocal Neo-Soul","release_date":"2022-07-21","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:3wEKPKOhHVtamvwlHXZBvg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3u0EQPPjWPNlJRY6InCZkK"},"href":"https://api.spotify.com/v1/artists/3u0EQPPjWPNlJRY6InCZkK","id":"3u0EQPPjWPNlJRY6InCZkK","name":"Rhiannon Mair Gray","type":"artist","uri":"spotify:artist:3u0EQPPjWPNlJRY6InCZkK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5wYhGh0fsLEUp5mh4z6UCC"},"href":"https://api.spotify.com/v1/artists/5wYhGh0fsLEUp5mh4z6UCC","id":"5wYhGh0fsLEUp5mh4z6UCC","name":"Kimberly Anne Sutherland","type":"artist","uri":"spotify:artist:5wYhGh0fsLEUp5mh4z6UCC"}],"disc_number":1,"duration_ms":173742,"explicit":false,"external_ids":{"isrc":"GBWC72200499"},"external_urls":{"spotify":"https://open.spotify.com/track/4WwztmXjMXNmH6lRfG3kMs"},"href":"https://api.spotify.com/v1/tracks/4WwztmXjMXNmH6lRfG3kMs","id":"4WwztmXjMXNmH6lRfG3kMs","is_local":false,"is_playable":true,"name":"Twilight High","track_number":9,"type":"track","uri":"spotify:track:4WwztmXjMXNmH6lRfG3kMs"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlR3aWxpZ2h0JTIyJTIwYXJ0aXN0JTNBJTIyR3JheSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJWZTRzZXYxdEM1Q0dFZVA1ZlViNVkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlZlNHNldjF0QzVDR0VlUDVmVWI1WSIsImlkIjoiMlZlNHNldjF0QzVDR0VlUDVmVWI1WSIsIm5hbWUiOiJHcmF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJWZTRzZXYxdEM1Q0dFZVA1ZlViNVkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMUp2MkY4VkZKc1NyMlhLdGUwdnBiUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xSnYyRjhWRkpzU3IyWEt0ZTB2cGJRIiwiaWQiOiIxSnYyRjhWRkpzU3IyWEt0ZTB2cGJRIiwibmFtZSI6IkEgTGl0dGxlIFNvdW5kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFKdjJGOFZGSnNTcjJY", + "S3RlMHZwYlEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xVGVxWWN1RnI0eDNESGR5cGFjTWVwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVRlcVljdUZyNHgzREhkeXBhY01lcCIsImlkIjoiMVRlcVljdUZyNHgzREhkeXBhY01lcCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5N2YzZGQyYzQyMjZkM2Y3MjI4ZTZhMTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTdmM2RkMmM0MjI2ZDNmNzIyOGU2YTEzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5N2YzZGQyYzQyMjZkM2Y3MjI4ZTZhMTMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHdpbGlnaHQiLCJyZWxlYXNlX2RhdGUiOiIyMDIyLTA3LTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxVGVxWWN1RnI0eDNESGR5cGFjTWVwIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlZlNHNldjF0QzVDR0VlUDVmVWI1WSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVmU0c2V2MXRDNUNHRWVQNWZVYjVZIiwiaWQiOiIyVmU0c2V2MXRDNUNHRWVQNWZVYjVZIiwibmFtZSI6IkdyYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlZlNHNldjF0QzVDR0VlUDVmVWI1WSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xSnYyRjhWRkpzU3IyWEt0ZTB2cGJRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFKdjJGOFZGSnNTcjJYS3RlMHZwYlEiLCJpZCI6IjFKdjJGOFZGSnNTcjJYS3RlMHZwYlEiLCJuYW1lIjoiQSBMaXR0bGUgU291bmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUp2MkY4VkZKc1NyMlhLdGUwdnBiUSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDc1NTgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQjhLRTIyMDY3NTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJlenptbGw5NA==", + "R2JhWGVoblV4NmoyaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJlenptbGw5NEdiYVhlaG5VeDZqMmgiLCJpZCI6IjJlenptbGw5NEdiYVhlaG5VeDZqMmgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHdpbGlnaHQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MmV6em1sbDk0R2JhWGVoblV4NmoyaCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVmU0c2V2MXRDNUNHRWVQNWZVYjVZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJWZTRzZXYxdEM1Q0dFZVA1ZlViNVkiLCJpZCI6IjJWZTRzZXYxdEM1Q0dFZVA1ZlViNVkiLCJuYW1lIjoiR3JheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVmU0c2V2MXRDNUNHRWVQNWZVYjVZIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN3dDd2FYR2cyN2tBQ0lrQXdFY28zVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzd3Q3dhWEdnMjdrQUNJa0F3RWNvM1QiLCJpZCI6Ijd3Q3dhWEdnMjdrQUNJa0F3RWNvM1QiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTFhZmQwOWEzNTViNjExMDVmYzg4YTZjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUxYWZkMDlhMzU1YjYxMTA1ZmM4OGE2YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTFhZmQwOWEzNTViNjExMDVmYzg4YTZjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpZ2l0YWwgTm9tYWQiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTA1LTMwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3d0N3YVhHZzI3a0FDSWtBd0VjbzNUIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlZlNHNldjF0QzVDR0VlUDVmVWI1WSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVmU0c2V2MXRDNUNHRWVQNWZVYjVZIg==", + "LCJpZCI6IjJWZTRzZXYxdEM1Q0dFZVA1ZlViNVkiLCJuYW1lIjoiR3JheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVmU0c2V2MXRDNUNHRWVQNWZVYjVZIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFKdjJGOFZGSnNTcjJYS3RlMHZwYlEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUp2MkY4VkZKc1NyMlhLdGUwdnBiUSIsImlkIjoiMUp2MkY4VkZKc1NyMlhLdGUwdnBiUSIsIm5hbWUiOiJBIExpdHRsZSBTb3VuZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxSnYyRjhWRkpzU3IyWEt0ZTB2cGJRIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5MDU4OCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCOEtFMjQxMTA2MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2REMDd0ODlaZ0NoYUZUZkprckVIMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdkRDA3dDg5WmdDaGFGVGZKa3JFSDMiLCJpZCI6IjdkRDA3dDg5WmdDaGFGVGZKa3JFSDMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHdpbGlnaHQgLSBDb21lZG93biBNaXgiLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2REMDd0ODlaZ0NoYUZUZkprckVIMyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlZlNHNldjF0QzVDR0VlUDVmVWI1WSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVmU0c2V2MXRDNUNHRWVQNWZVYjVZIiwiaWQiOiIyVmU0c2V2MXRDNUNHRWVQNWZVYjVZIiwibmFtZSI6IkdyYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlZlNHNldjF0QzVDR0VlUDVmVWI1WSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc0RjdYUHNnakNPRHY2djNyMjBEaVoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83NEY3WFBzZ2pDT0R2NnYzcjIwRGlaIiwiaWQiOiI3NEY3WFBzZ2pDT0R2NnYzcjIwRGlaIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE3OTZhYmFlZDZmMQ==", + "NmIwZTIzNWFjMGU0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE3OTZhYmFlZDZmMTZiMGUyMzVhYzBlNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTc5NmFiYWVkNmYxNmIwZTIzNWFjMGU0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlR3aWxpZ2h0IChDb21lZG93biBNaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wNS0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzRGN1hQc2dqQ09EdjZ2M3IyMERpWiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJWZTRzZXYxdEM1Q0dFZVA1ZlViNVkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlZlNHNldjF0QzVDR0VlUDVmVWI1WSIsImlkIjoiMlZlNHNldjF0QzVDR0VlUDVmVWI1WSIsIm5hbWUiOiJHcmF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJWZTRzZXYxdEM1Q0dFZVA1ZlViNVkifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMUp2MkY4VkZKc1NyMlhLdGUwdnBiUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xSnYyRjhWRkpzU3IyWEt0ZTB2cGJRIiwiaWQiOiIxSnYyRjhWRkpzU3IyWEt0ZTB2cGJRIiwibmFtZSI6IkEgTGl0dGxlIFNvdW5kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFKdjJGOFZGSnNTcjJYS3RlMHZwYlEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTkwNTg4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0I4S0UyNDExMDYwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80Q2tZT3RLMDljZEQyenVMbzdqMU90In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNENrWU90SzA5Y2REMnp1TG83ajFPdCIsImlkIjoiNENrWU90SzA5Y2REMnp1TG83ajFPdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUd2lsaWdodCAtIENvbWVkb3duIE1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0Q2tZT3RLMDljZEQyenVMbzdqMU90In0seyJhbGJ1bSI6eyJhbA==", + "YnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlhxOUNJTVlXSzRSQ3JNVnRmRU9NMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82WHE5Q0lNWVdLNFJDck1WdGZFT00wIiwiaWQiOiI2WHE5Q0lNWVdLNFJDck1WdGZFT00wIiwibmFtZSI6IkdyYXlzY2FsZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2WHE5Q0lNWVdLNFJDck1WdGZFT00wIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNWo4NnlJNjhNamdaTEthWXNMNlNkNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVqODZ5STY4TWpnWkxLYVlzTDZTZDciLCJpZCI6IjVqODZ5STY4TWpnWkxLYVlzTDZTZDciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDdjYzdmNGIwZWFkMmU5YWQ3N2MzOGUzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA3Y2M3ZjRiMGVhZDJlOWFkNzdjMzhlMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDdjYzdmNGIwZWFkMmU5YWQ3N2MzOGUzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5lbGxhIFZpdGEiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA5LTA2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWo4NnlJNjhNamdaTEthWXNMNlNkNyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZYcTlDSU1ZV0s0UkNyTVZ0ZkVPTTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNlhxOUNJTVlXSzRSQ3JNVnRmRU9NMCIsImlkIjoiNlhxOUNJTVlXSzRSQ3JNVnRmRU9NMCIsIm5hbWUiOiJHcmF5c2NhbGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlhxOUNJTVlXSzRSQ3JNVnRmRU9NMCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjE4NTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVUzUyNjE5MjMxNjQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZg==", + "eS5jb20vdHJhY2svM0VrRmVCWTlSbUxJS3hrSmRYcEd2aSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNFa0ZlQlk5Um1MSUt4a0pkWHBHdmkiLCJpZCI6IjNFa0ZlQlk5Um1MSUt4a0pkWHBHdmkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHdpbGlnaHQgKE15IEhlYXZlbikiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0VrRmVCWTlSbUxJS3hrSmRYcEd2aSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3BDZk5NY1NsVVdRZ0JYYnlvRWN5TyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83cENmTk1jU2xVV1FnQlhieW9FY3lPIiwiaWQiOiI3cENmTk1jU2xVV1FnQlhieW9FY3lPIiwibmFtZSI6IlNvbG9tb24gR3JleSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3cENmTk1jU2xVV1FnQlhieW9FY3lPIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMEladFQwYzNxY3JPRk1wUm00b1pwaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBJWnRUMGMzcWNyT0ZNcFJtNG9acGoiLCJpZCI6IjBJWnRUMGMzcWNyT0ZNcFJtNG9acGoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzM2MTljZTZkODk3NzZiYmZkZjEzMTNlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmMzNjE5Y2U2ZDg5Nzc2YmJmZGYxMzEzZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzM2MTljZTZkODk3NzZiYmZkZjEzMTNlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlR3aWxpZ2h0IiwicmVsZWFzZV9kYXRlIjoiMjAxNS0wOS0wNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MEladFQwYzNxY3JPRk1wUm00b1pwaiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdwQ2ZOTWNTbFVXUWdCWGJ5b0VjeU8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuYw==", + "b20vdjEvYXJ0aXN0cy83cENmTk1jU2xVV1FnQlhieW9FY3lPIiwiaWQiOiI3cENmTk1jU2xVV1FnQlhieW9FY3lPIiwibmFtZSI6IlNvbG9tb24gR3JleSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3cENmTk1jU2xVV1FnQlhieW9FY3lPIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQ4OTE1NSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MTUwNDc5OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnRiTUZrR2tremh3NlpDSW0wNEhXSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ0Yk1Ga0dra3podzZaQ0ltMDRIV0siLCJpZCI6IjZ0Yk1Ga0dra3podzZaQ0ltMDRIV0siLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHdpbGlnaHQgLSBKb2huIE1vbmttYW4gUmVtaXgiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NnRiTUZrR2tremh3NlpDSW0wNEhXSyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83SjJsWkJBTml6Z1BOZlV6dXgzMVBWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdKMmxaQkFOaXpnUE5mVXp1eDMxUFYiLCJpZCI6IjdKMmxaQkFOaXpnUE5mVXp1eDMxUFYiLCJuYW1lIjoiRGF2aWQgR3JheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3SjJsWkJBTml6Z1BOZlV6dXgzMVBWIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNDhVUXl0MW1IMUU2bjFqeTQxY3lhMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzQ4VVF5dDFtSDFFNm4xank0MWN5YTEiLCJpZCI6IjQ4VVF5dDFtSDFFNm4xank0MWN5YTEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjM4MzNiZWUxNzY3NjI0MmIyODAwZDZhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjIzODMzYmVlMTc2NzYyNDJiMjgwMGQ2YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjM4MzNiZWUxNzY3NjI0MmIyODAwZDZhIn1dLA==", + "ImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTG9zdCBTb25ncyA5NS05OCIsInJlbGVhc2VfZGF0ZSI6IjIwMDEtMDItMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0OFVReXQxbUgxRTZuMWp5NDFjeWExIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0oybFpCQU5pemdQTmZVenV4MzFQViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83SjJsWkJBTml6Z1BOZlV6dXgzMVBWIiwiaWQiOiI3SjJsWkJBTml6Z1BOZlV6dXgzMVBWIiwibmFtZSI6IkRhdmlkIEdyYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0oybFpCQU5pemdQTmZVenV4MzFQViJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNDM0MjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkRMWTAwMDAwMTMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNER2k0RWJFVHJyeHhrNXJROHdqdzgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zREdpNEViRVRycnh4azVyUTh3anc4IiwiaWQiOiIzREdpNEViRVRycnh4azVyUTh3anc4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlR3aWxpZ2h0IiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNER2k0RWJFVHJyeHhrNXJROHdqdzgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdwQ2ZOTWNTbFVXUWdCWGJ5b0VjeU8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3BDZk5NY1NsVVdRZ0JYYnlvRWN5TyIsImlkIjoiN3BDZk5NY1NsVVdRZ0JYYnlvRWN5TyIsIm5hbWUiOiJTb2xvbW9uIEdyZXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3BDZk5NY1NsVVdRZ0JYYnlvRWN5TyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzd4R1Q5TTlHTXBhckJHM21HcmV2dTYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83eEdUOU05R01wYXJCRzNtR3JldnU2IiwiaWQiOiI3eEdUOU05R01wYXJCRzNtR3JldnU2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOg==", + "NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWIxZGNkYWNmYTY0OTZhOTI4ZjM4Njk3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjliMWRjZGFjZmE2NDk2YTkyOGYzODY5NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWIxZGNkYWNmYTY0OTZhOTI4ZjM4Njk3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNlbGVjdGVkIEZlYXR1cmVzIiwicmVsZWFzZV9kYXRlIjoiMjAxNS0wOS0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N3hHVDlNOUdNcGFyQkczbUdyZXZ1NiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdwQ2ZOTWNTbFVXUWdCWGJ5b0VjeU8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3BDZk5NY1NsVVdRZ0JYYnlvRWN5TyIsImlkIjoiN3BDZk5NY1NsVVdRZ0JYYnlvRWN5TyIsIm5hbWUiOiJTb2xvbW9uIEdyZXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3BDZk5NY1NsVVdRZ0JYYnlvRWN5TyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80UU5nRjBUUTdFc0R2dkVYalU5QzQyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRRTmdGMFRRN0VzRHZ2RVhqVTlDNDIiLCJpZCI6IjRRTmdGMFRRN0VzRHZ2RVhqVTlDNDIiLCJuYW1lIjoiSW1vZ2VuIFJvc2UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFFOZ0YwVFE3RXNEdnZFWGpVOUM0MiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTEwODAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlVNNzE1MDM4ODQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNjR3JYOVJoSFBJNEFDZnc4WDVydTkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zY0dyWDlSaEhQSTRBQ2Z3OFg1cnU5IiwiaWQiOiIzY0dyWDlSaEhQSTRBQ2Z3OFg1cnU5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlR3aWxpZ2h0IC0gTmlnaHQgTWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eQ==", + "cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2NHclg5UmhIUEk0QUNmdzhYNXJ1OSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDUzcTB1a0lEUmd6d1RyNHZOU3dhYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wNTNxMHVrSURSZ3p3VHI0dk5Td2FiIiwiaWQiOiIwNTNxMHVrSURSZ3p3VHI0dk5Td2FiIiwibmFtZSI6IkdyaW1lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNTNxMHVrSURSZ3p3VHI0dk5Td2FiIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMUNvZzZhWjZOd25KaXVJTmMwTFFFVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFDb2c2YVo2TnduSml1SU5jMExRRVUiLCJpZCI6IjFDb2c2YVo2TnduSml1SU5jMExRRVUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMGNjMWU2YWNmMzEzODlmMjllZjg1NTRjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjBjYzFlNmFjZjMxMzg5ZjI5ZWY4NTU0YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMGNjMWU2YWNmMzEzODlmMjllZjg1NTRjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRhcmtibG9vbSIsInJlbGVhc2VfZGF0ZSI6IjIwMTEtMDQtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFDb2c2YVo2TnduSml1SU5jMExRRVUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNTNxMHVrSURSZ3p3VHI0dk5Td2FiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA1M3EwdWtJRFJnendUcjR2TlN3YWIiLCJpZCI6IjA1M3EwdWtJRFJnendUcjR2TlN3YWIiLCJuYW1lIjoiR3JpbWVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA1M3EwdWtJRFJnendUcjR2TlN3YWIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjU1NjM0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIg==", + "OiJDQTIxTzExMDAwMTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVFaFpDOEdGT1ZYcnBpVVcyMmpuY0UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81RWhaQzhHRk9WWHJwaVVXMjJqbmNFIiwiaWQiOiI1RWhaQzhHRk9WWHJwaVVXMjJqbmNFIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlVyYmFuIFR3aWxpZ2h0IiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVFaFpDOEdGT1ZYcnBpVVcyMmpuY0UifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0oybFpCQU5pemdQTmZVenV4MzFQViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83SjJsWkJBTml6Z1BOZlV6dXgzMVBWIiwiaWQiOiI3SjJsWkJBTml6Z1BOZlV6dXgzMVBWIiwibmFtZSI6IkRhdmlkIEdyYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0oybFpCQU5pemdQTmZVenV4MzFQViJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzY1c0luWEFHdFBtbG1BdEY2WFhNblQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82NXNJblhBR3RQbWxtQXRGNlhYTW5UIiwiaWQiOiI2NXNJblhBR3RQbWxtQXRGNlhYTW5UIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzU1OTU1NGEzOTNmMDExOGRhMjc0NzJmOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1NTk1NTRhMzkzZjAxMThkYTI3NDcyZjgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly8=", + "aS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1NTk1NTRhMzkzZjAxMThkYTI3NDcyZjgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEJlc3Qgb2YgRGF2aWQgR3JheSAoRGVsdXhlIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAxNi0xMC0yOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjY1c0luWEFHdFBtbG1BdEY2WFhNblQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83SjJsWkJBTml6Z1BOZlV6dXgzMVBWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdKMmxaQkFOaXpnUE5mVXp1eDMxUFYiLCJpZCI6IjdKMmxaQkFOaXpnUE5mVXp1eDMxUFYiLCJuYW1lIjoiRGF2aWQgR3JheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3SjJsWkJBTml6Z1BOZlV6dXgzMVBWIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjE0MjEyOSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCRExZMTYwMDAyOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVNQQk1mN1BtUFpxb3RkcDFvMnJpTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVTUEJNZjdQbVBacW90ZHAxbzJyaU8iLCJpZCI6IjVTUEJNZjdQbVBacW90ZHAxbzJyaU8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHdpbGlnaHQiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVTUEJNZjdQbVBacW90ZHAxbzJyaU8ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0c3RTd5UFREWVMxM1pCbncxWUczNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zRzdFN3lQVERZUzEzWkJudzFZRzM2IiwiaWQiOiIzRzdFN3lQVERZUzEzWkJudzFZRzM2IiwibmFtZSI6Ik1hdHRoZXcgR29vZG1hbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozRzdFN3lQVERZUzEzWkJudzFZRzM2In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV3WWhHaDBmc0xFVXA1bWg0ejZVQ0MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuYw==", + "b20vdjEvYXJ0aXN0cy81d1loR2gwZnNMRVVwNW1oNHo2VUNDIiwiaWQiOiI1d1loR2gwZnNMRVVwNW1oNHo2VUNDIiwibmFtZSI6IktpbWJlcmx5IEFubmUgU3V0aGVybGFuZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1d1loR2gwZnNMRVVwNW1oNHo2VUNDIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN1MEVRUFBqV1BObEpSWTZJbkNaa0sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3UwRVFQUGpXUE5sSlJZNkluQ1prSyIsImlkIjoiM3UwRVFQUGpXUE5sSlJZNkluQ1prSyIsIm5hbWUiOiJSaGlhbm5vbiBNYWlyIEdyYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3UwRVFQUGpXUE5sSlJZNkluQ1prSyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzN3RUtQS09oSFZ0YW12d2xIWFpCdmcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zd0VLUEtPaEhWdGFtdndsSFhaQnZnIiwiaWQiOiIzd0VLUEtPaEhWdGFtdndsSFhaQnZnIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FkNjVjNmUxYzJjMTVjNzIwY2ZiNTgxYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhZDY1YzZlMWMyYzE1YzcyMGNmYjU4MWEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFkNjVjNmUxYzJjMTVjNzIwY2ZiNTgxYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb3VsdHJvbmljIC0gRnJlc2ggVm9jYWwgTmVvLVNvdWwiLCJyZWxlYXNlX2RhdGUiOiIyMDIyLTA3LTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M3dFS1BLT2hIVnRhbXZ3bEhYWkJ2ZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN1MEVRUFBqV1BObEpSWTZJbkNaa0sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3UwRVFQUGpXUE5sSlJZNkluQ1prSyIsImlkIjoiM3UwRVFQUGpXUE5sSlJZNkluQ1prSyIsIm5hbWUiOiJSaGlhbm5vbiBNYWlyIEdyYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdA==", + "aWZ5OmFydGlzdDozdTBFUVBQaldQTmxKUlk2SW5DWmtLIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV3WWhHaDBmc0xFVXA1bWg0ejZVQ0MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXdZaEdoMGZzTEVVcDVtaDR6NlVDQyIsImlkIjoiNXdZaEdoMGZzTEVVcDVtaDR6NlVDQyIsIm5hbWUiOiJLaW1iZXJseSBBbm5lIFN1dGhlcmxhbmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXdZaEdoMGZzTEVVcDVtaDR6NlVDQyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzM3NDIsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQldDNzIyMDA0OTkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRXd3p0bVhqTVhObUg2bFJmRzNrTXMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80V3d6dG1Yak1YTm1INmxSZkcza01zIiwiaWQiOiI0V3d6dG1Yak1YTm1INmxSZkcza01zIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlR3aWxpZ2h0IEhpZ2giLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFd3enRtWGpNWE5tSDZsUmZHM2tNcyJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Twilight%22+artist%3A%22Gray%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Downtown%22%20artist%3A%22Godford%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"external_urls":{"spotify":"https://open.spotify.com/album/5gFwQJ5wcMQNPm69TYNFTP"},"href":"https://api.spotify.com/v1/albums/5gFwQJ5wcMQNPm69TYNFTP","id":"5gFwQJ5wcMQNPm69TYNFTP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aa9c8411d9f30cd99e93629c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aa9c8411d9f30cd99e93629c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aa9c8411d9f30cd99e93629c"}],"is_playable":true,"name":"Non Binary Place","release_date":"2020-09-25","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5gFwQJ5wcMQNPm69TYNFTP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"disc_number":1,"duration_ms":267911,"explicit":false,"external_ids":{"isrc":"FRD9M1900280"},"external_urls":{"spotify":"https://open.spotify.com/track/6WKu0pl1jHSuVo4PbSn2yk"},"href":"https://api.spotify.com/v1/tracks/6WKu0pl1jHSuVo4PbSn2yk","id":"6WKu0pl1jHSuVo4PbSn2yk","is_local":false,"is_playable":true,"name":"Downtown","track_number":2,"type":"track","uri":"spotify:track:6WKu0pl1jHSuVo4PbSn2yk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"external_urls":{"spotify":"https://open.spotify.com/album/1SxsP8sgDsbN2tefZTN9Ao"},"href":"https://api.spotify.com/v1/albums/1SxsP8sgDsbN2tefZTN9Ao","id":"1SxsP8sgDsbN2tefZTN9Ao","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273403f245a95ad96ca40599393"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02403f245a95ad96ca40599393"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851403f245a95ad96ca40599393"}],"is_playable":true,"name":"Downtown (Couros Remix)","release_date":"2021-01-13","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:1SxsP8sgDsbN2tefZTN9Ao"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"disc_number":1,"duration_ms":267911,"explicit":false,"external_ids":{"isrc":"FRD9M1900280"},"external_urls":{"spotify":"https://open.spotify.com/track/3q4DwnFcrYdpV1BlXifyAv"},"href":"https://api.spotify.com/v1/tracks/3q4DwnFcrYdpV1BlXifyAv","id":"3q4DwnFcrYdpV1BlXifyAv","is_local":false,"is_playable":true,"name":"Downtown","track_number":2,"type":"track","uri":"spotify:track:3q4DwnFcrYdpV1BlXifyAv"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"external_urls":{"spotify":"https://open.spotify.com/album/6Lz2iB6xfFvAWMUqcujGVk"},"href":"https://api.spotify.com/v1/albums/6Lz2iB6xfFvAWMUqcujGVk","id":"6Lz2iB6xfFvAWMUqcujGVk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734e2636c2696111408dd804fe"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024e2636c2696111408dd804fe"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514e2636c2696111408dd804fe"}],"is_playable":true,"name":"Downtown","release_date":"2020-01-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6Lz2iB6xfFvAWMUqcujGVk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"disc_number":1,"duration_ms":267911,"explicit":false,"external_ids":{"isrc":"FRD9M1900280"},"external_urls":{"spotify":"https://open.spotify.com/track/1mL66NYaEjriWFhTQiLyeI"},"href":"https://api.spotify.com/v1/tracks/1mL66NYaEjriWFhTQiLyeI","id":"1mL66NYaEjriWFhTQiLyeI","is_local":false,"is_playable":true,"name":"Downtown","track_number":1,"type":"track","uri":"spotify:track:1mL66NYaEjriWFhTQiLyeI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"}],"external_urls":{"spotify":"https://open.spotify.com/album/1SxsP8sgDsbN2tefZTN9Ao"},"href":"https://api.spotify.com/v1/albums/1SxsP8sgDsbN2tefZTN9Ao","id":"1SxsP8sgDsbN2tefZTN9Ao","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273403f245a95ad96ca40599393"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02403f245a95ad96ca40599393"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851403f245a95ad96ca40599393"}],"is_playable":true,"name":"Downtown (Couros Remix)","release_date":"2021-01-13","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:1SxsP8sgDsbN2tefZTN9Ao"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4pUwtnbS6FdBniLp410AOu"},"href":"https://api.spotify.com/v1/artists/4pUwtnbS6FdBniLp410AOu","id":"4pUwtnbS6FdBniLp410AOu","name":"Godford","type":"artist","uri":"spotify:artist:4pUwtnbS6FdBniLp410AOu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7g0azP1aJBtmhhOk00SpIM"},"href":"https://api.spotify.com/v1/artists/7g0azP1aJBtmhhOk00SpIM","id":"7g0azP1aJBtmhhOk00SpIM","name":"Couros","type":"artist","uri":"spotify:artist:7g0azP1aJBtmhhOk00SpIM"}],"disc_number":1,"duration_ms":188701,"explicit":false,"external_ids":{"isrc":"QMFME2055810"},"external_urls":{"spotify":"https://open.spotify.com/track/1tFyeVd0R8yqxpK8H4sURf"},"href":"https://api.spotify.com/v1/tracks/1tFyeVd0R8yqxpK8H4sURf","id":"1tFyeVd0R8yqxpK8H4sURf","is_local":false,"is_playable":true,"name":"Downtown - Couros Remix","track_number":1,"type":"track","uri":"spotify:track:1tFyeVd0R8yqxpK8H4sURf"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRvd250b3duJTIyJTIwYXJ0aXN0JTNBJTIyR29kZm9yZCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwiaWQiOiI0cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwibmFtZSI6IkdvZGZvcmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVnRndRSjV3Y01RTlBtNjlUWU5GVFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81Z0Z3UUo1d2NNUU5QbTY5VFlORlRQIiwiaWQiOiI1Z0Z3UUo1d2NNUU5QbTY5VFlORlRQIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNg==", + "ZDAwMDBiMjczYWE5Yzg0MTFkOWYzMGNkOTllOTM2MjljIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmFhOWM4NDExZDlmMzBjZDk5ZTkzNjI5YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYWE5Yzg0MTFkOWYzMGNkOTllOTM2MjljIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vbiBCaW5hcnkgUGxhY2UiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTA5LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWdGd1FKNXdjTVFOUG02OVRZTkZUUCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSIsImlkIjoiNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSIsIm5hbWUiOiJHb2Rmb3JkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY3OTExLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiRlJEOU0xOTAwMjgwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82V0t1MHBsMWpIU3VWbzRQYlNuMnlrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNldLdTBwbDFqSFN1Vm80UGJTbjJ5ayIsImlkIjoiNldLdTBwbDFqSFN1Vm80UGJTbjJ5ayIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb3dudG93biIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2V0t1MHBsMWpIU3VWbzRQYlNuMnlrIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80cFV3dG5iUzZGZEJuaUxwNDEwQU91In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJpZCI6IjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJuYW1lIjoiR29kZm9yZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdA==", + "OjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xU3hzUDhzZ0RzYk4ydGVmWlROOUFvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVN4c1A4c2dEc2JOMnRlZlpUTjlBbyIsImlkIjoiMVN4c1A4c2dEc2JOMnRlZlpUTjlBbyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0MDNmMjQ1YTk1YWQ5NmNhNDA1OTkzOTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDAzZjI0NWE5NWFkOTZjYTQwNTk5MzkzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0MDNmMjQ1YTk1YWQ5NmNhNDA1OTkzOTMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRG93bnRvd24gKENvdXJvcyBSZW1peCkiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTAxLTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxU3hzUDhzZ0RzYk4ydGVmWlROOUFvIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwiaWQiOiI0cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwibmFtZSI6IkdvZGZvcmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjc5MTEsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJGUkQ5TTE5MDAyODAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNxNER3bkZjcllkcFYxQmxYaWZ5QXYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zcTREd25GY3JZZHBWMUJsWGlmeUF2IiwiaWQiOiIzcTREd25GY3JZZHBWMUJsWGlmeUF2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRvd250b3duIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNxNER3bkZjcllkcFYxQmxYaQ==", + "ZnlBdiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwiaWQiOiI0cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwibmFtZSI6IkdvZGZvcmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZMejJpQjZ4ZkZ2QVdNVXFjdWpHVmsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82THoyaUI2eGZGdkFXTVVxY3VqR1ZrIiwiaWQiOiI2THoyaUI2eGZGdkFXTVVxY3VqR1ZrIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRlMjYzNmMyNjk2MTExNDA4ZGQ4MDRmZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0ZTI2MzZjMjY5NjExMTQwOGRkODA0ZmUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRlMjYzNmMyNjk2MTExNDA4ZGQ4MDRmZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb3dudG93biIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDEtMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZMejJpQjZ4ZkZ2QVdNVXFjdWpHVmsifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80cFV3dG5iUzZGZEJuaUxwNDEwQU91In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJpZCI6IjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJuYW1lIjoiR29kZm9yZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0cFV3dG5iUzZGZEJuaUxwNDEwQU91In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2NzkxMSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkZSRDlNMTkwMDI4MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwcw==", + "Oi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xbUw2Nk5ZYUVqcmlXRmhUUWlMeWVJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMW1MNjZOWWFFanJpV0ZoVFFpTHllSSIsImlkIjoiMW1MNjZOWWFFanJpV0ZoVFFpTHllSSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb3dudG93biIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxbUw2Nk5ZYUVqcmlXRmhUUWlMeWVJIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80cFV3dG5iUzZGZEJuaUxwNDEwQU91In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJpZCI6IjRwVXd0bmJTNkZkQm5pTHA0MTBBT3UiLCJuYW1lIjoiR29kZm9yZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0cFV3dG5iUzZGZEJuaUxwNDEwQU91In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMVN4c1A4c2dEc2JOMnRlZlpUTjlBbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFTeHNQOHNnRHNiTjJ0ZWZaVE45QW8iLCJpZCI6IjFTeHNQOHNnRHNiTjJ0ZWZaVE45QW8iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDAzZjI0NWE5NWFkOTZjYTQwNTk5MzkzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQwM2YyNDVhOTVhZDk2Y2E0MDU5OTM5MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDAzZjI0NWE5NWFkOTZjYTQwNTk5MzkzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRvd250b3duIChDb3Vyb3MgUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wMS0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVN4c1A4c2dEc2JOMnRlZlpUTjlBbyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRwVXd0bmJTNkZkQm5pTHA0MTBBT3UifSwiaHJlZiI6Imh0dHBzOi8vYQ==", + "cGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwiaWQiOiI0cFV3dG5iUzZGZEJuaUxwNDEwQU91IiwibmFtZSI6IkdvZGZvcmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHBVd3RuYlM2RmRCbmlMcDQxMEFPdSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83ZzBhelAxYUpCdG1oaE9rMDBTcElNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdnMGF6UDFhSkJ0bWhoT2swMFNwSU0iLCJpZCI6IjdnMGF6UDFhSkJ0bWhoT2swMFNwSU0iLCJuYW1lIjoiQ291cm9zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdnMGF6UDFhSkJ0bWhoT2swMFNwSU0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg4NzAxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU1GTUUyMDU1ODEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xdEZ5ZVZkMFI4eXF4cEs4SDRzVVJmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMXRGeWVWZDBSOHlxeHBLOEg0c1VSZiIsImlkIjoiMXRGeWVWZDBSOHlxeHBLOEg0c1VSZiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb3dudG93biAtIENvdXJvcyBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxdEZ5ZVZkMFI4eXF4cEs4SDRzVVJmIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Downtown%22+artist%3A%22Godford%22&type=track&limit=10" + } +] diff --git a/eval/fixtures/nineties-nostalgia/anthropic.json b/eval/fixtures/nineties-nostalgia/anthropic.json new file mode 100644 index 0000000..3789d5f --- /dev/null +++ b/eval/fixtures/nineties-nostalgia/anthropic.json @@ -0,0 +1,66 @@ +[ + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"query\":\"take me back to the nineties\",\"history\":[],\"prior_recommendations\":[],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"required_candidate_count\":35}"}],"model":"claude-sonnet-5","output_config":{"effort":"low","format":{"schema":{"$defs":{"CandidateOutput":{"type":"object","description":"One bounded candidate in the intent response.","title":"CandidateOutput","properties":{"title":{"type":"string","title":"Title","description":"{maxLength: 200, minLength: 1}"},"artist":{"type":"string","title":"Artist","description":"{maxLength: 200, minLength: 1}"}},"additionalProperties":false,"required":["title","artist"]},"Familiarity":{"type":"string","enum":["familiar","mix","new"],"description":"How strongly a request should favor known or unknown music.","title":"Familiarity"}},"type":"object","description":"Bounded structured output for the intent call.","title":"IntentOutput","properties":{"mood":{"type":"array","title":"Mood","items":{"type":"string"},"description":"{maxItems: 6}"},"activity":{"anyOf":[{"type":"string","description":"{maxLength: 100}"},{"type":"null"}],"title":"Activity","description":"{default: None}"},"era":{"type":"array","title":"Era","items":{"type":"string"},"description":"{maxItems: 5}"},"languages":{"type":"array","title":"Languages","items":{"type":"string"},"description":"{maxItems: 8}"},"genres":{"type":"array","title":"Genres","items":{"type":"string"},"description":"{maxItems: 8}"},"familiarity":{"$ref":"#/$defs/Familiarity"},"is_refinement":{"type":"boolean","title":"Is Refinement"},"intent_summary":{"type":"string","title":"Intent Summary","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"},"candidates":{"type":"array","title":"Candidates","items":{"$ref":"#/$defs/CandidateOutput"},"description":"{maxItems: 50, minItems: 10}"}},"additionalProperties":false,"required":["familiarity","is_refinement","intent_summary","candidates"]},"type":"json_schema"}},"system":[{"type":"text","text":"You are the intent interpreter and candidate generator for a music discovery system. Your job is to understand one listener request, use the supplied taste evidence carefully, and propose real recordings that another service can resolve against Spotify. Return only data that conforms to the provided output schema. Do not add prose before or after the structured response.\n\nInterpret the request in context. The variable input can contain a current query, a bounded conversation history, recommendations from an earlier response, and a compact taste profile. Treat the current query as authoritative. Use history only to resolve references, continuity, or explicit changes such as \"more like the third one\" or \"less energetic.\" Prior recommendations are evidence about what the listener has just seen, not proof that the listener likes every item. The Spotify taste profile is evidence of listening behavior, not a complete identity and not permission to stereotype the listener.\n\nPopulate every schema field honestly. Mood is a short bounded list of useful musical or emotional qualities. Activity is a concise listening context when one is stated or strongly implied, otherwise null. Era contains only time periods that matter to the request. Languages contains requested or strongly implied vocal languages; use an empty list when language is irrelevant or the music can be instrumental. Genres should be specific enough to guide selection without inventing a false precision. Familiarity must be familiar, mix, or new. Use familiar when the listener asks for comfort, favorites, known songs, or reliable crowd recognition. Use new when the listener asks for discovery, obscurity, unfamiliar music, or a departure from their habits. Use mix for a balanced bridge or when the request does not justify either extreme.\n\nSet is_refinement to true only when the listener is revising, narrowing, extending, or referring to an earlier recommendation result in the supplied conversation. A standalone request is not a refinement merely because history exists. The intent summary must be one plain-English sentence that tells the listener how the request was understood. It must not mention internal models, candidate generation, schemas, retrieval, or Spotify search behavior.\n\nGenerate the exact candidate count requested in the variable input. Each candidate contains only a track title and the credited artist name most likely to identify the recording. Choose recordings that plausibly exist in Spotify's catalog. Use canonical spellings. Do not fabricate tracks, mash up titles and artists, translate titles, or use descriptive placeholders. Avoid remixes, live versions, remasters, edits, sped-up versions, slowed versions, karaoke versions, covers, and tribute recordings unless the user explicitly asks for them. When several recordings share a title, choose the artist credit that makes the intended recording unambiguous.\n\nCandidate quality matters more than superficial variety. Every candidate should fit the interpreted mood, activity, era, language, genre, and familiarity. Still, spread the set across artists. Do not let one artist dominate the candidate list, even when that artist appears prominently in the taste profile. Avoid duplicate titles by the same artist and avoid multiple editions of the same recording. Use a range of strong fits so a later ranking step has meaningful choices rather than thirty near-identical songs.\n\nWhen familiarity leans new, propose music the listener plausibly does not know. Move beyond the named top artists and tracks while retaining understandable bridges through genre, scene, production style, instrumentation, energy, era, or songwriting. Do not simply select deep cuts from every familiar artist. Prefer adjacent artists, overlooked catalogs, regional scenes, and credible cross-genre connections. The profile is not exhaustive, so never claim that a candidate is definitely unknown. When familiarity is familiar, candidates may include supplied top or saved tracks, but remain responsive to the current request. When familiarity is mix, combine recognizable anchors with adjacent discoveries rather than splitting into unrelated halves.\n\nUse musical knowledge conservatively. Base selection on durable, commonly knowable attributes of recordings. Do not invent listening statistics, personal memories, release stories, chart facts, cultural identities, lyrical meanings, or audio features. Do not infer sensitive traits from taste. Explicit safety or content constraints in the request are binding. If a request is broad, create a coherent interpretation instead of asking a question. If constraints conflict, prioritize explicit exclusions, then the current query, then history, then taste evidence.\n\nThe downstream resolver first tries an exact field-filtered search and then a fuzzy bare-text search. Help it succeed with correct title and artist spelling. It will reject weak title or artist matches, so substituting a vaguely related track wastes a candidate. Prefer a confidently identifiable recording over an obscure item whose title or credit you cannot state accurately. Do not include Spotify identifiers, album names, explanations, scores, or justifications in candidate objects.\n\nBefore returning, silently check that the response matches the schema, the candidate list has exactly the requested size, familiarity uses the allowed value, is_refinement reflects conversation continuity, the intent summary is one line, spellings are credible, artist distribution is broad, and no candidate violates an explicit exclusion. Return strictly the structured response and nothing else.\n","cache_control":{"type":"ephemeral"}}]}", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJtb2RlbCI6ImNsYXVkZS1zb25uZXQtNSIsImlkIjoibXNnXzAxMUNkdHVTOHBCS3pKZ0RQcm9xNFZQcCIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsIg==", + "Y29udGVudCI6W3sidHlwZSI6InRleHQiLCJ0ZXh0Ijoie1wibW9vZFwiOltcIm5vc3RhbGdpY1wiLFwidXBiZWF0XCIsXCJmdW5cIixcImNhcmVmcmVlXCJdLFwiYWN0aXZpdHlcIjpudWxsLFwiZXJhXCI6W1wiMTk5MHNcIl0sXCJsYW5ndWFnZXNcIjpbXSxcImdlbnJlc1wiOltcIjkwcyBwb3BcIixcIjkwcyBoaXAgaG9wXCIsXCI5MHMgcm9ja1wiLFwiOTBzIFImQlwiLFwiOTBzIGRhbmNlXCJdLFwiZmFtaWxpYXJpdHlcIjpcIm1peFwiLFwiaXNfcmVmaW5lbWVudFwiOmZhbHNlLFwiaW50ZW50X3N1bW1hcnlcIjpcIllvdSB3YW50IGEgbm9zdGFsZ2ljIHRyaXAgdGhyb3VnaCB0aGUgc291bmQgb2YgdGhlIDE5OTBzIGFjcm9zcyBwb3AsIHJvY2ssIGhpcCBob3AsIGFuZCBkYW5jZS5cIixcImNhbmRpZGF0ZXNcIjpbe1widGl0bGVcIjpcIldvbmRlcndhbGxcIixcImFydGlzdFwiOlwiT2FzaXNcIn0se1widGl0bGVcIjpcIkxvc2luZyBNeSBSZWxpZ2lvblwiLFwiYXJ0aXN0XCI6XCJSLkUuTS5cIn0se1widGl0bGVcIjpcIktpbGxpbmcgTWUgU29mdGx5IHdpdGggSGlzIFNvbmdcIixcImFydGlzdFwiOlwiRnVnZWVzXCJ9LHtcInRpdGxlXCI6XCJObyBEaWdnaXR5XCIsXCJhcnRpc3RcIjpcIkJsYWNrc3RyZWV0XCJ9LHtcInRpdGxlXCI6XCJXYXRlcmZhbGxzXCIsXCJhcnRpc3RcIjpcIlRMQ1wifSx7XCJ0aXRsZVwiOlwiU21lbGxzIExpa2UgVGVlbiBTcGlyaXRcIixcImFydGlzdFwiOlwiTmlydmFuYVwifSx7XCJ0aXRsZVwiOlwiQmFza2V0IENhc2VcIixcImFydGlzdFwiOlwiR3JlZW4gRGF5XCJ9LHtcInRpdGxlXCI6XCJTZW1pLUNoYXJtZWQgTGlmZVwiLFwiYXJ0aXN0XCI6XCJUaGlyZCBFeWUgQmxpbmRcIn0se1widGl0bGVcIjpcIjE5NzlcIixcImFydGlzdFwiOlwiVGhlIFNtYXNoaW5nIFB1bXBraW5zXCJ9LHtcInRpdGxlXCI6XCJUb3JuXCIsXCJhcnRpc3RcIjpcIk5hdGFsaWUgSW1icnVnbGlhXCJ9LHtcInRpdGxlXCI6XCJJcm9uaWNcIixcImFydGlzdFwiOlwiQWxhbmlzIE1vcmlzc2V0dGVcIn0se1widGl0bGVcIjpcIkNyeWluJ1wiLFwiYXJ0aXN0XCI6XCJBZXJvc21pdGhcIn0se1widGl0bGVcIjpcIk1tbWJvcFwiLFwiYXJ0aXN0XCI6XCJIYW5zb25cIn0se1widGl0bGVcIjpcIlpvbWJpZVwiLFwiYXJ0aXN0XCI6XCJUaGUgQ3JhbmJlcnJpZXNcIn0se1widGl0bGVcIjpcIlNheSBNeSBOYW1lXCIsXCJhcnRpc3RcIjpcIkRlc3RpbnkncyBDaGlsZFwifSx7XCJ0aXRsZVwiOlwiQydtb24gTicgUmlkZSBJdCAoVGhlIFRyYWluKVwiLFwiYXJ0aXN0XCI6XCJRdWFkIENpdHkgREonc1wifSx7XCJ0aXRsZVwiOlwiR2FuZ3N0YSdzIFBhcmFkaXNlXCIsXCJhcnRpc3RcIjpcIkNvb2xpb1wifQ==", + "LHtcInRpdGxlXCI6XCJSZWd1bGF0ZVwiLFwiYXJ0aXN0XCI6XCJXYXJyZW4gR1wifSx7XCJ0aXRsZVwiOlwiQ2FsaWZvcm5pYSBMb3ZlXCIsXCJhcnRpc3RcIjpcIjJQYWNcIn0se1widGl0bGVcIjpcIkp1aWN5XCIsXCJhcnRpc3RcIjpcIlRoZSBOb3RvcmlvdXMgQi5JLkcuXCJ9LHtcInRpdGxlXCI6XCJUaGlzIElzIEhvdyBXZSBEbyBJdFwiLFwiYXJ0aXN0XCI6XCJNb250ZWxsIEpvcmRhblwifSx7XCJ0aXRsZVwiOlwiQmFieSBPbmUgTW9yZSBUaW1lXCIsXCJhcnRpc3RcIjpcIkJyaXRuZXkgU3BlYXJzXCJ9LHtcInRpdGxlXCI6XCJJIFdhbnQgSXQgVGhhdCBXYXlcIixcImFydGlzdFwiOlwiQmFja3N0cmVldCBCb3lzXCJ9LHtcInRpdGxlXCI6XCJCaXR0ZXJzd2VldCBTeW1waG9ueVwiLFwiYXJ0aXN0XCI6XCJUaGUgVmVydmVcIn0se1widGl0bGVcIjpcIkFyZSBZb3UgR29ubmEgR28gTXkgV2F5XCIsXCJhcnRpc3RcIjpcIkxlbm55IEtyYXZpdHpcIn0se1widGl0bGVcIjpcIkJ1ZGR5IEhvbGx5XCIsXCJhcnRpc3RcIjpcIldlZXplclwifSx7XCJ0aXRsZVwiOlwiV2hhdCdzIFVwP1wiLFwiYXJ0aXN0XCI6XCI0IE5vbiBCbG9uZGVzXCJ9LHtcInRpdGxlXCI6XCJWb2d1ZVwiLFwiYXJ0aXN0XCI6XCJNYWRvbm5hXCJ9LHtcInRpdGxlXCI6XCJLaXNzIGZyb20gYSBSb3NlXCIsXCJhcnRpc3RcIjpcIlNlYWxcIn0se1widGl0bGVcIjpcIkRvbyBXb3AgKFRoYXQgVGhpbmcpXCIsXCJhcnRpc3RcIjpcIkxhdXJ5biBIaWxsXCJ9LHtcInRpdGxlXCI6XCJJbnNhbmUgaW4gdGhlIEJyYWluXCIsXCJhcnRpc3RcIjpcIkN5cHJlc3MgSGlsbFwifSx7XCJ0aXRsZVwiOlwiUmV0dXJuIG9mIHRoZSBNYWNrXCIsXCJhcnRpc3RcIjpcIk1hcmsgTW9ycmlzb25cIn0se1widGl0bGVcIjpcIkJhcmVseSBCcmVhdGhpbmdcIixcImFydGlzdFwiOlwiRHVuY2FuIFNoZWlrXCJ9LHtcInRpdGxlXCI6XCJZb3UgT3VnaHRhIEtub3dcIixcImFydGlzdFwiOlwiQWxhbmlzIE1vcmlzc2V0dGVcIn0se1widGl0bGVcIjpcIkdyb292ZSBJcyBpbiB0aGUgSGVhcnRcIixcImFydGlzdFwiOlwiRGVlZS1MaXRlXCJ9XX0ifV0sInN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NDk4MywiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6Mjc4MywiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MCwiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjEwMzksIm91dHB1dF90b2tlbnNfZGV0YWlscyI6eyJ0aGluaw==", + "aW5nX3Rva2VucyI6MH0sInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Imdsb2JhbCJ9fQ==" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"intent\":{\"mood\":[\"nostalgic\",\"upbeat\",\"fun\",\"carefree\"],\"activity\":null,\"era\":[\"1990s\"],\"languages\":[],\"genres\":[\"90s pop\",\"90s hip hop\",\"90s rock\",\"90s R&B\",\"90s dance\"],\"familiarity\":\"mix\",\"intent_summary\":\"You want a nostalgic trip through the sound of the 1990s across pop, rock, hip hop, and dance.\"},\"grounded_pool\":[{\"track_id\":\"1qPbGZqppFwLwcBC1JQ6Vr\",\"title\":\"Wonderwall\",\"artists\":[\"Oasis\"]},{\"track_id\":\"31AOj9sFz2gM0O3hMARRBx\",\"title\":\"Losing My Religion\",\"artists\":[\"R.E.M.\"]},{\"track_id\":\"0Q0IVlqMV64kNLlwjPj0Hl\",\"title\":\"Killing Me Softly With His Song\",\"artists\":[\"Fugees\",\"Ms. Lauryn Hill\"]},{\"track_id\":\"6MdqqkQ8sSC0WB4i8PyRuQ\",\"title\":\"No Diggity\",\"artists\":[\"Blackstreet\",\"Dr. Dre\",\"Queen Pen\"]},{\"track_id\":\"6qspW4YKycviDFjHBOaqUY\",\"title\":\"Waterfalls\",\"artists\":[\"TLC\"]},{\"track_id\":\"4CeeEOM32jQcH3eN9Q2dGj\",\"title\":\"Smells Like Teen Spirit\",\"artists\":[\"Nirvana\"]},{\"track_id\":\"6L89mwZXSOwYl76YXfX13s\",\"title\":\"Basket Case\",\"artists\":[\"Green Day\"]},{\"track_id\":\"42et6fnHCw1HIPSrdPprMl\",\"title\":\"Semi-Charmed Life\",\"artists\":[\"Third Eye Blind\"]},{\"track_id\":\"3h5zik31hTTat9jmpCZZNC\",\"title\":\"1979\",\"artists\":[\"The Smashing Pumpkins\"]},{\"track_id\":\"1Jaah2tmN9Hv81A87KZ1MU\",\"title\":\"Torn\",\"artists\":[\"Natalie Imbruglia\"]},{\"track_id\":\"29YBihzQOmat0U74k4ukdx\",\"title\":\"Ironic\",\"artists\":[\"Alanis Morissette\"]},{\"track_id\":\"4t1fWWJQs5V9YErfsrDslC\",\"title\":\"Cryin'\",\"artists\":[\"Aerosmith\"]},{\"track_id\":\"0lnxrQAd9ZxbhBBe7d8FO8\",\"title\":\"MMMBop\",\"artists\":[\"Hanson\"]},{\"track_id\":\"49wOjOkS4pBK3PQnPnNYjb\",\"title\":\"Zombie\",\"artists\":[\"The Cranberries\"]},{\"track_id\":\"7H6ev70Weq6DdpZyyTmUXk\",\"title\":\"Say My Name\",\"artists\":[\"Destiny's Child\"]},{\"track_id\":\"2QLEN3RVunMas7j0PHjeAT\",\"title\":\"C'mon N' Ride It (The Train)\",\"artists\":[\"Quad City DJ's\"]},{\"track_id\":\"1DIXPcTDzTj8ZMHt3PDt8p\",\"title\":\"Gangsta's Paradise\",\"artists\":[\"Coolio\",\"L.V.\"]},{\"track_id\":\"7nYvUtkQMx1v80S2FH2s9J\",\"title\":\"Regulate\",\"artists\":[\"Warren G\",\"Nate Dogg\"]},{\"track_id\":\"0LyLz6XsVs6wz85dK0S6EG\",\"title\":\"California Love\",\"artists\":[\"2Pac\"]},{\"track_id\":\"6aJ90LBl96bly9zuEH1U2X\",\"title\":\"This Is How We Do It\",\"artists\":[\"Montell Jordan\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"history\":[],\"requested_selection_count\":15,\"correction\":null}"}],"model":"claude-sonnet-5","output_config":{"effort":"medium","format":{"type":"json_schema","schema":{"$defs":{"RerankSelectionOutput":{"type":"object","description":"One validated object extracted from the rerank stream.","title":"RerankSelectionOutput","properties":{"track_id":{"type":"string","title":"Track Id","description":"{maxLength: 200, minLength: 1}"},"justification":{"type":"string","title":"Justification","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"}},"additionalProperties":false,"required":["track_id","justification"]}},"type":"object","description":"Complete bounded rerank output used for final validation.","title":"RerankOutput","properties":{"recommendations":{"type":"array","title":"Recommendations","items":{"$ref":"#/$defs/RerankSelectionOutput"},"minItems":1,"description":"{maxItems: 50}"}},"additionalProperties":false,"required":["recommendations"]}}},"system":[{"type":"text","text":"You are the final ranking component of a music discovery system. Select and order tracks only from the grounded Spotify pool supplied in the variable input. Return only data that conforms to the provided JSON schema. Output strictly the JSON object required by that schema, with no markdown, no code fence, no introductory sentence, and no trailing commentary.\n\nThe variable input contains the interpreted intent, a compact listener taste summary, bounded conversation history, and a grounded pool. Every pool entry includes a Spotify track id, title, and artist names. The pool is the complete set of allowed choices. Copy track_id values exactly. Never create, alter, guess, shorten, or normalize an id. Never select a title that is absent from the pool, even if it would be a better recommendation. Never return the same track id twice.\n\nChoose up to the requested selection count, ordered from strongest to weakest recommendation. Prefer a shorter set of honest strong fits over padding with clearly unsuitable material, but normally fill the requested count when the pool contains enough relevant choices. Ranking should respond to the current intent first. Use the taste summary to personalize among plausible fits, not to override an explicit request. Use history to understand refinements and references. Treat prior assistant statements as conversation context rather than verified facts about a recording.\n\nRespect the interpreted mood, activity, era, languages, genres, and familiarity together. A track need not satisfy every soft descriptor equally, but the ordering should form a coherent listening path. Put the clearest overall matches early. Consider transitions in energy, texture, and familiarity when that creates a more useful sequence, while avoiding a mechanical pattern. Spread selections across artists where the grounded pool permits it. Do not rank several editions of the same recording merely to fill space.\n\nFamiliarity affects ordering, but it does not grant access to information outside the input. For familiar requests, favor grounded tracks that visibly connect to the supplied taste evidence or prior recommendations. For new requests, favor credible adjacent discoveries and avoid leaning entirely on artists named in the taste summary. For mix requests, use recognizable anchors and exploratory choices in a coherent balance. The application may already have filtered known tracks, so do not claim that any selection is definitely new or previously unheard.\n\nWrite one concise, plain-English justification for each selection. It should connect the track to the stated intent and, only when supported, to an explicit item or pattern in the supplied taste summary. Keep it to one line. Make the reason useful to the listener rather than describing internal ranking operations. Good reasons identify a grounded connection such as pacing for the activity, a genre bridge, a requested era, a compatible vocal language, a mood transition, or continuity with a named preference.\n\nBe exact and modest. Do not invent audio measurements, tempo values, key signatures, instrumentation, lyrical subjects, release dates, artist biographies, chart history, cultural significance, collaborations, popularity, or claims about what the listener has heard. A title and artist name alone do not prove detailed sonic or lyrical facts. You may use stable general musical knowledge when confident, but phrase the justification around the supplied intent and visible evidence. If the inputs do not support a specific fact, use a restrained reason such as \"A focused fit for the requested late-night electronic mood\" rather than manufacturing detail.\n\nDo not mention Spotify search, grounding, the candidate generator, language models, schemas, hidden scores, safety filters, cache state, or missing data in a justification. Do not tell the listener that a track was selected because it was available in the pool. Do not compare a selection with tracks that are not in the pool. Do not repeat the same generic sentence for every item. Avoid promotional language and absolute claims such as \"perfect,\" \"guaranteed,\" or \"the best.\"\n\nWhen the variable input says this is a correction attempt, treat the stated validation failure as a strict constraint. Return a fresh complete JSON object, not a patch or explanation. Correct invalid ids, duplicates, malformed fields, count problems, and formatting errors using only the supplied pool. The correction instruction never allows an out-of-pool id.\n\nThe response must be one JSON object with the exact top-level field required by the schema. Each array item must contain exactly a track_id and justification in the required types. Preserve the requested ranking order in the array. Use valid JSON quoting and escaping. Do not emit comments, dangling commas, alternate keys, null justifications, numeric ids, or additional properties.\n\nBefore returning, silently verify every track_id against the supplied pool, ensure all ids are unique, ensure the number of items does not exceed the requested count, confirm each justification is honest and one line, confirm the ranking follows the current intent, and confirm the entire response is valid against the provided JSON schema. Return only the JSON object.\n","cache_control":{"type":"ephemeral"}}],"stream":true}", + "response_body_base64": "event: message_start
data: {"type":"message_start","message":{"model":"claude-sonnet-5","id":"msg_011CdtuT6VJqAmRDsUqJZ6ck","type":"message","role":"assistant","content":[],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":6201,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"global"}}       }

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}   }

event: ping
data: {"type": "ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"{"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"recommendations\":[{\"track_id\":\"4CeeEOM32jQc"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"H3eN9Q2dGj\",\"justification\":\"An"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" essential 90s rock anchor that instantly signals the decade's energy.\"},{\"track_id\":\"6L89mwZX"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"SOwYl76YXfX13s"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"Green Day already appears in your listening history, making this punk-pop cut a familiar nostalgic tou"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"chpoint.\"},{\"track_id\":\"0Q0IVlqMV64kN"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"LlwjPj0Hl\",\"justification\":\"A smooth 90s R&B classic that adds war"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"mth and variety to the mix.\"},{\"track_id\":\"6MdqqkQ8sSC"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"0WB4i8PyRuQ\",\"justification\":\"Up"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"beat 90s R&B/hip hop crossover that keeps the carefree energy moving.\"},{\"track_id\":\"1DIXPc"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"TDzTj8ZMHt3PD"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"t8p\",\"justification\":\"A defining 90s hip hop track that bridges nostalgia with rhythmic drive.\"},{\"track_id"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\":\"0LyLz6XsVs6wz"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"85dK0S6EG\",\"justification\":\"Iconic 90s West Coast hip hop that f"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"its the fun, upbeat throwback theme.\"},{\"track_id\":\"7nYvUtk"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"QMx1v80S2FH2s"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"9J\",\"justification\":\"Laid-back 90s hip hop groove that complements the carefree mood.\"},{\"track_id\":\"6aJ90"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"LBl96bly9zuEH1"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"U2X\",\"justification\":\"A bouncy 90s R&B/dance hit that keeps the fun factor high.\"},{\"track_id\":\"2QL"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"EN3RVunMas7j0PH"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"jeAT\",\"justification\":\"Pure 90s dance nostalgia with an infectious, carefree vibe.\"},{"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"track_id\":\"6qspW4YKycviDFjH"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"BOaqUY\",\"justification\":\"A heartfelt 90s R&B classic that adds emotional depth to the nostalgic trip.\"},{\"track_id"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\":\"7H6ev70Weq6DdpZyy"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"TmUXk\",\"justification\":\"Catchy 90s R&B/pop crossover that keeps the upbeat momentum going.\"},{\"track"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"_id\":\"1qPbGZqppFwLwcBC1"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"JQ6Vr\",\"justification\":\"A beloved 90s rock anthem that pairs well with your rock listening patterns.\"},{\"track_id\":\"29"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"YBihzQOmat0U74k4"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ukdx\",\"justification\":\"A sharp, nostalgic 90s alt-rock track with a wry, carefree edge.\"},{\"track_id\":\"42et"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"6fnHCw1HIPSr"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"dPprMl\",\"justification\":\"An upbeat 90s alt-rock cut that fits the fun, nostalgic s"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"equence.\"},{\"track_id\":\"0lnxrQAd9Zxbh"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"BBe7d8FO8\",\"justification\":\"A playful, undeniably cat"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"chy 90s pop moment to close out the carefree journey.\"}]}"}            }

event: content_block_stop
data: {"type":"content_block_stop","index":0            }

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null,"stop_details":null},"usage":{"input_tokens":6201,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"output_tokens":958,"output_tokens_details":{"thinking_tokens":0}}}

event: message_stop
data: {"type":"message_stop"}

", + "response_chunks_base64": [ + "ZXZlbnQ6IG1lc3NhZ2Vfc3Q=", + "YXJ0CmRhdGE6IHsidHlwZSI6Im1lc3NhZ2Vfc3RhcnQiLCJtZXNzYWdlIjp7Im1vZGVsIjoiY2xhdWRlLXNvbm5ldC01IiwiaWQiOiJtc2dfMDExQ2R0dVQ2VkpxQW1SRHNVcUpaNmNrIiwidHlwZSI6Im1lc3NhZ2UiLCJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6W10sInN0b3BfcmVhc29uIjpudWxsLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NjIwMSwiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MjExMywiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MCwiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjEsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Imdsb2JhbCJ9fSAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RhcnQKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19zdGFydCIsImluZGV4IjowLCJjb250ZW50X2Jsb2NrIjp7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IiJ9ICAgfQoK", + "ZXZlbnQ6IHBpbmcKZGF0YTogeyJ0eXBlIjogInBpbmcifQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ7In0gICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInJlY29tbWVuZGF0aW9uc1wiOlt7XCJ0cmFja19pZFwiOlwiNENlZUVPTTMyalFjIn0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJIM2VOOVEyZEdqXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBbiJ9ICAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgZXNzZW50aWFsIDkwcyByb2NrIGFuY2hvciB0aGF0IGluc3RhbnRseSBzaWduYWxzIHRoZSBkZWNhZGUncyBlbmVyZ3kuXCJ9LHtcInRyYWNrX2lkXCI6XCI2TDg5bXdaWCJ9ICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJTT3dZbDc2WVhmWDEzcyJ9ICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIkdyZWVuIERheSBhbHJlYWR5IGFwcGVhcnMgaW4geW91ciBsaXN0ZW5pbmcgaGlzdG9yeSwgbWFraW5nIHRoaXMgcHVuay1wb3AgY3V0IGEgZmFtaWxpYXIgbm9zdGFsZ2ljIHRvdSJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJjaHBvaW50LlwifSx7XCJ0cmFja19pZFwiOlwiMFEwSVZscU1WNjRrTiJ9ICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJMbHdqUGowSGxcIixcImp1c3RpZmljYXRpb25cIjpcIkEgc21vb3RoIDkwcyBSJkIgY2xhc3NpYyB0aGF0IGFkZHMgd2FyIn0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJtdGggYW5kIHZhcmlldHkgdG8gdGhlIG1peC5cIn0se1widHJhY2tfaWRcIjpcIjZNZHFxa1E4c1NDIn0gICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIwV0I0aThQeVJ1UVwiLFwianVzdGlmaWNhdGlvblwiOlwiVXAifX0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJiZWF0IDkwcyBSJkIvaGlwIGhvcCBjcm9zc292ZXIgdGhhdCBrZWVwcyB0aGUgY2FyZWZyZWUgZW5lcmd5IG1vdmluZy5cIn0se1widHJhY2tfaWRcIjpcIjFESVhQYyJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJURHpUajhaTUh0M1BEIn0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ0OHBcIixcImp1c3RpZmljYXRpb25cIjpcIkEgZGVmaW5pbmcgOTBzIGhpcCBob3AgdHJhY2sgdGhhdCBicmlkZ2VzIG5vc3RhbGdpYSB3aXRoIHJoeXRobWljIGRyaXZlLlwifSx7XCJ0cmFja19pZCJ9ICAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIjpcIjBMeUx6NlhzVnM2d3oifSAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI4NWRLMFM2RUdcIixcImp1c3RpZmljYXRpb25cIjpcIkljb25pYyA5MHMgV2VzdCBDb2FzdCBoaXAgaG9wIHRoYXQgZiJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpdHMgdGhlIGZ1biwgdXBiZWF0IHRocm93YmFjayB0aGVtZS5cIn0se1widHJhY2tfaWRcIjpcIjduWXZVdGsifSAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJRTXgxdjgwUzJGSDJzIn0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI5SlwiLFwianVzdGlmaWNhdGlvblwiOlwiTGFpZC1iYWNrIDkwcyBoaXAgaG9wIGdyb292ZSB0aGF0IGNvbXBsZW1lbnRzIHRoZSBjYXJlZnJlZSBtb29kLlwifSx7XCJ0cmFja19pZFwiOlwiNmFKOTAifX0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJMQmw5NmJseTl6dUVIMSJ9ICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJVMlhcIixcImp1c3RpZmljYXRpb25cIjpcIkEgYm91bmN5IDkwcyBSJkIvZGFuY2UgaGl0IHRoYXQga2VlcHMgdGhlIGZ1biBmYWN0b3IgaGlnaC5cIn0se1widHJhY2tfaWRcIjpcIjJRTCJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJFTjNSVnVuTWFzN2owUEgifSAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJqZUFUXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJQdXJlIDkwcyBkYW5jZSBub3N0YWxnaWEgd2l0aCBhbiBpbmZlY3Rpb3VzLCBjYXJlZnJlZSB2aWJlLlwifSx7In0gICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInRyYWNrX2lkXCI6XCI2cXNwVzRZS3ljdmlERmpIIn0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJCT2FxVVlcIixcImp1c3RpZmljYXRpb25cIjpcIkEgaGVhcnRmZWx0IDkwcyBSJkIgY2xhc3NpYyB0aGF0IGFkZHMgZW1vdGlvbmFsIGRlcHRoIHRvIHRoZSBub3N0YWxnaWMgdHJpcC5cIn0se1widHJhY2tfaWQifSAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIjpcIjdINmV2NzBXZXE2RGRwWnl5In0gfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJUbVVYa1wiLFwianVzdGlmaWNhdGlvblwiOlwiQ2F0Y2h5IDkwcyBSJkIvcG9wIGNyb3Nzb3ZlciB0aGF0IGtlZXBzIHRoZSB1cGJlYXQgbW9tZW50dW0gZ29pbmcuXCJ9LHtcInRyYWNrIn0gICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJfaWRcIjpcIjFxUGJHWnFwcEZ3THdjQkMxIn0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJKUTZWclwiLFwianVzdGlmaWNhdGlvblwiOlwiQSBiZWxvdmVkIDkwcyByb2NrIGFudGhlbSB0aGF0IHBhaXJzIHdlbGwgd2l0aCB5b3VyIHJvY2sgbGlzdGVuaW5nIHBhdHRlcm5zLlwifSx7XCJ0cmFja19pZFwiOlwiMjkifSAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJZQmloelFPbWF0MFU3NGs0In0gfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ1a2R4XCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIHNoYXJwLCBub3N0YWxnaWMgOTBzIGFsdC1yb2NrIHRyYWNrIHdpdGggYSB3cnksIGNhcmVmcmVlIGVkZ2UuXCJ9LHtcInRyYWNrX2lkXCI6XCI0MmV0In0gICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI2Zm5IQ3cxSElQU3IifSAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJkUHByTWxcIixcImp1c3RpZmljYXRpb25cIjpcIkFuIHVwYmVhdCA5MHMgYWx0LXJvY2sgY3V0IHRoYXQgZml0cyB0aGUgZnVuLCBub3N0YWxnaWMgcyJ9ICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlcXVlbmNlLlwifSx7XCJ0cmFja19pZFwiOlwiMGxueHJRQWQ5WnhiaCJ9ICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJCQmU3ZDhGTzhcIixcImp1c3RpZmljYXRpb25cIjpcIkEgcGxheWZ1bCwgdW5kZW5pYWJseSBjYXQifSAgICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJjaHkgOTBzIHBvcCBtb21lbnQgdG8gY2xvc2Ugb3V0IHRoZSBjYXJlZnJlZSBqb3VybmV5LlwifV19In0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RvcApkYXRhOiB7InR5cGUiOiJjb250ZW50X2Jsb2NrX3N0b3AiLCJpbmRleCI6MCAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IG1lc3NhZ2VfZGVsdGEKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9kZWx0YSIsImRlbHRhIjp7InN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGx9LCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjYyMDEsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjIxMTMsIm91dHB1dF90b2tlbnMiOjk1OCwib3V0cHV0X3Rva2Vuc19kZXRhaWxzIjp7InRoaW5raW5nX3Rva2VucyI6MH19fQoK", + "ZXZlbnQ6IG1lc3NhZ2Vfc3RvcApkYXRhOiB7InR5cGUiOiJtZXNzYWdlX3N0b3AifQoK" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + } +] diff --git a/eval/fixtures/nineties-nostalgia/spotify.json b/eval/fixtures/nineties-nostalgia/spotify.json new file mode 100644 index 0000000..b542e8e --- /dev/null +++ b/eval/fixtures/nineties-nostalgia/spotify.json @@ -0,0 +1,439 @@ +[ + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=", + "response_chunks_base64": [ + "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=0" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Killing%20Me%20Softly%20with%20His%20Song%22%20artist%3A%22Fugees%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7aBzpmFXB4WWpPl2F7RjBe"},"href":"https://api.spotify.com/v1/artists/7aBzpmFXB4WWpPl2F7RjBe","id":"7aBzpmFXB4WWpPl2F7RjBe","name":"Wyclef Jean","type":"artist","uri":"spotify:artist:7aBzpmFXB4WWpPl2F7RjBe"}],"external_urls":{"spotify":"https://open.spotify.com/album/18XFe4CPBgVezXkxZP6rTb"},"href":"https://api.spotify.com/v1/albums/18XFe4CPBgVezXkxZP6rTb","id":"18XFe4CPBgVezXkxZP6rTb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b7865be7f7fcc05faec6137"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b7865be7f7fcc05faec6137"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b7865be7f7fcc05faec6137"}],"is_playable":true,"name":"The Score (Expanded Edition)","release_date":"1996-02-13","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:18XFe4CPBgVezXkxZP6rTb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"}],"disc_number":1,"duration_ms":298666,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/0Q0IVlqMV64kNLlwjPj0Hl"},"href":"https://api.spotify.com/v1/tracks/0Q0IVlqMV64kNLlwjPj0Hl","id":"0Q0IVlqMV64kNLlwjPj0Hl","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":8,"type":"track","uri":"spotify:track:0Q0IVlqMV64kNLlwjPj0Hl"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"external_urls":{"spotify":"https://open.spotify.com/album/0D6QmUlYmrTExpUA3T4GTM"},"href":"https://api.spotify.com/v1/albums/0D6QmUlYmrTExpUA3T4GTM","id":"0D6QmUlYmrTExpUA3T4GTM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733d06c71068384b0ba4c47f62"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023d06c71068384b0ba4c47f62"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513d06c71068384b0ba4c47f62"}],"is_playable":true,"name":"Greatest Hits","release_date":"2003-03-25","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:0D6QmUlYmrTExpUA3T4GTM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":290266,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/7IuR13GY471Tbz4lp9DKOZ"},"href":"https://api.spotify.com/v1/tracks/7IuR13GY471Tbz4lp9DKOZ","id":"7IuR13GY471Tbz4lp9DKOZ","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":4,"type":"track","uri":"spotify:track:7IuR13GY471Tbz4lp9DKOZ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7aBzpmFXB4WWpPl2F7RjBe"},"href":"https://api.spotify.com/v1/artists/7aBzpmFXB4WWpPl2F7RjBe","id":"7aBzpmFXB4WWpPl2F7RjBe","name":"Wyclef Jean","type":"artist","uri":"spotify:artist:7aBzpmFXB4WWpPl2F7RjBe"}],"external_urls":{"spotify":"https://open.spotify.com/album/4z6F5s3RVaOsekuaegbLfD"},"href":"https://api.spotify.com/v1/albums/4z6F5s3RVaOsekuaegbLfD","id":"4z6F5s3RVaOsekuaegbLfD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273970c54109c747d26b56636eb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02970c54109c747d26b56636eb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851970c54109c747d26b56636eb"}],"is_playable":true,"name":"The Score","release_date":"1996-02-13","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4z6F5s3RVaOsekuaegbLfD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"}],"disc_number":1,"duration_ms":298733,"explicit":false,"external_ids":{"isrc":"USSM11508624"},"external_urls":{"spotify":"https://open.spotify.com/track/0EKow7JeCxHtweqQyVy5ko"},"href":"https://api.spotify.com/v1/tracks/0EKow7JeCxHtweqQyVy5ko","id":"0EKow7JeCxHtweqQyVy5ko","is_local":false,"is_playable":true,"name":"Killing Me Softly with His Song","track_number":8,"type":"track","uri":"spotify:track:0EKow7JeCxHtweqQyVy5ko"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"external_urls":{"spotify":"https://open.spotify.com/album/29pTiwvAAgbAjrl0g1twLy"},"href":"https://api.spotify.com/v1/albums/29pTiwvAAgbAjrl0g1twLy","id":"29pTiwvAAgbAjrl0g1twLy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27308c18e8a38e47817b6e9aed8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0208c18e8a38e47817b6e9aed8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485108c18e8a38e47817b6e9aed8"}],"is_playable":true,"name":"Greatest Hits","release_date":"2003-03-25","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:29pTiwvAAgbAjrl0g1twLy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7aBzpmFXB4WWpPl2F7RjBe"},"href":"https://api.spotify.com/v1/artists/7aBzpmFXB4WWpPl2F7RjBe","id":"7aBzpmFXB4WWpPl2F7RjBe","name":"Wyclef Jean","type":"artist","uri":"spotify:artist:7aBzpmFXB4WWpPl2F7RjBe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0kJMPTXq7h3ztpDukSx5iD"},"href":"https://api.spotify.com/v1/artists/0kJMPTXq7h3ztpDukSx5iD","id":"0kJMPTXq7h3ztpDukSx5iD","name":"Pras","type":"artist","uri":"spotify:artist:0kJMPTXq7h3ztpDukSx5iD"}],"disc_number":1,"duration_ms":290293,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/2HAVFycrhtbmLxyyxpm6JI"},"href":"https://api.spotify.com/v1/tracks/2HAVFycrhtbmLxyyxpm6JI","id":"2HAVFycrhtbmLxyyxpm6JI","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":5,"type":"track","uri":"spotify:track:2HAVFycrhtbmLxyyxpm6JI"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5wrB1poUL6qIAPBxC8oOi5"},"href":"https://api.spotify.com/v1/albums/5wrB1poUL6qIAPBxC8oOi5","id":"5wrB1poUL6qIAPBxC8oOi5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730b20cdcf933e3d4b5c86aede"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020b20cdcf933e3d4b5c86aede"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510b20cdcf933e3d4b5c86aede"}],"is_playable":true,"name":"2500 x TOP 40 Alarmschijf","release_date":"2018-03-30","release_date_precision":"day","total_tracks":104,"type":"album","uri":"spotify:album:5wrB1poUL6qIAPBxC8oOi5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":244666,"explicit":false,"external_ids":{"isrc":"USSM19503362"},"external_urls":{"spotify":"https://open.spotify.com/track/5fY7lXA3GXFpGbMW9wrdRQ"},"href":"https://api.spotify.com/v1/tracks/5fY7lXA3GXFpGbMW9wrdRQ","id":"5fY7lXA3GXFpGbMW9wrdRQ","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song - Radio Edit","track_number":53,"type":"track","uri":"spotify:track:5fY7lXA3GXFpGbMW9wrdRQ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6F41L5AXF6IgP0ch4y8qaq"},"href":"https://api.spotify.com/v1/albums/6F41L5AXF6IgP0ch4y8qaq","id":"6F41L5AXF6IgP0ch4y8qaq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27395d66e2e22b356a355186fb6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0295d66e2e22b356a355186fb6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485195d66e2e22b356a355186fb6"}],"is_playable":true,"name":"TOP 40 HITDOSSIER - #1 Hits","release_date":"2022-12-02","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:6F41L5AXF6IgP0ch4y8qaq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":244674,"explicit":false,"external_ids":{"isrc":"USSM19503362"},"external_urls":{"spotify":"https://open.spotify.com/track/5mWjdcdTJb5IFQhu6CIRwL"},"href":"https://api.spotify.com/v1/tracks/5mWjdcdTJb5IFQhu6CIRwL","id":"5mWjdcdTJb5IFQhu6CIRwL","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song - Radio Edit","track_number":35,"type":"track","uri":"spotify:track:5mWjdcdTJb5IFQhu6CIRwL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ChG0pQjLzXun4DNbqnDfp"},"href":"https://api.spotify.com/v1/albums/3ChG0pQjLzXun4DNbqnDfp","id":"3ChG0pQjLzXun4DNbqnDfp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273defddcc1c5b525859b81ebc8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02defddcc1c5b525859b81ebc8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851defddcc1c5b525859b81ebc8"}],"is_playable":true,"name":"90s R&B","release_date":"2014-09-26","release_date_precision":"day","total_tracks":60,"type":"album","uri":"spotify:album:3ChG0pQjLzXun4DNbqnDfp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":282106,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/7KghHnawa4wgfXmi2pssf4"},"href":"https://api.spotify.com/v1/tracks/7KghHnawa4wgfXmi2pssf4","id":"7KghHnawa4wgfXmi2pssf4","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":5,"type":"track","uri":"spotify:track:7KghHnawa4wgfXmi2pssf4"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0QhwxYDUougJiVDtyN4Lhm"},"href":"https://api.spotify.com/v1/albums/0QhwxYDUougJiVDtyN4Lhm","id":"0QhwxYDUougJiVDtyN4Lhm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c3fd856b637a87c675d2f29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c3fd856b637a87c675d2f29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c3fd856b637a87c675d2f29"}],"is_playable":true,"name":"R&B - 100 Hits - The Greatest R n B album - 100 R & B Classics featuring Usher, Pitbull and Synthetic Listener Timberlake","release_date":"2013-06-24","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0QhwxYDUougJiVDtyN4Lhm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":298666,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/3r3S4jo83XHvl4fQoH9sce"},"href":"https://api.spotify.com/v1/tracks/3r3S4jo83XHvl4fQoH9sce","id":"3r3S4jo83XHvl4fQoH9sce","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":68,"type":"track","uri":"spotify:track:3r3S4jo83XHvl4fQoH9sce"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5RwYlSZC0HX64LZ61yVzCs"},"href":"https://api.spotify.com/v1/albums/5RwYlSZC0HX64LZ61yVzCs","id":"5RwYlSZC0HX64LZ61yVzCs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b8f8e73d5b5e43c9603c179"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b8f8e73d5b5e43c9603c179"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b8f8e73d5b5e43c9603c179"}],"is_playable":true,"name":"TOP 40 HITDOSSIER - 90s (Nineties Top 100)","release_date":"2020-03-06","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:5RwYlSZC0HX64LZ61yVzCs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":291693,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/2W7YqpaYQD8XFQfDl8MkJa"},"href":"https://api.spotify.com/v1/tracks/2W7YqpaYQD8XFQfDl8MkJa","id":"2W7YqpaYQD8XFQfDl8MkJa","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":31,"type":"track","uri":"spotify:track:2W7YqpaYQD8XFQfDl8MkJa"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Killing%20Me%20Softly%20with%20His%20Song%22%20artist%3A%22Fugees%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7aBzpmFXB4WWpPl2F7RjBe"},"href":"https://api.spotify.com/v1/artists/7aBzpmFXB4WWpPl2F7RjBe","id":"7aBzpmFXB4WWpPl2F7RjBe","name":"Wyclef Jean","type":"artist","uri":"spotify:artist:7aBzpmFXB4WWpPl2F7RjBe"}],"external_urls":{"spotify":"https://open.spotify.com/album/18XFe4CPBgVezXkxZP6rTb"},"href":"https://api.spotify.com/v1/albums/18XFe4CPBgVezXkxZP6rTb","id":"18XFe4CPBgVezXkxZP6rTb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b7865be7f7fcc05faec6137"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b7865be7f7fcc05faec6137"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b7865be7f7fcc05faec6137"}],"is_playable":true,"name":"The Score (Expanded Edition)","release_date":"1996-02-13","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:18XFe4CPBgVezXkxZP6rTb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"}],"disc_number":1,"duration_ms":298666,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/0Q0IVlqMV64kNLlwjPj0Hl"},"href":"https://api.spotify.com/v1/tracks/0Q0IVlqMV64kNLlwjPj0Hl","id":"0Q0IVlqMV64kNLlwjPj0Hl","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":8,"type":"track","uri":"spotify:track:0Q0IVlqMV64kNLlwjPj0Hl"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"external_urls":{"spotify":"https://open.spotify.com/album/0D6QmUlYmrTExpUA3T4GTM"},"href":"https://api.spotify.com/v1/albums/0D6QmUlYmrTExpUA3T4GTM","id":"0D6QmUlYmrTExpUA3T4GTM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733d06c71068384b0ba4c47f62"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023d06c71068384b0ba4c47f62"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513d06c71068384b0ba4c47f62"}],"is_playable":true,"name":"Greatest Hits","release_date":"2003-03-25","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:0D6QmUlYmrTExpUA3T4GTM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":290266,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/7IuR13GY471Tbz4lp9DKOZ"},"href":"https://api.spotify.com/v1/tracks/7IuR13GY471Tbz4lp9DKOZ","id":"7IuR13GY471Tbz4lp9DKOZ","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":4,"type":"track","uri":"spotify:track:7IuR13GY471Tbz4lp9DKOZ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7aBzpmFXB4WWpPl2F7RjBe"},"href":"https://api.spotify.com/v1/artists/7aBzpmFXB4WWpPl2F7RjBe","id":"7aBzpmFXB4WWpPl2F7RjBe","name":"Wyclef Jean","type":"artist","uri":"spotify:artist:7aBzpmFXB4WWpPl2F7RjBe"}],"external_urls":{"spotify":"https://open.spotify.com/album/4z6F5s3RVaOsekuaegbLfD"},"href":"https://api.spotify.com/v1/albums/4z6F5s3RVaOsekuaegbLfD","id":"4z6F5s3RVaOsekuaegbLfD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273970c54109c747d26b56636eb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02970c54109c747d26b56636eb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851970c54109c747d26b56636eb"}],"is_playable":true,"name":"The Score","release_date":"1996-02-13","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4z6F5s3RVaOsekuaegbLfD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"}],"disc_number":1,"duration_ms":298733,"explicit":false,"external_ids":{"isrc":"USSM11508624"},"external_urls":{"spotify":"https://open.spotify.com/track/0EKow7JeCxHtweqQyVy5ko"},"href":"https://api.spotify.com/v1/tracks/0EKow7JeCxHtweqQyVy5ko","id":"0EKow7JeCxHtweqQyVy5ko","is_local":false,"is_playable":true,"name":"Killing Me Softly with His Song","track_number":8,"type":"track","uri":"spotify:track:0EKow7JeCxHtweqQyVy5ko"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"external_urls":{"spotify":"https://open.spotify.com/album/29pTiwvAAgbAjrl0g1twLy"},"href":"https://api.spotify.com/v1/albums/29pTiwvAAgbAjrl0g1twLy","id":"29pTiwvAAgbAjrl0g1twLy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27308c18e8a38e47817b6e9aed8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0208c18e8a38e47817b6e9aed8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485108c18e8a38e47817b6e9aed8"}],"is_playable":true,"name":"Greatest Hits","release_date":"2003-03-25","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:29pTiwvAAgbAjrl0g1twLy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2Mu5NfyYm8n5iTomuKAEHl"},"href":"https://api.spotify.com/v1/artists/2Mu5NfyYm8n5iTomuKAEHl","id":"2Mu5NfyYm8n5iTomuKAEHl","name":"Ms. Lauryn Hill","type":"artist","uri":"spotify:artist:2Mu5NfyYm8n5iTomuKAEHl"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7aBzpmFXB4WWpPl2F7RjBe"},"href":"https://api.spotify.com/v1/artists/7aBzpmFXB4WWpPl2F7RjBe","id":"7aBzpmFXB4WWpPl2F7RjBe","name":"Wyclef Jean","type":"artist","uri":"spotify:artist:7aBzpmFXB4WWpPl2F7RjBe"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0kJMPTXq7h3ztpDukSx5iD"},"href":"https://api.spotify.com/v1/artists/0kJMPTXq7h3ztpDukSx5iD","id":"0kJMPTXq7h3ztpDukSx5iD","name":"Pras","type":"artist","uri":"spotify:artist:0kJMPTXq7h3ztpDukSx5iD"}],"disc_number":1,"duration_ms":290293,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/2HAVFycrhtbmLxyyxpm6JI"},"href":"https://api.spotify.com/v1/tracks/2HAVFycrhtbmLxyyxpm6JI","id":"2HAVFycrhtbmLxyyxpm6JI","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":5,"type":"track","uri":"spotify:track:2HAVFycrhtbmLxyyxpm6JI"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5wrB1poUL6qIAPBxC8oOi5"},"href":"https://api.spotify.com/v1/albums/5wrB1poUL6qIAPBxC8oOi5","id":"5wrB1poUL6qIAPBxC8oOi5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730b20cdcf933e3d4b5c86aede"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020b20cdcf933e3d4b5c86aede"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510b20cdcf933e3d4b5c86aede"}],"is_playable":true,"name":"2500 x TOP 40 Alarmschijf","release_date":"2018-03-30","release_date_precision":"day","total_tracks":104,"type":"album","uri":"spotify:album:5wrB1poUL6qIAPBxC8oOi5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":244666,"explicit":false,"external_ids":{"isrc":"USSM19503362"},"external_urls":{"spotify":"https://open.spotify.com/track/5fY7lXA3GXFpGbMW9wrdRQ"},"href":"https://api.spotify.com/v1/tracks/5fY7lXA3GXFpGbMW9wrdRQ","id":"5fY7lXA3GXFpGbMW9wrdRQ","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song - Radio Edit","track_number":53,"type":"track","uri":"spotify:track:5fY7lXA3GXFpGbMW9wrdRQ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6F41L5AXF6IgP0ch4y8qaq"},"href":"https://api.spotify.com/v1/albums/6F41L5AXF6IgP0ch4y8qaq","id":"6F41L5AXF6IgP0ch4y8qaq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27395d66e2e22b356a355186fb6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0295d66e2e22b356a355186fb6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485195d66e2e22b356a355186fb6"}],"is_playable":true,"name":"TOP 40 HITDOSSIER - #1 Hits","release_date":"2022-12-02","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:6F41L5AXF6IgP0ch4y8qaq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":244674,"explicit":false,"external_ids":{"isrc":"USSM19503362"},"external_urls":{"spotify":"https://open.spotify.com/track/5mWjdcdTJb5IFQhu6CIRwL"},"href":"https://api.spotify.com/v1/tracks/5mWjdcdTJb5IFQhu6CIRwL","id":"5mWjdcdTJb5IFQhu6CIRwL","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song - Radio Edit","track_number":35,"type":"track","uri":"spotify:track:5mWjdcdTJb5IFQhu6CIRwL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ChG0pQjLzXun4DNbqnDfp"},"href":"https://api.spotify.com/v1/albums/3ChG0pQjLzXun4DNbqnDfp","id":"3ChG0pQjLzXun4DNbqnDfp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273defddcc1c5b525859b81ebc8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02defddcc1c5b525859b81ebc8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851defddcc1c5b525859b81ebc8"}],"is_playable":true,"name":"90s R&B","release_date":"2014-09-26","release_date_precision":"day","total_tracks":60,"type":"album","uri":"spotify:album:3ChG0pQjLzXun4DNbqnDfp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":282106,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/7KghHnawa4wgfXmi2pssf4"},"href":"https://api.spotify.com/v1/tracks/7KghHnawa4wgfXmi2pssf4","id":"7KghHnawa4wgfXmi2pssf4","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":5,"type":"track","uri":"spotify:track:7KghHnawa4wgfXmi2pssf4"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0QhwxYDUougJiVDtyN4Lhm"},"href":"https://api.spotify.com/v1/albums/0QhwxYDUougJiVDtyN4Lhm","id":"0QhwxYDUougJiVDtyN4Lhm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c3fd856b637a87c675d2f29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c3fd856b637a87c675d2f29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c3fd856b637a87c675d2f29"}],"is_playable":true,"name":"R&B - 100 Hits - The Greatest R n B album - 100 R & B Classics featuring Usher, Pitbull and Synthetic Listener Timberlake","release_date":"2013-06-24","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0QhwxYDUougJiVDtyN4Lhm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":298666,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/3r3S4jo83XHvl4fQoH9sce"},"href":"https://api.spotify.com/v1/tracks/3r3S4jo83XHvl4fQoH9sce","id":"3r3S4jo83XHvl4fQoH9sce","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":68,"type":"track","uri":"spotify:track:3r3S4jo83XHvl4fQoH9sce"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5RwYlSZC0HX64LZ61yVzCs"},"href":"https://api.spotify.com/v1/albums/5RwYlSZC0HX64LZ61yVzCs","id":"5RwYlSZC0HX64LZ61yVzCs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b8f8e73d5b5e43c9603c179"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b8f8e73d5b5e43c9603c179"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b8f8e73d5b5e43c9603c179"}],"is_playable":true,"name":"TOP 40 HITDOSSIER - 90s (Nineties Top 100)","release_date":"2020-03-06","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:5RwYlSZC0HX64LZ61yVzCs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2WKdxPFRD7IqZvlIAvhMgY"},"href":"https://api.spotify.com/v1/artists/2WKdxPFRD7IqZvlIAvhMgY","id":"2WKdxPFRD7IqZvlIAvhMgY","name":"Fugees","type":"artist","uri":"spotify:artist:2WKdxPFRD7IqZvlIAvhMgY"}],"disc_number":1,"duration_ms":291693,"explicit":true,"external_ids":{"isrc":"USSM19600055"},"external_urls":{"spotify":"https://open.spotify.com/track/2W7YqpaYQD8XFQfDl8MkJa"},"href":"https://api.spotify.com/v1/tracks/2W7YqpaYQD8XFQfDl8MkJa","id":"2W7YqpaYQD8XFQfDl8MkJa","is_local":false,"is_playable":true,"name":"Killing Me Softly With His Song","track_number":31,"type":"track","uri":"spotify:track:2W7YqpaYQD8XFQfDl8MkJa"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Killing+Me+Softly+with+His+Song%22+artist%3A%22Fugees%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22No%20Diggity%22%20artist%3A%22Blackstreet%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"}],"external_urls":{"spotify":"https://open.spotify.com/album/2zGZLQiFl9UubtrVmtIkbi"},"href":"https://api.spotify.com/v1/albums/2zGZLQiFl9UubtrVmtIkbi","id":"2zGZLQiFl9UubtrVmtIkbi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27303ca37157b9ceefbe8fe225b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0203ca37157b9ceefbe8fe225b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485103ca37157b9ceefbe8fe225b"}],"is_playable":true,"name":"Another Level","release_date":"1996-09-09","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:2zGZLQiFl9UubtrVmtIkbi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0VbIlorLz3I5SEtIsc5vAr"},"href":"https://api.spotify.com/v1/artists/0VbIlorLz3I5SEtIsc5vAr","id":"0VbIlorLz3I5SEtIsc5vAr","name":"Queen Pen","type":"artist","uri":"spotify:artist:0VbIlorLz3I5SEtIsc5vAr"}],"disc_number":1,"duration_ms":304600,"explicit":false,"external_ids":{"isrc":"USIR19600978"},"external_urls":{"spotify":"https://open.spotify.com/track/6MdqqkQ8sSC0WB4i8PyRuQ"},"href":"https://api.spotify.com/v1/tracks/6MdqqkQ8sSC0WB4i8PyRuQ","id":"6MdqqkQ8sSC0WB4i8PyRuQ","is_local":false,"is_playable":true,"name":"No Diggity","track_number":3,"type":"track","uri":"spotify:track:6MdqqkQ8sSC0WB4i8PyRuQ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"}],"external_urls":{"spotify":"https://open.spotify.com/album/5iEdkyR0Ez5wQLQFphYYAU"},"href":"https://api.spotify.com/v1/albums/5iEdkyR0Ez5wQLQFphYYAU","id":"5iEdkyR0Ez5wQLQFphYYAU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273712adf549c0e899738daf13e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02712adf549c0e899738daf13e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851712adf549c0e899738daf13e"}],"is_playable":true,"name":"No Diggity: The Very Best Of Blackstreet","release_date":"2003-01-01","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5iEdkyR0Ez5wQLQFphYYAU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0VbIlorLz3I5SEtIsc5vAr"},"href":"https://api.spotify.com/v1/artists/0VbIlorLz3I5SEtIsc5vAr","id":"0VbIlorLz3I5SEtIsc5vAr","name":"Queen Pen","type":"artist","uri":"spotify:artist:0VbIlorLz3I5SEtIsc5vAr"}],"disc_number":1,"duration_ms":305706,"explicit":false,"external_ids":{"isrc":"USIR19600978"},"external_urls":{"spotify":"https://open.spotify.com/track/5eyIfIp6IafrdAjRnZF6ql"},"href":"https://api.spotify.com/v1/tracks/5eyIfIp6IafrdAjRnZF6ql","id":"5eyIfIp6IafrdAjRnZF6ql","is_local":false,"is_playable":true,"name":"No Diggity","track_number":7,"type":"track","uri":"spotify:track:5eyIfIp6IafrdAjRnZF6ql"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5wwneIFdawNgQ7GvKK29Z3"},"href":"https://api.spotify.com/v1/artists/5wwneIFdawNgQ7GvKK29Z3","id":"5wwneIFdawNgQ7GvKK29Z3","name":"Lucas & Steve","type":"artist","uri":"spotify:artist:5wwneIFdawNgQ7GvKK29Z3"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"}],"external_urls":{"spotify":"https://open.spotify.com/album/1x66drtf4CW5onOaeS0oz3"},"href":"https://api.spotify.com/v1/albums/1x66drtf4CW5onOaeS0oz3","id":"1x66drtf4CW5onOaeS0oz3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273988bc47878f332f34bcd2384"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02988bc47878f332f34bcd2384"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851988bc47878f332f34bcd2384"}],"is_playable":true,"name":"No Diggity","release_date":"2021-03-26","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1x66drtf4CW5onOaeS0oz3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5wwneIFdawNgQ7GvKK29Z3"},"href":"https://api.spotify.com/v1/artists/5wwneIFdawNgQ7GvKK29Z3","id":"5wwneIFdawNgQ7GvKK29Z3","name":"Lucas & Steve","type":"artist","uri":"spotify:artist:5wwneIFdawNgQ7GvKK29Z3"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"}],"disc_number":1,"duration_ms":168727,"explicit":false,"external_ids":{"isrc":"NLZ542100332"},"external_urls":{"spotify":"https://open.spotify.com/track/32PKQDEaouIIOlNZ5umoR6"},"href":"https://api.spotify.com/v1/tracks/32PKQDEaouIIOlNZ5umoR6","id":"32PKQDEaouIIOlNZ5umoR6","is_local":false,"is_playable":true,"name":"No Diggity","track_number":1,"type":"track","uri":"spotify:track:32PKQDEaouIIOlNZ5umoR6"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2DW5ffPVewXy3AzFw4e7ve"},"href":"https://api.spotify.com/v1/albums/2DW5ffPVewXy3AzFw4e7ve","id":"2DW5ffPVewXy3AzFw4e7ve","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733e3d14f69e56cf749c13b8ec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023e3d14f69e56cf749c13b8ec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513e3d14f69e56cf749c13b8ec"}],"is_playable":true,"name":"Hip Hop - Universal Masters","release_date":"2003-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:2DW5ffPVewXy3AzFw4e7ve"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0VbIlorLz3I5SEtIsc5vAr"},"href":"https://api.spotify.com/v1/artists/0VbIlorLz3I5SEtIsc5vAr","id":"0VbIlorLz3I5SEtIsc5vAr","name":"Queen Pen","type":"artist","uri":"spotify:artist:0VbIlorLz3I5SEtIsc5vAr"}],"disc_number":1,"duration_ms":305573,"explicit":false,"external_ids":{"isrc":"USIR19600978"},"external_urls":{"spotify":"https://open.spotify.com/track/0BSUsLKmtxKWFckXM4CVTH"},"href":"https://api.spotify.com/v1/tracks/0BSUsLKmtxKWFckXM4CVTH","id":"0BSUsLKmtxKWFckXM4CVTH","is_local":false,"is_playable":true,"name":"No Diggity","track_number":8,"type":"track","uri":"spotify:track:0BSUsLKmtxKWFckXM4CVTH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4px2gCCX8nUzNj6tF4AAVa"},"href":"https://api.spotify.com/v1/albums/4px2gCCX8nUzNj6tF4AAVa","id":"4px2gCCX8nUzNj6tF4AAVa","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273165e4fc265b97a58afbdda00"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02165e4fc265b97a58afbdda00"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851165e4fc265b97a58afbdda00"}],"is_playable":true,"name":"R&B The Collection Summer 2011","release_date":"2011-01-01","release_date_precision":"day","total_tracks":36,"type":"album","uri":"spotify:album:4px2gCCX8nUzNj6tF4AAVa"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"}],"disc_number":1,"duration_ms":250493,"explicit":false,"external_ids":{"isrc":"USIR10210930"},"external_urls":{"spotify":"https://open.spotify.com/track/65UD72ckpIjFvYj18tQFF4"},"href":"https://api.spotify.com/v1/tracks/65UD72ckpIjFvYj18tQFF4","id":"65UD72ckpIjFvYj18tQFF4","is_local":false,"is_playable":true,"name":"No Diggity - Radio Version","track_number":10,"type":"track","uri":"spotify:track:65UD72ckpIjFvYj18tQFF4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"}],"external_urls":{"spotify":"https://open.spotify.com/album/5w5xPRh1SlQ6FejC1LCYYd"},"href":"https://api.spotify.com/v1/albums/5w5xPRh1SlQ6FejC1LCYYd","id":"5w5xPRh1SlQ6FejC1LCYYd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aa52ae0211bb7cbcf047aae3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aa52ae0211bb7cbcf047aae3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aa52ae0211bb7cbcf047aae3"}],"is_playable":true,"name":"Another Level (Expanded Edition)","release_date":"1996-09-10","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:5w5xPRh1SlQ6FejC1LCYYd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0VbIlorLz3I5SEtIsc5vAr"},"href":"https://api.spotify.com/v1/artists/0VbIlorLz3I5SEtIsc5vAr","id":"0VbIlorLz3I5SEtIsc5vAr","name":"Queen Pen","type":"artist","uri":"spotify:artist:0VbIlorLz3I5SEtIsc5vAr"}],"disc_number":1,"duration_ms":304600,"explicit":false,"external_ids":{"isrc":"USIR19600978"},"external_urls":{"spotify":"https://open.spotify.com/track/5tzDYbMDhomaADt9hKhANt"},"href":"https://api.spotify.com/v1/tracks/5tzDYbMDhomaADt9hKhANt","id":"5tzDYbMDhomaADt9hKhANt","is_local":false,"is_playable":true,"name":"No Diggity","track_number":3,"type":"track","uri":"spotify:track:5tzDYbMDhomaADt9hKhANt"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5wwneIFdawNgQ7GvKK29Z3"},"href":"https://api.spotify.com/v1/artists/5wwneIFdawNgQ7GvKK29Z3","id":"5wwneIFdawNgQ7GvKK29Z3","name":"Lucas & Steve","type":"artist","uri":"spotify:artist:5wwneIFdawNgQ7GvKK29Z3"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2gduEC76ry33RVurAvT05p"},"href":"https://api.spotify.com/v1/artists/2gduEC76ry33RVurAvT05p","id":"2gduEC76ry33RVurAvT05p","name":"Nathan Dawe","type":"artist","uri":"spotify:artist:2gduEC76ry33RVurAvT05p"}],"external_urls":{"spotify":"https://open.spotify.com/album/1hBZF3FJVp7ZFZgE7gkqN9"},"href":"https://api.spotify.com/v1/albums/1hBZF3FJVp7ZFZgE7gkqN9","id":"1hBZF3FJVp7ZFZgE7gkqN9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fa06b89b9700aa7ed0f62add"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fa06b89b9700aa7ed0f62add"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fa06b89b9700aa7ed0f62add"}],"is_playable":true,"name":"No Diggity (Nathan Dawe Remix)","release_date":"2021-06-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1hBZF3FJVp7ZFZgE7gkqN9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5wwneIFdawNgQ7GvKK29Z3"},"href":"https://api.spotify.com/v1/artists/5wwneIFdawNgQ7GvKK29Z3","id":"5wwneIFdawNgQ7GvKK29Z3","name":"Lucas & Steve","type":"artist","uri":"spotify:artist:5wwneIFdawNgQ7GvKK29Z3"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2gduEC76ry33RVurAvT05p"},"href":"https://api.spotify.com/v1/artists/2gduEC76ry33RVurAvT05p","id":"2gduEC76ry33RVurAvT05p","name":"Nathan Dawe","type":"artist","uri":"spotify:artist:2gduEC76ry33RVurAvT05p"}],"disc_number":1,"duration_ms":156525,"explicit":false,"external_ids":{"isrc":"NLZ542100920"},"external_urls":{"spotify":"https://open.spotify.com/track/530B0PHyIWouZrZ6dUWlPK"},"href":"https://api.spotify.com/v1/tracks/530B0PHyIWouZrZ6dUWlPK","id":"530B0PHyIWouZrZ6dUWlPK","is_local":false,"is_playable":true,"name":"No Diggity - Nathan Dawe Remix","track_number":1,"type":"track","uri":"spotify:track:530B0PHyIWouZrZ6dUWlPK"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5B8yXRhRIxrBNlhyFfFwEt"},"href":"https://api.spotify.com/v1/albums/5B8yXRhRIxrBNlhyFfFwEt","id":"5B8yXRhRIxrBNlhyFfFwEt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27394c061512e2f62f618651eb8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0294c061512e2f62f618651eb8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485194c061512e2f62f618651eb8"}],"is_playable":true,"name":"Ultimate R&B 2008 (Double Album)","release_date":"2008-01-01","release_date_precision":"day","total_tracks":38,"type":"album","uri":"spotify:album:5B8yXRhRIxrBNlhyFfFwEt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0VbIlorLz3I5SEtIsc5vAr"},"href":"https://api.spotify.com/v1/artists/0VbIlorLz3I5SEtIsc5vAr","id":"0VbIlorLz3I5SEtIsc5vAr","name":"Queen Pen","type":"artist","uri":"spotify:artist:0VbIlorLz3I5SEtIsc5vAr"}],"disc_number":1,"duration_ms":305973,"explicit":false,"external_ids":{"isrc":"USIR19600978"},"external_urls":{"spotify":"https://open.spotify.com/track/68j7Tt2bxcK3VcF8bWcarz"},"href":"https://api.spotify.com/v1/tracks/68j7Tt2bxcK3VcF8bWcarz","id":"68j7Tt2bxcK3VcF8bWcarz","is_local":false,"is_playable":true,"name":"No Diggity","track_number":10,"type":"track","uri":"spotify:track:68j7Tt2bxcK3VcF8bWcarz"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"}],"external_urls":{"spotify":"https://open.spotify.com/album/0cO62CmE0QoXp29Jb4Ovqv"},"href":"https://api.spotify.com/v1/albums/0cO62CmE0QoXp29Jb4Ovqv","id":"0cO62CmE0QoXp29Jb4Ovqv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a53ba0d93a6de9334d4b7efb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a53ba0d93a6de9334d4b7efb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a53ba0d93a6de9334d4b7efb"}],"is_playable":true,"name":"The Best Of BLACKstreet - 20th Century Masters The Millennium Collection","release_date":"2004-01-01","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:0cO62CmE0QoXp29Jb4Ovqv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2P3cjUru4H3fhSXXNxE9kA"},"href":"https://api.spotify.com/v1/artists/2P3cjUru4H3fhSXXNxE9kA","id":"2P3cjUru4H3fhSXXNxE9kA","name":"Blackstreet","type":"artist","uri":"spotify:artist:2P3cjUru4H3fhSXXNxE9kA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0VbIlorLz3I5SEtIsc5vAr"},"href":"https://api.spotify.com/v1/artists/0VbIlorLz3I5SEtIsc5vAr","id":"0VbIlorLz3I5SEtIsc5vAr","name":"Queen Pen","type":"artist","uri":"spotify:artist:0VbIlorLz3I5SEtIsc5vAr"}],"disc_number":1,"duration_ms":306440,"explicit":false,"external_ids":{"isrc":"USIR19600978"},"external_urls":{"spotify":"https://open.spotify.com/track/61HmUv8Zuh8IJXMrQej0hO"},"href":"https://api.spotify.com/v1/tracks/61HmUv8Zuh8IJXMrQej0hO","id":"61HmUv8Zuh8IJXMrQej0hO","is_local":false,"is_playable":true,"name":"No Diggity","track_number":5,"type":"track","uri":"spotify:track:61HmUv8Zuh8IJXMrQej0hO"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk5vJTIwRGlnZ2l0eSUyMiUyMGFydGlzdCUzQSUyMkJsYWNrc3RyZWV0JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo5LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJpZCI6IjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJuYW1lIjoiQmxhY2tzdHJlZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJ6R1pMUWlGbDlVdWJ0clZtdElrYmkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yekdaTFFpRmw5VXVidHJWbXRJa2JpIiwiaWQiOiIyekdaTFFpRmw5VXVidHJWbXRJa2JpIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28v", + "aW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzAzY2EzNzE1N2I5Y2VlZmJlOGZlMjI1YiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwM2NhMzcxNTdiOWNlZWZiZThmZTIyNWIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAzY2EzNzE1N2I5Y2VlZmJlOGZlMjI1YiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbm90aGVyIExldmVsIiwicmVsZWFzZV9kYXRlIjoiMTk5Ni0wOS0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJ6R1pMUWlGbDlVdWJ0clZtdElrYmkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJpZCI6IjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJuYW1lIjoiQmxhY2tzdHJlZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RFBZaXlxNWtXVlFTNFJHd3h6UEM3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZEUFlpeXE1a1dWUVM0Ukd3eHpQQzciLCJpZCI6IjZEUFlpeXE1a1dWUVM0Ukd3eHpQQzciLCJuYW1lIjoiRHIuIERyZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2RFBZaXlxNWtXVlFTNFJHd3h6UEM3In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBWYklsb3JMejNJNVNFdElzYzV2QXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFZiSWxvckx6M0k1U0V0SXNjNXZBciIsImlkIjoiMFZiSWxvckx6M0k1U0V0SXNjNXZBciIsIm5hbWUiOiJRdWVlbiBQZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFZiSWxvckx6M0k1U0V0SXNjNXZBciJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDQ2MDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0lSMTk2MDA5NzgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuYw==", + "b20vdHJhY2svNk1kcXFrUThzU0MwV0I0aThQeVJ1USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZNZHFxa1E4c1NDMFdCNGk4UHlSdVEiLCJpZCI6IjZNZHFxa1E4c1NDMFdCNGk4UHlSdVEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTm8gRGlnZ2l0eSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2TWRxcWtROHNTQzBXQjRpOFB5UnVRIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlAzY2pVcnU0SDNmaFNYWE54RTlrQSIsImlkIjoiMlAzY2pVcnU0SDNmaFNYWE54RTlrQSIsIm5hbWUiOiJCbGFja3N0cmVldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyUDNjalVydTRIM2ZoU1hYTnhFOWtBIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNWlFZGt5UjBFejV3UUxRRnBoWVlBVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVpRWRreVIwRXo1d1FMUUZwaFlZQVUiLCJpZCI6IjVpRWRreVIwRXo1d1FMUUZwaFlZQVUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzEyYWRmNTQ5YzBlODk5NzM4ZGFmMTNlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjcxMmFkZjU0OWMwZTg5OTczOGRhZjEzZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzEyYWRmNTQ5YzBlODk5NzM4ZGFmMTNlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vIERpZ2dpdHk6IFRoZSBWZXJ5IEJlc3QgT2YgQmxhY2tzdHJlZXQiLCJyZWxlYXNlX2RhdGUiOiIyMDAzLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NWlFZGt5UjBFejV3UUxRRnBoWVlBVSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EifSwiaHJlZg==", + "IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIiwiaWQiOiIyUDNjalVydTRIM2ZoU1hYTnhFOWtBIiwibmFtZSI6IkJsYWNrc3RyZWV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RFBZaXlxNWtXVlFTNFJHd3h6UEM3IiwiaWQiOiI2RFBZaXlxNWtXVlFTNFJHd3h6UEM3IiwibmFtZSI6IkRyLiBEcmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkRQWWl5cTVrV1ZRUzRSR3d4elBDNyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wVmJJbG9yTHozSTVTRXRJc2M1dkFyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBWYklsb3JMejNJNVNFdElzYzV2QXIiLCJpZCI6IjBWYklsb3JMejNJNVNFdElzYzV2QXIiLCJuYW1lIjoiUXVlZW4gUGVuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBWYklsb3JMejNJNVNFdElzYzV2QXIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzA1NzA2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNJUjE5NjAwOTc4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81ZXlJZklwNklhZnJkQWpSblpGNnFsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNWV5SWZJcDZJYWZyZEFqUm5aRjZxbCIsImlkIjoiNWV5SWZJcDZJYWZyZEFqUm5aRjZxbCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJObyBEaWdnaXR5IiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVleUlmSXA2SWFmcmRBalJuWkY2cWwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV3d25lSUZkYXdOZ1E3R3ZLSzI5WjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXd3bmVJRmRhd05nUTdHdktLMjlaMyIsImlkIjoiNXd3bmVJRmRhd05nUTdHdktLMjlaMyIsIm5hbWUiOiJMdWNhcyAmIFN0ZXZlIiwidHlwZSI6ImFydGlzdCIsIg==", + "dXJpIjoic3BvdGlmeTphcnRpc3Q6NXd3bmVJRmRhd05nUTdHdktLMjlaMyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJpZCI6IjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJuYW1lIjoiQmxhY2tzdHJlZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzF4NjZkcnRmNENXNW9uT2FlUzBvejMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xeDY2ZHJ0ZjRDVzVvbk9hZVMwb3ozIiwiaWQiOiIxeDY2ZHJ0ZjRDVzVvbk9hZVMwb3ozIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzk4OGJjNDc4NzhmMzMyZjM0YmNkMjM4NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5ODhiYzQ3ODc4ZjMzMmYzNGJjZDIzODQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTk4OGJjNDc4NzhmMzMyZjM0YmNkMjM4NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJObyBEaWdnaXR5IiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wMy0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXg2NmRydGY0Q1c1b25PYWVTMG96MyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV3d25lSUZkYXdOZ1E3R3ZLSzI5WjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXd3bmVJRmRhd05nUTdHdktLMjlaMyIsImlkIjoiNXd3bmVJRmRhd05nUTdHdktLMjlaMyIsIm5hbWUiOiJMdWNhcyAmIFN0ZXZlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV3d25lSUZkYXdOZ1E3R3ZLSzI5WjMifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdg==", + "MS9hcnRpc3RzLzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJpZCI6IjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJuYW1lIjoiQmxhY2tzdHJlZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjg3MjcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFo1NDIxMDAzMzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzMyUEtRREVhb3VJSU9sTlo1dW1vUjYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zMlBLUURFYW91SUlPbE5aNXVtb1I2IiwiaWQiOiIzMlBLUURFYW91SUlPbE5aNXVtb1I2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vIERpZ2dpdHkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MzJQS1FERWFvdUlJT2xOWjV1bW9SNiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yRFc1ZmZQVmV3WHkzQXpGdzRlN3ZlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMkRXNWZmUFZld1h5M0F6Rnc0ZTd2ZSIsImlkIjoiMkRXNWZmUFZld1h5M0F6Rnc0ZTd2ZSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzZTNkMTRmNjllNTZjZjc0OWMxM2I4ZWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyM2UzZDE0ZjY5ZTU2Y2Y3NDljMTNiOGVjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzZTNkMTRmNjllNTZjZjc0OWMxM2I4ZWMifV0sImlzX3BsYXlhYmxlIg==", + "OnRydWUsIm5hbWUiOiJIaXAgSG9wIC0gVW5pdmVyc2FsIE1hc3RlcnMiLCJyZWxlYXNlX2RhdGUiOiIyMDAzLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MkRXNWZmUFZld1h5M0F6Rnc0ZTd2ZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlAzY2pVcnU0SDNmaFNYWE54RTlrQSIsImlkIjoiMlAzY2pVcnU0SDNmaFNYWE54RTlrQSIsIm5hbWUiOiJCbGFja3N0cmVldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyUDNjalVydTRIM2ZoU1hYTnhFOWtBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZEUFlpeXE1a1dWUVM0Ukd3eHpQQzcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyIsImlkIjoiNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyIsIm5hbWUiOiJEci4gRHJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZEUFlpeXE1a1dWUVM0Ukd3eHpQQzcifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFZiSWxvckx6M0k1U0V0SXNjNXZBciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wVmJJbG9yTHozSTVTRXRJc2M1dkFyIiwiaWQiOiIwVmJJbG9yTHozSTVTRXRJc2M1dkFyIiwibmFtZSI6IlF1ZWVuIFBlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowVmJJbG9yTHozSTVTRXRJc2M1dkFyIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwNTU3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSVIxOTYwMDk3OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMEJTVXNMS210eEtXRmNrWE00Q1ZUSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBCU1VzTEttdHhLV0Zja1hNNENWVEgiLCJpZCI6IjBCU1VzTEttdHhLV0Zja1hNNENWVEgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTm8gRGlnZ2l0eSIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowQlNVc0xLbQ==", + "dHhLV0Zja1hNNENWVEgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNHB4MmdDQ1g4blV6Tmo2dEY0QUFWYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRweDJnQ0NYOG5Vek5qNnRGNEFBVmEiLCJpZCI6IjRweDJnQ0NYOG5Vek5qNnRGNEFBVmEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMTY1ZTRmYzI2NWI5N2E1OGFmYmRkYTAwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE2NWU0ZmMyNjViOTdhNThhZmJkZGEwMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTY1ZTRmYzI2NWI5N2E1OGFmYmRkYTAwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlImQiBUaGUgQ29sbGVjdGlvbiBTdW1tZXIgMjAxMSIsInJlbGVhc2VfZGF0ZSI6IjIwMTEtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0cHgyZ0NDWDhuVXpOajZ0RjRBQVZhIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIiwiaWQiOiIyUDNjalVydTRIM2ZoU1hYTnhFOWtBIiwibmFtZSI6IkJsYWNrc3RyZWV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkRQWWl5cTVrV1ZRUzRSRw==", + "d3h6UEM3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZEUFlpeXE1a1dWUVM0Ukd3eHpQQzciLCJpZCI6IjZEUFlpeXE1a1dWUVM0Ukd3eHpQQzciLCJuYW1lIjoiRHIuIERyZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2RFBZaXlxNWtXVlFTNFJHd3h6UEM3In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1MDQ5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSVIxMDIxMDkzMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNjVVRDcyY2twSWpGdllqMTh0UUZGNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzY1VUQ3MmNrcElqRnZZajE4dFFGRjQiLCJpZCI6IjY1VUQ3MmNrcElqRnZZajE4dFFGRjQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTm8gRGlnZ2l0eSAtIFJhZGlvIFZlcnNpb24iLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjY1VUQ3MmNrcElqRnZZajE4dFFGRjQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIiwiaWQiOiIyUDNjalVydTRIM2ZoU1hYTnhFOWtBIiwibmFtZSI6IkJsYWNrc3RyZWV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81dzV4UFJoMVNsUTZGZWpDMUxDWVlkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNXc1eFBSaDFTbFE2RmVqQzFMQ1lZZCIsImlkIjoiNXc1eFBSaDFTbFE2RmVqQzFMQ1lZZCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhYTUyYWUwMjExYmI3Y2JjZjA0N2FhZTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWE1MmFlMDIxMWJiN2NiY2YwNDdhYWUzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMA==", + "NDg1MWFhNTJhZTAyMTFiYjdjYmNmMDQ3YWFlMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbm90aGVyIExldmVsIChFeHBhbmRlZCBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjE5OTYtMDktMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyOSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1dzV4UFJoMVNsUTZGZWpDMUxDWVlkIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIiwiaWQiOiIyUDNjalVydTRIM2ZoU1hYTnhFOWtBIiwibmFtZSI6IkJsYWNrc3RyZWV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RFBZaXlxNWtXVlFTNFJHd3h6UEM3IiwiaWQiOiI2RFBZaXlxNWtXVlFTNFJHd3h6UEM3IiwibmFtZSI6IkRyLiBEcmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkRQWWl5cTVrV1ZRUzRSR3d4elBDNyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wVmJJbG9yTHozSTVTRXRJc2M1dkFyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBWYklsb3JMejNJNVNFdElzYzV2QXIiLCJpZCI6IjBWYklsb3JMejNJNVNFdElzYzV2QXIiLCJuYW1lIjoiUXVlZW4gUGVuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBWYklsb3JMejNJNVNFdElzYzV2QXIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzA0NjAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNJUjE5NjAwOTc4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81dHpEWWJNRGhvbWFBRHQ5aEtoQU50In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNXR6RFliTURob21hQUR0OWhLaEFOdCIsImlkIjoiNXR6RFliTURob21hQUR0OWhLaEFOdCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJObyBEaWdnaXR5IiwidHJhY2tfbnVtYg==", + "ZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXR6RFliTURob21hQUR0OWhLaEFOdCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXd3bmVJRmRhd05nUTdHdktLMjlaMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81d3duZUlGZGF3TmdRN0d2S0syOVozIiwiaWQiOiI1d3duZUlGZGF3TmdRN0d2S0syOVozIiwibmFtZSI6Ikx1Y2FzICYgU3RldmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXd3bmVJRmRhd05nUTdHdktLMjlaMyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJpZCI6IjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJuYW1lIjoiQmxhY2tzdHJlZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yZ2R1RUM3NnJ5MzNSVnVyQXZUMDVwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJnZHVFQzc2cnkzM1JWdXJBdlQwNXAiLCJpZCI6IjJnZHVFQzc2cnkzM1JWdXJBdlQwNXAiLCJuYW1lIjoiTmF0aGFuIERhd2UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmdkdUVDNzZyeTMzUlZ1ckF2VDA1cCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFoQlpGM0ZKVnA3WkZaZ0U3Z2txTjkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xaEJaRjNGSlZwN1pGWmdFN2drcU45IiwiaWQiOiIxaEJaRjNGSlZwN1pGWmdFN2drcU45IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ZhMDZiODliOTcwMGFhN2VkMGY2MmFkZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmYTA2Yjg5Yjk3MDBhYTdlZDBmNjJhZGQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWZhMA==", + "NmI4OWI5NzAwYWE3ZWQwZjYyYWRkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vIERpZ2dpdHkgKE5hdGhhbiBEYXdlIFJlbWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDYtMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFoQlpGM0ZKVnA3WkZaZ0U3Z2txTjkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81d3duZUlGZGF3TmdRN0d2S0syOVozIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV3d25lSUZkYXdOZ1E3R3ZLSzI5WjMiLCJpZCI6IjV3d25lSUZkYXdOZ1E3R3ZLSzI5WjMiLCJuYW1lIjoiTHVjYXMgJiBTdGV2ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1d3duZUlGZGF3TmdRN0d2S0syOVozIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlAzY2pVcnU0SDNmaFNYWE54RTlrQSIsImlkIjoiMlAzY2pVcnU0SDNmaFNYWE54RTlrQSIsIm5hbWUiOiJCbGFja3N0cmVldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyUDNjalVydTRIM2ZoU1hYTnhFOWtBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJnZHVFQzc2cnkzM1JWdXJBdlQwNXAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmdkdUVDNzZyeTMzUlZ1ckF2VDA1cCIsImlkIjoiMmdkdUVDNzZyeTMzUlZ1ckF2VDA1cCIsIm5hbWUiOiJOYXRoYW4gRGF3ZSIsInR5cGU=", + "IjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmdkdUVDNzZyeTMzUlZ1ckF2VDA1cCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNTY1MjUsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOTFo1NDIxMDA5MjAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzUzMEIwUEh5SVdvdVpyWjZkVVdsUEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81MzBCMFBIeUlXb3Vaclo2ZFVXbFBLIiwiaWQiOiI1MzBCMFBIeUlXb3Vaclo2ZFVXbFBLIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vIERpZ2dpdHkgLSBOYXRoYW4gRGF3ZSBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1MzBCMFBIeUlXb3Vaclo2ZFVXbFBLIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVCOHlYUmhSSXhyQk5saHlGZkZ3RXQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81Qjh5WFJoUkl4ckJObGh5RmZGd0V0IiwiaWQiOiI1Qjh5WFJoUkl4ckJObGh5RmZGd0V0IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzk0YzA2MTUxMmUyZjYyZjYxODY1MWViOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5NGMwNjE1MTJlMmY2MmY2MTg2NTFlYjgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTk0YzA2MTUxMmUyZjYyZjYxODY1MWViOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJVbHRpbWF0ZSBSJkIgMjAwOCAoRG91YmxlIEFsYnVtKSIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMA==", + "MS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVCOHlYUmhSSXhyQk5saHlGZkZ3RXQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJpZCI6IjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJuYW1lIjoiQmxhY2tzdHJlZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RFBZaXlxNWtXVlFTNFJHd3h6UEM3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZEUFlpeXE1a1dWUVM0Ukd3eHpQQzciLCJpZCI6IjZEUFlpeXE1a1dWUVM0Ukd3eHpQQzciLCJuYW1lIjoiRHIuIERyZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2RFBZaXlxNWtXVlFTNFJHd3h6UEM3In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBWYklsb3JMejNJNVNFdElzYzV2QXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFZiSWxvckx6M0k1U0V0SXNjNXZBciIsImlkIjoiMFZiSWxvckx6M0k1U0V0SXNjNXZBciIsIm5hbWUiOiJRdWVlbiBQZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFZiSWxvckx6M0k1U0V0SXNjNXZBciJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDU5NzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0lSMTk2MDA5NzgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzY4ajdUdDJieGNLM1ZjRjhiV2NhcnoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82OGo3VHQyYnhjSzNWY0Y4YldjYXJ6IiwiaWQiOiI2OGo3VHQyYnhjSzNWY0Y4YldjYXJ6IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vIERpZ2dpdHkiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjY4ajdUdDJieGNLM1ZjRjhiV2NhcnoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOg==", + "W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yUDNjalVydTRIM2ZoU1hYTnhFOWtBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJpZCI6IjJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EiLCJuYW1lIjoiQmxhY2tzdHJlZXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlAzY2pVcnU0SDNmaFNYWE54RTlrQSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBjTzYyQ21FMFFvWHAyOUpiNE92cXYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wY082MkNtRTBRb1hwMjlKYjRPdnF2IiwiaWQiOiIwY082MkNtRTBRb1hwMjlKYjRPdnF2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2E1M2JhMGQ5M2E2ZGU5MzM0ZDRiN2VmYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhNTNiYTBkOTNhNmRlOTMzNGQ0YjdlZmIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWE1M2JhMGQ5M2E2ZGU5MzM0ZDRiN2VmYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgQmVzdCBPZiBCTEFDS3N0cmVldCAtIDIwdGggQ2VudHVyeSBNYXN0ZXJzIFRoZSBNaWxsZW5uaXVtIENvbGxlY3Rpb24iLCJyZWxlYXNlX2RhdGUiOiIyMDA0LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MGNPNjJDbUUwUW9YcDI5SmI0T3ZxdiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJQM2NqVXJ1NEgzZmhTWFhOeEU5a0EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlAzY2pVcnU0SDNmaFNYWE54RTlrQSIsImlkIjoiMlAzY2pVcnU0SDNmaFNYWE54RTlrQSIsIm5hbWUiOiJCbGFja3N0cmVldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyUDNjalVydTRIM2ZoU1hYTnhFOWtBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZEUFlpeXE1a1dWUVM0Ukd3eHpQQzcifSwiaHJlZiI6Imh0dHBzOi8vYQ==", + "cGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RFBZaXlxNWtXVlFTNFJHd3h6UEM3IiwiaWQiOiI2RFBZaXlxNWtXVlFTNFJHd3h6UEM3IiwibmFtZSI6IkRyLiBEcmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkRQWWl5cTVrV1ZRUzRSR3d4elBDNyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wVmJJbG9yTHozSTVTRXRJc2M1dkFyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBWYklsb3JMejNJNVNFdElzYzV2QXIiLCJpZCI6IjBWYklsb3JMejNJNVNFdElzYzV2QXIiLCJuYW1lIjoiUXVlZW4gUGVuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBWYklsb3JMejNJNVNFdElzYzV2QXIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzA2NDQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNJUjE5NjAwOTc4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82MUhtVXY4WnVoOElKWE1yUWVqMGhPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNjFIbVV2OFp1aDhJSlhNclFlajBoTyIsImlkIjoiNjFIbVV2OFp1aDhJSlhNclFlajBoTyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJObyBEaWdnaXR5IiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjYxSG1VdjhadWg4SUpYTXJRZWowaE8ifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22No+Diggity%22+artist%3A%22Blackstreet%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Losing%20My%20Religion%22%20artist%3A%22R.E.M.%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"external_urls":{"spotify":"https://open.spotify.com/album/6yEuIwTQpciH1qtj7mP5GK"},"href":"https://api.spotify.com/v1/albums/6yEuIwTQpciH1qtj7mP5GK","id":"6yEuIwTQpciH1qtj7mP5GK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e2dd4e821bcc3f70dc0c8ffd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e2dd4e821bcc3f70dc0c8ffd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e2dd4e821bcc3f70dc0c8ffd"}],"is_playable":true,"name":"Out Of Time (25th Anniversary Edition)","release_date":"1991-03-12","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:6yEuIwTQpciH1qtj7mP5GK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"disc_number":1,"duration_ms":268426,"explicit":false,"external_ids":{"isrc":"USC4R1605373"},"external_urls":{"spotify":"https://open.spotify.com/track/31AOj9sFz2gM0O3hMARRBx"},"href":"https://api.spotify.com/v1/tracks/31AOj9sFz2gM0O3hMARRBx","id":"31AOj9sFz2gM0O3hMARRBx","is_local":false,"is_playable":true,"name":"Losing My Religion","track_number":2,"type":"track","uri":"spotify:track:31AOj9sFz2gM0O3hMARRBx"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"external_urls":{"spotify":"https://open.spotify.com/album/3BO3qnsrk0GfBjLO1tWJwg"},"href":"https://api.spotify.com/v1/albums/3BO3qnsrk0GfBjLO1tWJwg","id":"3BO3qnsrk0GfBjLO1tWJwg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e9cc52668a37682faed561b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e9cc52668a37682faed561b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e9cc52668a37682faed561b"}],"is_playable":true,"name":"R.E.M. Live","release_date":"2007-10-15","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:3BO3qnsrk0GfBjLO1tWJwg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"disc_number":1,"duration_ms":293346,"explicit":false,"external_ids":{"isrc":"USWB10703649"},"external_urls":{"spotify":"https://open.spotify.com/track/0svaiEE8lMG6Q3PjMWdxLq"},"href":"https://api.spotify.com/v1/tracks/0svaiEE8lMG6Q3PjMWdxLq","id":"0svaiEE8lMG6Q3PjMWdxLq","is_local":false,"is_playable":true,"name":"Losing My Religion - Live At The Point Depot, Dublin, Ireland / February, 2005","track_number":17,"type":"track","uri":"spotify:track:0svaiEE8lMG6Q3PjMWdxLq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"external_urls":{"spotify":"https://open.spotify.com/album/2vPM8y0gBZTnEO48rGnCzs"},"href":"https://api.spotify.com/v1/albums/2vPM8y0gBZTnEO48rGnCzs","id":"2vPM8y0gBZTnEO48rGnCzs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d766cd2d2bb125f58ef22c22"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d766cd2d2bb125f58ef22c22"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d766cd2d2bb125f58ef22c22"}],"is_playable":true,"name":"Out Of Time","release_date":"1991-03-12","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:2vPM8y0gBZTnEO48rGnCzs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"disc_number":1,"duration_ms":268426,"explicit":false,"external_ids":{"isrc":"USC4R1605373"},"external_urls":{"spotify":"https://open.spotify.com/track/6bCPryuQjsts5cEybA3Nb5"},"href":"https://api.spotify.com/v1/tracks/6bCPryuQjsts5cEybA3Nb5","id":"6bCPryuQjsts5cEybA3Nb5","is_local":false,"is_playable":true,"name":"Losing My Religion","track_number":2,"type":"track","uri":"spotify:track:6bCPryuQjsts5cEybA3Nb5"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"external_urls":{"spotify":"https://open.spotify.com/album/3UvVHQ31PhSMtI2GIS91Lz"},"href":"https://api.spotify.com/v1/albums/3UvVHQ31PhSMtI2GIS91Lz","id":"3UvVHQ31PhSMtI2GIS91Lz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273519038856cb5329dc27f5916"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02519038856cb5329dc27f5916"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851519038856cb5329dc27f5916"}],"is_playable":true,"name":"In Time: The Best Of R.E.M. 1988-2003","release_date":"2003-08-27","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:3UvVHQ31PhSMtI2GIS91Lz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"disc_number":1,"duration_ms":269000,"explicit":false,"external_ids":{"isrc":"USWB19901521"},"external_urls":{"spotify":"https://open.spotify.com/track/6FBlNlVx0xrXPb9suicaMM"},"href":"https://api.spotify.com/v1/tracks/6FBlNlVx0xrXPb9suicaMM","id":"6FBlNlVx0xrXPb9suicaMM","is_local":false,"is_playable":true,"name":"Losing My Religion","track_number":6,"type":"track","uri":"spotify:track:6FBlNlVx0xrXPb9suicaMM"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"external_urls":{"spotify":"https://open.spotify.com/album/0L8Os8yMKhyq0iXhL8VfKR"},"href":"https://api.spotify.com/v1/albums/0L8Os8yMKhyq0iXhL8VfKR","id":"0L8Os8yMKhyq0iXhL8VfKR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734cd3ea41cc91a8647386a63a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024cd3ea41cc91a8647386a63a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514cd3ea41cc91a8647386a63a"}],"is_playable":true,"name":"Losing My Religion","release_date":"2020-10-02","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:0L8Os8yMKhyq0iXhL8VfKR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"disc_number":1,"duration_ms":267733,"explicit":false,"external_ids":{"isrc":"USWB19901521"},"external_urls":{"spotify":"https://open.spotify.com/track/4FLKdqTCxLm0G4s5Bouaad"},"href":"https://api.spotify.com/v1/tracks/4FLKdqTCxLm0G4s5Bouaad","id":"4FLKdqTCxLm0G4s5Bouaad","is_local":false,"is_playable":true,"name":"Losing My Religion","track_number":1,"type":"track","uri":"spotify:track:4FLKdqTCxLm0G4s5Bouaad"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1FNSpUmGkbHXJC6QDUskFS"},"href":"https://api.spotify.com/v1/albums/1FNSpUmGkbHXJC6QDUskFS","id":"1FNSpUmGkbHXJC6QDUskFS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730712cd27fc7b529c55f75132"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020712cd27fc7b529c55f75132"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510712cd27fc7b529c55f75132"}],"is_playable":true,"name":"Rock & Metal","release_date":"2023-09-21","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:1FNSpUmGkbHXJC6QDUskFS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"disc_number":1,"duration_ms":268520,"explicit":false,"external_ids":{"isrc":"USWB11102866"},"external_urls":{"spotify":"https://open.spotify.com/track/00zg3HTVUVQs6usWhqubeu"},"href":"https://api.spotify.com/v1/tracks/00zg3HTVUVQs6usWhqubeu","id":"00zg3HTVUVQs6usWhqubeu","is_local":false,"is_playable":true,"name":"Losing My Religion","track_number":22,"type":"track","uri":"spotify:track:00zg3HTVUVQs6usWhqubeu"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3J4P6hB6zJH8MIwnGqiU8J"},"href":"https://api.spotify.com/v1/albums/3J4P6hB6zJH8MIwnGqiU8J","id":"3J4P6hB6zJH8MIwnGqiU8J","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736ecf180e54cbc64cee96071b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026ecf180e54cbc64cee96071b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516ecf180e54cbc64cee96071b"}],"is_playable":true,"name":"Awesome Rock Mix","release_date":"2023-09-21","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:3J4P6hB6zJH8MIwnGqiU8J"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"disc_number":1,"duration_ms":269000,"explicit":false,"external_ids":{"isrc":"USWB19901521"},"external_urls":{"spotify":"https://open.spotify.com/track/0IsYLmIF7zShWKSJZBDY9l"},"href":"https://api.spotify.com/v1/tracks/0IsYLmIF7zShWKSJZBDY9l","id":"0IsYLmIF7zShWKSJZBDY9l","is_local":false,"is_playable":true,"name":"Losing My Religion","track_number":23,"type":"track","uri":"spotify:track:0IsYLmIF7zShWKSJZBDY9l"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"external_urls":{"spotify":"https://open.spotify.com/album/0lkKxxnV5EV8XaKUjjODqd"},"href":"https://api.spotify.com/v1/albums/0lkKxxnV5EV8XaKUjjODqd","id":"0lkKxxnV5EV8XaKUjjODqd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d19a802815af06c6942f9413"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d19a802815af06c6942f9413"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d19a802815af06c6942f9413"}],"is_playable":true,"name":"Part Lies, Part Heart, Part Truth, Part Garbage: 1982-2011","release_date":"2011-11-11","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:0lkKxxnV5EV8XaKUjjODqd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"disc_number":1,"duration_ms":268520,"explicit":false,"external_ids":{"isrc":"USWB11102866"},"external_urls":{"spotify":"https://open.spotify.com/track/6swVEAgrjZBZVVll237fJ7"},"href":"https://api.spotify.com/v1/tracks/6swVEAgrjZBZVVll237fJ7","id":"6swVEAgrjZBZVVll237fJ7","is_local":false,"is_playable":true,"name":"Losing My Religion","track_number":18,"type":"track","uri":"spotify:track:6swVEAgrjZBZVVll237fJ7"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4hNSO2rO6cxHODX2xX9eKB"},"href":"https://api.spotify.com/v1/albums/4hNSO2rO6cxHODX2xX9eKB","id":"4hNSO2rO6cxHODX2xX9eKB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e188b2804b2f2668c744ee19"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e188b2804b2f2668c744ee19"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e188b2804b2f2668c744ee19"}],"is_playable":true,"name":"Indie Gods","release_date":"2021-07-16","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:4hNSO2rO6cxHODX2xX9eKB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4KWTAlx2RvbpseOGMEmROg"},"href":"https://api.spotify.com/v1/artists/4KWTAlx2RvbpseOGMEmROg","id":"4KWTAlx2RvbpseOGMEmROg","name":"R.E.M.","type":"artist","uri":"spotify:artist:4KWTAlx2RvbpseOGMEmROg"}],"disc_number":1,"duration_ms":269000,"explicit":false,"external_ids":{"isrc":"USWB19901521"},"external_urls":{"spotify":"https://open.spotify.com/track/2toaRVrLELvimCfH8yMdjh"},"href":"https://api.spotify.com/v1/tracks/2toaRVrLELvimCfH8yMdjh","id":"2toaRVrLELvimCfH8yMdjh","is_local":false,"is_playable":true,"name":"Losing My Religion","track_number":7,"type":"track","uri":"spotify:track:2toaRVrLELvimCfH8yMdjh"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkxvc2luZyUyME15JTIwUmVsaWdpb24lMjIlMjBhcnRpc3QlM0ElMjJSLkUuTS4lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjksIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRLV1RBbHgyUnZicHNlT0dNRW1ST2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsImlkIjoiNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsIm5hbWUiOiJSLkUuTS4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ5RXVJd1RRcGNpSDFxdGo3bVA1R0sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82eUV1SXdUUXBjaUgxcXRqN21QNUdLIiwiaWQiOiI2eUV1SXdUUXBjaUgxcXRqN21QNUdLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28v", + "aW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2UyZGQ0ZTgyMWJjYzNmNzBkYzBjOGZmZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlMmRkNGU4MjFiY2MzZjcwZGMwYzhmZmQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWUyZGQ0ZTgyMWJjYzNmNzBkYzBjOGZmZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPdXQgT2YgVGltZSAoMjV0aCBBbm5pdmVyc2FyeSBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjE5OTEtMDMtMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2eUV1SXdUUXBjaUgxcXRqN21QNUdLIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwiaWQiOiI0S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwibmFtZSI6IlIuRS5NLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2ODQyNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQzRSMTYwNTM3MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMzFBT2o5c0Z6MmdNME8zaE1BUlJCeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzMxQU9qOXNGejJnTTBPM2hNQVJSQngiLCJpZCI6IjMxQU9qOXNGejJnTTBPM2hNQVJSQngiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTG9zaW5nIE15IFJlbGlnaW9uIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjMxQU9qOXNGejJnTTBPM2hNQVJSQngifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwiaWQiOiI0S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwibmFtZSI6IlIuRQ==", + "Lk0uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRLV1RBbHgyUnZicHNlT0dNRW1ST2cifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zQk8zcW5zcmswR2ZCakxPMXRXSndnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0JPM3Fuc3JrMEdmQmpMTzF0V0p3ZyIsImlkIjoiM0JPM3Fuc3JrMEdmQmpMTzF0V0p3ZyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1ZTljYzUyNjY4YTM3NjgyZmFlZDU2MWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWU5Y2M1MjY2OGEzNzY4MmZhZWQ1NjFiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1ZTljYzUyNjY4YTM3NjgyZmFlZDU2MWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUi5FLk0uIExpdmUiLCJyZWxlYXNlX2RhdGUiOiIyMDA3LTEwLTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0JPM3Fuc3JrMEdmQmpMTzF0V0p3ZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRLV1RBbHgyUnZicHNlT0dNRW1ST2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsImlkIjoiNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsIm5hbWUiOiJSLkUuTS4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyOTMzNDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1dCMTA3MDM2NDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBzdmFpRUU4bE1HNlEzUGpNV2R4THEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wc3ZhaUVFOGxNRzZRM1BqTVdkeExxIiwiaWQiOiIwc3ZhaUVFOGxNRzZRM1BqTVdkeExxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikxvc2luZyBNeSBSZWxpZ2lvbiAtIExpdmUgQXQgVGhlIFBvaW50IERlcG90LCBEdWJsaQ==", + "biwgSXJlbGFuZCAvIEZlYnJ1YXJ5LCAyMDA1IiwidHJhY2tfbnVtYmVyIjoxNywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowc3ZhaUVFOGxNRzZRM1BqTVdkeExxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRLV1RBbHgyUnZicHNlT0dNRW1ST2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsImlkIjoiNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsIm5hbWUiOiJSLkUuTS4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJ2UE04eTBnQlpUbkVPNDhyR25DenMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8ydlBNOHkwZ0JaVG5FTzQ4ckduQ3pzIiwiaWQiOiIydlBNOHkwZ0JaVG5FTzQ4ckduQ3pzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2Q3NjZjZDJkMmJiMTI1ZjU4ZWYyMmMyMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkNzY2Y2QyZDJiYjEyNWY1OGVmMjJjMjIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWQ3NjZjZDJkMmJiMTI1ZjU4ZWYyMmMyMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPdXQgT2YgVGltZSIsInJlbGVhc2VfZGF0ZSI6IjE5OTEtMDMtMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToydlBNOHkwZ0JaVG5FTzQ4ckduQ3pzIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwiaWQiOiI0S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwibmFtZSI6IlIuRS5NLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpbw==", + "bl9tcyI6MjY4NDI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNDNFIxNjA1MzczIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82YkNQcnl1UWpzdHM1Y0V5YkEzTmI1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmJDUHJ5dVFqc3RzNWNFeWJBM05iNSIsImlkIjoiNmJDUHJ5dVFqc3RzNWNFeWJBM05iNSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMb3NpbmcgTXkgUmVsaWdpb24iLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NmJDUHJ5dVFqc3RzNWNFeWJBM05iNSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRLV1RBbHgyUnZicHNlT0dNRW1ST2ciLCJpZCI6IjRLV1RBbHgyUnZicHNlT0dNRW1ST2ciLCJuYW1lIjoiUi5FLk0uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRLV1RBbHgyUnZicHNlT0dNRW1ST2cifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zVXZWSFEzMVBoU010STJHSVM5MUx6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM1V2VkhRMzFQaFNNdEkyR0lTOTFMeiIsImlkIjoiM1V2VkhRMzFQaFNNdEkyR0lTOTFMeiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1MTkwMzg4NTZjYjUzMjlkYzI3ZjU5MTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTE5MDM4ODU2Y2I1MzI5ZGMyN2Y1OTE2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1MTkwMzg4NTZjYjUzMjlkYzI3ZjU5MTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW4gVGltZTogVGhlIEJlc3QgT2YgUi5FLk0uIDE5ODgtMjAwMyIsInJlbGVhc2VfZGF0ZSI6IjIwMDMtMDgtMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozVXZWSFEzMQ==", + "UGhTTXRJMkdJUzkxTHoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRLV1RBbHgyUnZicHNlT0dNRW1ST2ciLCJpZCI6IjRLV1RBbHgyUnZicHNlT0dNRW1ST2ciLCJuYW1lIjoiUi5FLk0uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRLV1RBbHgyUnZicHNlT0dNRW1ST2cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY5MDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNXQjE5OTAxNTIxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82RkJsTmxWeDB4clhQYjlzdWljYU1NIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNkZCbE5sVngweHJYUGI5c3VpY2FNTSIsImlkIjoiNkZCbE5sVngweHJYUGI5c3VpY2FNTSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMb3NpbmcgTXkgUmVsaWdpb24iLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NkZCbE5sVngweHJYUGI5c3VpY2FNTSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwiaWQiOiI0S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwibmFtZSI6IlIuRS5NLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMEw4T3M4eU1LaHlxMGlYaEw4VmZLUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBMOE9zOHlNS2h5cTBpWGhMOFZmS1IiLCJpZCI6IjBMOE9zOHlNS2h5cTBpWGhMOFZmS1IiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNGNkM2VhNDFjYzkxYTg2NDczODZhNjNhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjRjZA==", + "M2VhNDFjYzkxYTg2NDczODZhNjNhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0Y2QzZWE0MWNjOTFhODY0NzM4NmE2M2EifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTG9zaW5nIE15IFJlbGlnaW9uIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0xMC0wMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MEw4T3M4eU1LaHlxMGlYaEw4VmZLUiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRLV1RBbHgyUnZicHNlT0dNRW1ST2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsImlkIjoiNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsIm5hbWUiOiJSLkUuTS4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjc3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1dCMTk5MDE1MjEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRGTEtkcVRDeExtMEc0czVCb3VhYWQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80RkxLZHFUQ3hMbTBHNHM1Qm91YWFkIiwiaWQiOiI0RkxLZHFUQ3hMbTBHNHM1Qm91YWFkIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikxvc2luZyBNeSBSZWxpZ2lvbiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0RkxLZHFUQ3hMbTBHNHM1Qm91YWFkIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFGTg==", + "U3BVbUdrYkhYSkM2UURVc2tGUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFGTlNwVW1Ha2JIWEpDNlFEVXNrRlMiLCJpZCI6IjFGTlNwVW1Ha2JIWEpDNlFEVXNrRlMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDcxMmNkMjdmYzdiNTI5YzU1Zjc1MTMyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA3MTJjZDI3ZmM3YjUyOWM1NWY3NTEzMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDcxMmNkMjdmYzdiNTI5YzU1Zjc1MTMyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvY2sgJiBNZXRhbCIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDktMjEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxRk5TcFVtR2tiSFhKQzZRRFVza0ZTIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwiaWQiOiI0S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIiwibmFtZSI6IlIuRS5NLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2ODUyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTV0IxMTEwMjg2NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMDB6ZzNIVFZVVlFzNnVzV2hxdWJldSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzAwemczSFRWVVZRczZ1c1docXViZXUiLCJpZCI6IjAwemczSFRWVVZRczZ1c1docXViZXUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTG9zaW5nIE15IFJlbGlnaW9uIiwidHJhY2tfbnVtYmVyIjoyMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowMHpnM0hUVlVWUXM2dXNXaHF1YmV1In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwcw==", + "Oi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM0o0UDZoQjZ6Skg4TUl3bkdxaVU4SiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNKNFA2aEI2ekpIOE1Jd25HcWlVOEoiLCJpZCI6IjNKNFA2aEI2ekpIOE1Jd25HcWlVOEoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmVjZjE4MGU1NGNiYzY0Y2VlOTYwNzFiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZlY2YxODBlNTRjYmM2NGNlZTk2MDcxYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmVjZjE4MGU1NGNiYzY0Y2VlOTYwNzFiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkF3ZXNvbWUgUm9jayBNaXgiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA5LTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0o0UDZoQjZ6Skg4TUl3bkdxaVU4SiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRLV1RBbHgyUnZicHNlT0dNRW1ST2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsImlkIjoiNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsIm5hbWUiOiJSLkUuTS4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjkwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1dCMTk5MDE1MjEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBJc1lMbUlGN3pTaFdLU0paQkRZOWwifSwiaHJlZiI6Imh0dHBzOi8vYQ==", + "cGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBJc1lMbUlGN3pTaFdLU0paQkRZOWwiLCJpZCI6IjBJc1lMbUlGN3pTaFdLU0paQkRZOWwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTG9zaW5nIE15IFJlbGlnaW9uIiwidHJhY2tfbnVtYmVyIjoyMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowSXNZTG1JRjd6U2hXS1NKWkJEWTlsIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRLV1RBbHgyUnZicHNlT0dNRW1ST2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsImlkIjoiNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsIm5hbWUiOiJSLkUuTS4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBsa0t4eG5WNUVWOFhhS1Vqak9EcWQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wbGtLeHhuVjVFVjhYYUtVampPRHFkIiwiaWQiOiIwbGtLeHhuVjVFVjhYYUtVampPRHFkIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2QxOWE4MDI4MTVhZjA2YzY5NDJmOTQxMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkMTlhODAyODE1YWYwNmM2OTQyZjk0MTMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWQxOWE4MDI4MTVhZjA2YzY5NDJmOTQxMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQYXJ0IExpZXMsIFBhcnQgSGVhcnQsIFBhcnQgVHJ1dGgsIFBhcnQgR2FyYmFnZTogMTk4Mi0yMDExIiwicmVsZWFzZV9kYXRlIjoiMjAxMS0xMS0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBsa0t4eG5WNUVWOFhhS1Vqak9EcWQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MQ==", + "L2FydGlzdHMvNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsImlkIjoiNEtXVEFseDJSdmJwc2VPR01FbVJPZyIsIm5hbWUiOiJSLkUuTS4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEtXVEFseDJSdmJwc2VPR01FbVJPZyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjg1MjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1dCMTExMDI4NjYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZzd1ZFQWdyalpCWlZWbGwyMzdmSjcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82c3dWRUFncmpaQlpWVmxsMjM3Zko3IiwiaWQiOiI2c3dWRUFncmpaQlpWVmxsMjM3Zko3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikxvc2luZyBNeSBSZWxpZ2lvbiIsInRyYWNrX251bWJlciI6MTgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NnN3VkVBZ3JqWkJaVlZsbDIzN2ZKNyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80aE5TTzJyTzZjeEhPRFgyeFg5ZUtCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNGhOU08yck82Y3hIT0RYMnhYOWVLQiIsImlkIjoiNGhOU08yck82Y3hIT0RYMnhYOWVLQiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlMTg4YjI4MDRiMmYyNjY4Yzc0NGVlMTkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTE4OGIyODA0YjJmMjY2OGM3NDRlZTE5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlMTg4YjI4MDRiMmYyNjY4Yzc0NGVlMTkifV0sImlzX3BsYXlhYg==", + "bGUiOnRydWUsIm5hbWUiOiJJbmRpZSBHb2RzIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wNy0xNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRoTlNPMnJPNmN4SE9EWDJ4WDllS0IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80S1dUQWx4MlJ2YnBzZU9HTUVtUk9nIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRLV1RBbHgyUnZicHNlT0dNRW1ST2ciLCJpZCI6IjRLV1RBbHgyUnZicHNlT0dNRW1ST2ciLCJuYW1lIjoiUi5FLk0uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRLV1RBbHgyUnZicHNlT0dNRW1ST2cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY5MDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNXQjE5OTAxNTIxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8ydG9hUlZyTEVMdmltQ2ZIOHlNZGpoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMnRvYVJWckxFTHZpbUNmSDh5TWRqaCIsImlkIjoiMnRvYVJWckxFTHZpbUNmSDh5TWRqaCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMb3NpbmcgTXkgUmVsaWdpb24iLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MnRvYVJWckxFTHZpbUNmSDh5TWRqaCJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Losing+My+Religion%22+artist%3A%22R.E.M.%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Smells%20Like%20Teen%20Spirit%22%20artist%3A%22Nirvana%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":6,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"external_urls":{"spotify":"https://open.spotify.com/album/2UJcKiJxNryhL050F5Z1Fk"},"href":"https://api.spotify.com/v1/albums/2UJcKiJxNryhL050F5Z1Fk","id":"2UJcKiJxNryhL050F5Z1Fk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fbc71c99f9c1296c56dd51b6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fbc71c99f9c1296c56dd51b6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fbc71c99f9c1296c56dd51b6"}],"is_playable":true,"name":"Nevermind (Remastered)","release_date":"1991-09-26","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2UJcKiJxNryhL050F5Z1Fk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"disc_number":1,"duration_ms":301920,"explicit":false,"external_ids":{"isrc":"USGF19942501"},"external_urls":{"spotify":"https://open.spotify.com/track/4CeeEOM32jQcH3eN9Q2dGj"},"href":"https://api.spotify.com/v1/tracks/4CeeEOM32jQcH3eN9Q2dGj","id":"4CeeEOM32jQcH3eN9Q2dGj","is_local":false,"is_playable":true,"name":"Smells Like Teen Spirit","track_number":1,"type":"track","uri":"spotify:track:4CeeEOM32jQcH3eN9Q2dGj"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"external_urls":{"spotify":"https://open.spotify.com/album/3FFGbUutKWN1c4f0CJR4Uh"},"href":"https://api.spotify.com/v1/albums/3FFGbUutKWN1c4f0CJR4Uh","id":"3FFGbUutKWN1c4f0CJR4Uh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb2d4c1ac0a601826986c785"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb2d4c1ac0a601826986c785"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb2d4c1ac0a601826986c785"}],"is_playable":true,"name":"Nevermind (Super Deluxe Edition)","release_date":"1991-09-26","release_date_precision":"day","total_tracks":70,"type":"album","uri":"spotify:album:3FFGbUutKWN1c4f0CJR4Uh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"disc_number":1,"duration_ms":301920,"explicit":false,"external_ids":{"isrc":"USGF19942501"},"external_urls":{"spotify":"https://open.spotify.com/track/2Wtm3yc0paBifvBSjOhO3b"},"href":"https://api.spotify.com/v1/tracks/2Wtm3yc0paBifvBSjOhO3b","id":"2Wtm3yc0paBifvBSjOhO3b","is_local":false,"is_playable":true,"name":"Smells Like Teen Spirit","track_number":1,"type":"track","uri":"spotify:track:2Wtm3yc0paBifvBSjOhO3b"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"external_urls":{"spotify":"https://open.spotify.com/album/5zBPRXCAc801vyHWoRurNZ"},"href":"https://api.spotify.com/v1/albums/5zBPRXCAc801vyHWoRurNZ","id":"5zBPRXCAc801vyHWoRurNZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27356072fea6785a3ad2d24237c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0256072fea6785a3ad2d24237c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485156072fea6785a3ad2d24237c"}],"is_playable":true,"name":"Nirvana","release_date":"2002-10-29","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:5zBPRXCAc801vyHWoRurNZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"disc_number":1,"duration_ms":301453,"explicit":false,"external_ids":{"isrc":"USGF19942501"},"external_urls":{"spotify":"https://open.spotify.com/track/6y1etHPLRsgA467gLBOgBm"},"href":"https://api.spotify.com/v1/tracks/6y1etHPLRsgA467gLBOgBm","id":"6y1etHPLRsgA467gLBOgBm","is_local":false,"is_playable":true,"name":"Smells Like Teen Spirit","track_number":5,"type":"track","uri":"spotify:track:6y1etHPLRsgA467gLBOgBm"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"external_urls":{"spotify":"https://open.spotify.com/album/4bvBe5ZmDyzjr2IXhAC89x"},"href":"https://api.spotify.com/v1/albums/4bvBe5ZmDyzjr2IXhAC89x","id":"4bvBe5ZmDyzjr2IXhAC89x","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734a7781dd4f494d71fa0abf51"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024a7781dd4f494d71fa0abf51"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514a7781dd4f494d71fa0abf51"}],"is_playable":true,"name":"Smells Like Teen Spirit / In Bloom / On A Plain / Lithium / Breed","release_date":"2021-11-10","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:4bvBe5ZmDyzjr2IXhAC89x"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"disc_number":1,"duration_ms":300893,"explicit":false,"external_ids":{"isrc":"USGF19942501"},"external_urls":{"spotify":"https://open.spotify.com/track/0vYfKwaIDwY0IcKbMcqcY5"},"href":"https://api.spotify.com/v1/tracks/0vYfKwaIDwY0IcKbMcqcY5","id":"0vYfKwaIDwY0IcKbMcqcY5","is_local":false,"is_playable":true,"name":"Smells Like Teen Spirit - Remastered 2021","track_number":1,"type":"track","uri":"spotify:track:0vYfKwaIDwY0IcKbMcqcY5"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"external_urls":{"spotify":"https://open.spotify.com/album/5eA0qtE7Yu29XiMlwoby2G"},"href":"https://api.spotify.com/v1/albums/5eA0qtE7Yu29XiMlwoby2G","id":"5eA0qtE7Yu29XiMlwoby2G","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739aa37e5baca62ca6cc98d056"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029aa37e5baca62ca6cc98d056"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519aa37e5baca62ca6cc98d056"}],"is_playable":true,"name":"Nevermind (30th Anniversary Super Deluxe)","release_date":"2021-11-12","release_date_precision":"day","total_tracks":75,"type":"album","uri":"spotify:album:5eA0qtE7Yu29XiMlwoby2G"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"disc_number":1,"duration_ms":300893,"explicit":false,"external_ids":{"isrc":"USGF19942501"},"external_urls":{"spotify":"https://open.spotify.com/track/4TMhakloPMPS84lNHNTSa3"},"href":"https://api.spotify.com/v1/tracks/4TMhakloPMPS84lNHNTSa3","id":"4TMhakloPMPS84lNHNTSa3","is_local":false,"is_playable":true,"name":"Smells Like Teen Spirit - Remastered 2021","track_number":1,"type":"track","uri":"spotify:track:4TMhakloPMPS84lNHNTSa3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"external_urls":{"spotify":"https://open.spotify.com/album/01Z1nufhjxJVXVDuMRmNEM"},"href":"https://api.spotify.com/v1/albums/01Z1nufhjxJVXVDuMRmNEM","id":"01Z1nufhjxJVXVDuMRmNEM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27340c5b0a60c587bd0cee5ee0c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0240c5b0a60c587bd0cee5ee0c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485140c5b0a60c587bd0cee5ee0c"}],"is_playable":true,"name":"Live at Reading","release_date":"2009-01-01","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:01Z1nufhjxJVXVDuMRmNEM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6olE6TJLqED3rqDCT0FyPh"},"href":"https://api.spotify.com/v1/artists/6olE6TJLqED3rqDCT0FyPh","id":"6olE6TJLqED3rqDCT0FyPh","name":"Nirvana","type":"artist","uri":"spotify:artist:6olE6TJLqED3rqDCT0FyPh"}],"disc_number":1,"duration_ms":285186,"explicit":false,"external_ids":{"isrc":"USUM70995906"},"external_urls":{"spotify":"https://open.spotify.com/track/6gVH9jHl5Xpxxl4gVVrEkE"},"href":"https://api.spotify.com/v1/tracks/6gVH9jHl5Xpxxl4gVVrEkE","id":"6gVH9jHl5Xpxxl4gVVrEkE","is_local":false,"is_playable":true,"name":"Smells Like Teen Spirit - 1992/Live at Reading","track_number":13,"type":"track","uri":"spotify:track:6gVH9jHl5Xpxxl4gVVrEkE"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNtZWxscyUyMExpa2UlMjBUZWVuJTIwU3Bpcml0JTIyJTIwYXJ0aXN0JTNBJTIyTmlydmFuYSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NiwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82b2xFNlRKTHFFRDNycURDVDBGeVBoIiwiaWQiOiI2b2xFNlRKTHFFRDNycURDVDBGeVBoIiwibmFtZSI6Ik5pcnZhbmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJVSmNLaUp4TnJ5aEwwNTBGNVoxRmsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yVUpjS2lKeE5yeWhMMDUwRjVaMUZrIiwiaWQiOiIyVUpjS2lKeE5yeWhMMDUwRjVaMUZrIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9p", + "LnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ZiYzcxYzk5ZjljMTI5NmM1NmRkNTFiNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmYmM3MWM5OWY5YzEyOTZjNTZkZDUxYjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWZiYzcxYzk5ZjljMTI5NmM1NmRkNTFiNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOZXZlcm1pbmQgKFJlbWFzdGVyZWQpIiwicmVsZWFzZV9kYXRlIjoiMTk5MS0wOS0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJVSmNLaUp4TnJ5aEwwNTBGNVoxRmsifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82b2xFNlRKTHFFRDNycURDVDBGeVBoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJpZCI6IjZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJuYW1lIjoiTmlydmFuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2xFNlRKTHFFRDNycURDVDBGeVBoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwMTkyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTR0YxOTk0MjUwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNENlZUVPTTMyalFjSDNlTjlRMmRHaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRDZWVFT00zMmpRY0gzZU45UTJkR2oiLCJpZCI6IjRDZWVFT00zMmpRY0gzZU45UTJkR2oiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU21lbGxzIExpa2UgVGVlbiBTcGlyaXQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NENlZUVPTTMyalFjSDNlTjlRMmRHaiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82b2xFNlRKTHFFRDNycURDVDBGeVBoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJpZCI6IjZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJuYW1lIg==", + "OiJOaXJ2YW5hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZvbEU2VEpMcUVEM3JxRENUMEZ5UGgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zRkZHYlV1dEtXTjFjNGYwQ0pSNFVoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0ZGR2JVdXRLV04xYzRmMENKUjRVaCIsImlkIjoiM0ZGR2JVdXRLV04xYzRmMENKUjRVaCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmYjJkNGMxYWMwYTYwMTgyNjk4NmM3ODUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZmIyZDRjMWFjMGE2MDE4MjY5ODZjNzg1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmYjJkNGMxYWMwYTYwMTgyNjk4NmM3ODUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmV2ZXJtaW5kIChTdXBlciBEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIxOTkxLTA5LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NzAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0ZGR2JVdXRLV04xYzRmMENKUjRVaCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZvbEU2VEpMcUVEM3JxRENUMEZ5UGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCIsImlkIjoiNm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCIsIm5hbWUiOiJOaXJ2YW5hIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZvbEU2VEpMcUVEM3JxRENUMEZ5UGgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzAxOTIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNHRjE5OTQyNTAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yV3RtM3ljMHBhQmlmdkJTak9oTzNiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMld0bTN5YzBwYUJpZnZCU2pPaE8zYiIsImlkIjoiMld0bTN5YzBwYUJpZnZCU2pPaE8zYiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbWVsbHMgTGlrZSBUZWVuIFNwaXJpdA==", + "IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJXdG0zeWMwcGFCaWZ2QlNqT2hPM2IifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82b2xFNlRKTHFFRDNycURDVDBGeVBoIiwiaWQiOiI2b2xFNlRKTHFFRDNycURDVDBGeVBoIiwibmFtZSI6Ik5pcnZhbmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzV6QlBSWENBYzgwMXZ5SFdvUnVyTloifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81ekJQUlhDQWM4MDF2eUhXb1J1ck5aIiwiaWQiOiI1ekJQUlhDQWM4MDF2eUhXb1J1ck5aIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzU2MDcyZmVhNjc4NWEzYWQyZDI0MjM3YyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1NjA3MmZlYTY3ODVhM2FkMmQyNDIzN2MifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTU2MDcyZmVhNjc4NWEzYWQyZDI0MjM3YyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOaXJ2YW5hIiwicmVsZWFzZV9kYXRlIjoiMjAwMi0xMC0yOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjV6QlBSWENBYzgwMXZ5SFdvUnVyTloifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82b2xFNlRKTHFFRDNycURDVDBGeVBoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJpZCI6IjZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJuYW1lIjoiTmlydmFuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2xFNlRKTHFFRDNycURDVDBGeVBoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwMTQ1MywiZXhwbGljaXQiOg==", + "ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNHRjE5OTQyNTAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82eTFldEhQTFJzZ0E0NjdnTEJPZ0JtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNnkxZXRIUExSc2dBNDY3Z0xCT2dCbSIsImlkIjoiNnkxZXRIUExSc2dBNDY3Z0xCT2dCbSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbWVsbHMgTGlrZSBUZWVuIFNwaXJpdCIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2eTFldEhQTFJzZ0E0NjdnTEJPZ0JtIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82b2xFNlRKTHFFRDNycURDVDBGeVBoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJpZCI6IjZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJuYW1lIjoiTmlydmFuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2xFNlRKTHFFRDNycURDVDBGeVBoIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNGJ2QmU1Wm1EeXpqcjJJWGhBQzg5eCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRidkJlNVptRHl6anIySVhoQUM4OXgiLCJpZCI6IjRidkJlNVptRHl6anIySVhoQUM4OXgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNGE3NzgxZGQ0ZjQ5NGQ3MWZhMGFiZjUxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjRhNzc4MWRkNGY0OTRkNzFmYTBhYmY1MSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNGE3NzgxZGQ0ZjQ5NGQ3MWZhMGFiZjUxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNtZWxscyBMaWtlIFRlZW4gU3Bpcml0IC8gSW4gQmxvb20gLyBPbiBBIFBsYWluIC8gTGl0aGl1bSAvIEJyZWVkIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0xMS0xMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NGJ2Qg==", + "ZTVabUR5empyMklYaEFDODl4In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82b2xFNlRKTHFFRDNycURDVDBGeVBoIiwiaWQiOiI2b2xFNlRKTHFFRDNycURDVDBGeVBoIiwibmFtZSI6Ik5pcnZhbmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDA4OTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0dGMTk5NDI1MDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzB2WWZLd2FJRHdZMEljS2JNY3FjWTUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wdllmS3dhSUR3WTBJY0tiTWNxY1k1IiwiaWQiOiIwdllmS3dhSUR3WTBJY0tiTWNxY1k1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNtZWxscyBMaWtlIFRlZW4gU3Bpcml0IC0gUmVtYXN0ZXJlZCAyMDIxIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjB2WWZLd2FJRHdZMEljS2JNY3FjWTUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82b2xFNlRKTHFFRDNycURDVDBGeVBoIiwiaWQiOiI2b2xFNlRKTHFFRDNycURDVDBGeVBoIiwibmFtZSI6Ik5pcnZhbmEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm9sRTZUSkxxRUQzcnFEQ1QwRnlQaCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVlQTBxdEU3WXUyOVhpTWx3b2J5MkcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81ZUEwcXRFN1l1MjlYaU1sd29ieTJHIiwiaWQiOiI1ZUEwcXRFN1l1MjlYaU1sd29ieTJHIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzlhYTM3ZTViYWNhNjJjYTZjYzk4ZDA1NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLg==", + "Y28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjlhYTM3ZTViYWNhNjJjYTZjYzk4ZDA1NiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWFhMzdlNWJhY2E2MmNhNmNjOThkMDU2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5ldmVybWluZCAoMzB0aCBBbm5pdmVyc2FyeSBTdXBlciBEZWx1eGUpIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0xMS0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjc1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVlQTBxdEU3WXUyOVhpTWx3b2J5MkcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82b2xFNlRKTHFFRDNycURDVDBGeVBoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJpZCI6IjZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJuYW1lIjoiTmlydmFuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2xFNlRKTHFFRDNycURDVDBGeVBoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwMDg5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTR0YxOTk0MjUwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFRNaGFrbG9QTVBTODRsTkhOVFNhMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRUTWhha2xvUE1QUzg0bE5ITlRTYTMiLCJpZCI6IjRUTWhha2xvUE1QUzg0bE5ITlRTYTMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU21lbGxzIExpa2UgVGVlbiBTcGlyaXQgLSBSZW1hc3RlcmVkIDIwMjEiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFRNaGFrbG9QTVBTODRsTkhOVFNhMyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82b2xFNlRKTHFFRDNycURDVDBGeVBoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJpZCI6IjZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJuYW1lIjoiTmlydmFuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2xFNlRKTHFFRDNycURDVDBGeVBoIn1dLA==", + "ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wMVoxbnVmaGp4SlZYVkR1TVJtTkVNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDFaMW51ZmhqeEpWWFZEdU1SbU5FTSIsImlkIjoiMDFaMW51ZmhqeEpWWFZEdU1SbU5FTSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0MGM1YjBhNjBjNTg3YmQwY2VlNWVlMGMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDBjNWIwYTYwYzU4N2JkMGNlZTVlZTBjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0MGM1YjBhNjBjNTg3YmQwY2VlNWVlMGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGl2ZSBhdCBSZWFkaW5nIiwicmVsZWFzZV9kYXRlIjoiMjAwOS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjAxWjFudWZoanhKVlhWRHVNUm1ORU0ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82b2xFNlRKTHFFRDNycURDVDBGeVBoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJpZCI6IjZvbEU2VEpMcUVEM3JxRENUMEZ5UGgiLCJuYW1lIjoiTmlydmFuYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2xFNlRKTHFFRDNycURDVDBGeVBoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI4NTE4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MDk5NTkwNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNmdWSDlqSGw1WHB4eGw0Z1ZWckVrRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZnVkg5akhsNVhweHhsNGdWVnJFa0UiLCJpZCI6IjZnVkg5akhsNVhweHhsNGdWVnJFa0UiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU21lbGxzIExpa2UgVGVlbiBTcGlyaXQgLSAxOTkyL0xpdmUgYXQgUmVhZGluZyIsInRyYWNrX251bWJlciI6MTMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NmdWSDlqSGw1WHB4eA==", + "bDRnVlZyRWtFIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Smells+Like+Teen+Spirit%22+artist%3A%22Nirvana%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Wonderwall%22%20artist%3A%22Oasis%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/2u30gztZTylY4RG7IvfXs8"},"href":"https://api.spotify.com/v1/albums/2u30gztZTylY4RG7IvfXs8","id":"2u30gztZTylY4RG7IvfXs8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732f2eeee9b405f4d00428d84c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022f2eeee9b405f4d00428d84c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512f2eeee9b405f4d00428d84c"}],"is_playable":true,"name":"(What's The Story) Morning Glory?","release_date":"1995-10-02","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:2u30gztZTylY4RG7IvfXs8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":1,"duration_ms":258906,"explicit":false,"external_ids":{"isrc":"GBAAW9500189"},"external_urls":{"spotify":"https://open.spotify.com/track/1qPbGZqppFwLwcBC1JQ6Vr"},"href":"https://api.spotify.com/v1/tracks/1qPbGZqppFwLwcBC1JQ6Vr","id":"1qPbGZqppFwLwcBC1JQ6Vr","is_local":false,"is_playable":true,"name":"Wonderwall","track_number":3,"type":"track","uri":"spotify:track:1qPbGZqppFwLwcBC1JQ6Vr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/6tOe4eAF8xNhEkl9WyvsE4"},"href":"https://api.spotify.com/v1/albums/6tOe4eAF8xNhEkl9WyvsE4","id":"6tOe4eAF8xNhEkl9WyvsE4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737a4c8c59851c88f6794c3cbf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027a4c8c59851c88f6794c3cbf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517a4c8c59851c88f6794c3cbf"}],"is_playable":true,"name":"(What's The Story) Morning Glory? (Deluxe Remastered Edition)","release_date":"1995","release_date_precision":"year","total_tracks":40,"type":"album","uri":"spotify:album:6tOe4eAF8xNhEkl9WyvsE4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":1,"duration_ms":258773,"explicit":false,"external_ids":{"isrc":"GBQCP1400109"},"external_urls":{"spotify":"https://open.spotify.com/track/7ygpwy2qP3NbrxVkHvUhXY"},"href":"https://api.spotify.com/v1/tracks/7ygpwy2qP3NbrxVkHvUhXY","id":"7ygpwy2qP3NbrxVkHvUhXY","is_local":false,"is_playable":true,"name":"Wonderwall - Remastered","track_number":3,"type":"track","uri":"spotify:track:7ygpwy2qP3NbrxVkHvUhXY"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/12HZ8XQPpDmf6G8Axa85Gj"},"href":"https://api.spotify.com/v1/albums/12HZ8XQPpDmf6G8Axa85Gj","id":"12HZ8XQPpDmf6G8Axa85Gj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737224799a3dd95a63d102443f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027224799a3dd95a63d102443f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517224799a3dd95a63d102443f"}],"is_playable":true,"name":"Wonderwall (Live from Dublin, 16 August '25)","release_date":"2025-09-04","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:12HZ8XQPpDmf6G8Axa85Gj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":1,"duration_ms":261124,"explicit":true,"external_ids":{"isrc":"GBQCP2500142"},"external_urls":{"spotify":"https://open.spotify.com/track/7Cc2oIT12kip9Bn1vcI232"},"href":"https://api.spotify.com/v1/tracks/7Cc2oIT12kip9Bn1vcI232","id":"7Cc2oIT12kip9Bn1vcI232","is_local":false,"is_playable":true,"name":"Wonderwall (Live from Dublin, 16 August '25)","track_number":1,"type":"track","uri":"spotify:track:7Cc2oIT12kip9Bn1vcI232"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/5TC9oSol9ZQwXQk8XcsD7i"},"href":"https://api.spotify.com/v1/albums/5TC9oSol9ZQwXQk8XcsD7i","id":"5TC9oSol9ZQwXQk8XcsD7i","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ca147e0b4e7823a9d2416562"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ca147e0b4e7823a9d2416562"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ca147e0b4e7823a9d2416562"}],"is_playable":true,"name":"Knebworth 1996 (Live)","release_date":"2021-11-19","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:5TC9oSol9ZQwXQk8XcsD7i"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":2,"duration_ms":244506,"explicit":true,"external_ids":{"isrc":"GBQCP2100014"},"external_urls":{"spotify":"https://open.spotify.com/track/59duRmjmHPQPDQ7XESu3Vp"},"href":"https://api.spotify.com/v1/tracks/59duRmjmHPQPDQ7XESu3Vp","id":"59duRmjmHPQPDQ7XESu3Vp","is_local":false,"is_playable":true,"name":"Wonderwall (Live at Knebworth, 10 August '96)","track_number":3,"type":"track","uri":"spotify:track:59duRmjmHPQPDQ7XESu3Vp"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/29HCrimg9FM84Xkm1dxp3B"},"href":"https://api.spotify.com/v1/albums/29HCrimg9FM84Xkm1dxp3B","id":"29HCrimg9FM84Xkm1dxp3B","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b04f3f513e4ef6ae573cf0c7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b04f3f513e4ef6ae573cf0c7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b04f3f513e4ef6ae573cf0c7"}],"is_playable":true,"name":"Familiar To Millions (Live)","release_date":"2000-11-13","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:29HCrimg9FM84Xkm1dxp3B"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":1,"duration_ms":286466,"explicit":false,"external_ids":{"isrc":"GBBQY0002025"},"external_urls":{"spotify":"https://open.spotify.com/track/2nBnxAHFIs24IkYihmKlt8"},"href":"https://api.spotify.com/v1/tracks/2nBnxAHFIs24IkYihmKlt8","id":"2nBnxAHFIs24IkYihmKlt8","is_local":false,"is_playable":true,"name":"Wonderwall - Live at Wembley Stadium, July 2000","track_number":8,"type":"track","uri":"spotify:track:2nBnxAHFIs24IkYihmKlt8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4EYiaCimOb1Li1bnb7ppi6"},"href":"https://api.spotify.com/v1/albums/4EYiaCimOb1Li1bnb7ppi6","id":"4EYiaCimOb1Li1bnb7ppi6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735d7f7b30d1ecf63d9dc7073c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025d7f7b30d1ecf63d9dc7073c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515d7f7b30d1ecf63d9dc7073c"}],"is_playable":true,"name":"(What's The Story) Morning Glory? (30th Anniversary Deluxe Edition)","release_date":"2025-10-03","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:4EYiaCimOb1Li1bnb7ppi6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":2,"duration_ms":251024,"explicit":false,"external_ids":{"isrc":"GBQCP2500095"},"external_urls":{"spotify":"https://open.spotify.com/track/2kyngSsWvKzqIWRsOoL9qA"},"href":"https://api.spotify.com/v1/tracks/2kyngSsWvKzqIWRsOoL9qA","id":"2kyngSsWvKzqIWRsOoL9qA","is_local":false,"is_playable":true,"name":"Wonderwall (Unplugged)","track_number":3,"type":"track","uri":"spotify:track:2kyngSsWvKzqIWRsOoL9qA"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/4EYiaCimOb1Li1bnb7ppi6"},"href":"https://api.spotify.com/v1/albums/4EYiaCimOb1Li1bnb7ppi6","id":"4EYiaCimOb1Li1bnb7ppi6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735d7f7b30d1ecf63d9dc7073c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025d7f7b30d1ecf63d9dc7073c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515d7f7b30d1ecf63d9dc7073c"}],"is_playable":true,"name":"(What's The Story) Morning Glory? (30th Anniversary Deluxe Edition)","release_date":"2025-10-03","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:4EYiaCimOb1Li1bnb7ppi6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":1,"duration_ms":258773,"explicit":false,"external_ids":{"isrc":"GBQCP1400109"},"external_urls":{"spotify":"https://open.spotify.com/track/4aZYnnp6L8xDXpAQsc2iq2"},"href":"https://api.spotify.com/v1/tracks/4aZYnnp6L8xDXpAQsc2iq2","id":"4aZYnnp6L8xDXpAQsc2iq2","is_local":false,"is_playable":true,"name":"Wonderwall - Remastered","track_number":3,"type":"track","uri":"spotify:track:4aZYnnp6L8xDXpAQsc2iq2"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/1zaPsC8dBFfesoY62MwMFa"},"href":"https://api.spotify.com/v1/albums/1zaPsC8dBFfesoY62MwMFa","id":"1zaPsC8dBFfesoY62MwMFa","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273070c48e39ebec05f27a7211f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02070c48e39ebec05f27a7211f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851070c48e39ebec05f27a7211f"}],"is_playable":true,"name":"Stop The Clocks","release_date":"2006-11-20","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:1zaPsC8dBFfesoY62MwMFa"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":1,"duration_ms":258613,"explicit":false,"external_ids":{"isrc":"GBAAW9500189"},"external_urls":{"spotify":"https://open.spotify.com/track/0dD4myangln1RRBzwWUcIQ"},"href":"https://api.spotify.com/v1/tracks/0dD4myangln1RRBzwWUcIQ","id":"0dD4myangln1RRBzwWUcIQ","is_local":false,"is_playable":true,"name":"Wonderwall","track_number":6,"type":"track","uri":"spotify:track:0dD4myangln1RRBzwWUcIQ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ezI4EtsobNEhV0WSEsCGn"},"href":"https://api.spotify.com/v1/albums/3ezI4EtsobNEhV0WSEsCGn","id":"3ezI4EtsobNEhV0WSEsCGn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a4e5dcbb5ddcf130cbedd101"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a4e5dcbb5ddcf130cbedd101"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a4e5dcbb5ddcf130cbedd101"}],"is_playable":true,"name":"Wonderwall","release_date":"1995-10-30","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:3ezI4EtsobNEhV0WSEsCGn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DaxqgrOhkeH0fpeiQq2f4"},"href":"https://api.spotify.com/v1/artists/2DaxqgrOhkeH0fpeiQq2f4","id":"2DaxqgrOhkeH0fpeiQq2f4","name":"Oasis","type":"artist","uri":"spotify:artist:2DaxqgrOhkeH0fpeiQq2f4"}],"disc_number":1,"duration_ms":258906,"explicit":false,"external_ids":{"isrc":"GBAAW9500189"},"external_urls":{"spotify":"https://open.spotify.com/track/7dPd3dx4ipBe10xKuhj9eY"},"href":"https://api.spotify.com/v1/tracks/7dPd3dx4ipBe10xKuhj9eY","id":"7dPd3dx4ipBe10xKuhj9eY","is_local":false,"is_playable":true,"name":"Wonderwall","track_number":1,"type":"track","uri":"spotify:track:7dPd3dx4ipBe10xKuhj9eY"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldvbmRlcndhbGwlMjIlMjBhcnRpc3QlM0ElMjJPYXNpcyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwiaWQiOiIyRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwibmFtZSI6Ik9hc2lzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8ydTMwZ3p0WlR5bFk0Ukc3SXZmWHM4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMnUzMGd6dFpUeWxZNFJHN0l2ZlhzOCIsImlkIjoiMnUzMGd6dFpUeWxZNFJHN0l2ZlhzOCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZk", + "MDAwMGIyNzMyZjJlZWVlOWI0MDVmNGQwMDQyOGQ4NGMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmYyZWVlZTliNDA1ZjRkMDA0MjhkODRjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyZjJlZWVlOWI0MDVmNGQwMDQyOGQ4NGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiKFdoYXQncyBUaGUgU3RvcnkpIE1vcm5pbmcgR2xvcnk/IiwicmVsZWFzZV9kYXRlIjoiMTk5NS0xMC0wMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJ1MzBnenRaVHlsWTRSRzdJdmZYczgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJpZCI6IjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJuYW1lIjoiT2FzaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTg5MDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFBVzk1MDAxODkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFxUGJHWnFwcEZ3THdjQkMxSlE2VnIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xcVBiR1pxcHBGd0x3Y0JDMUpRNlZyIiwiaWQiOiIxcVBiR1pxcHBGd0x3Y0JDMUpRNlZyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldvbmRlcndhbGwiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXFQYkdacXBwRndMd2NCQzFKUTZWciJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJpZCI6IjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJuYW1lIjoiT2FzaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoicw==", + "cG90aWZ5OmFydGlzdDoyRGF4cWdyT2hrZUgwZnBlaVFxMmY0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNnRPZTRlQUY4eE5oRWtsOVd5dnNFNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZ0T2U0ZUFGOHhOaEVrbDlXeXZzRTQiLCJpZCI6IjZ0T2U0ZUFGOHhOaEVrbDlXeXZzRTQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2E0YzhjNTk4NTFjODhmNjc5NGMzY2JmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdhNGM4YzU5ODUxYzg4ZjY3OTRjM2NiZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2E0YzhjNTk4NTFjODhmNjc5NGMzY2JmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IihXaGF0J3MgVGhlIFN0b3J5KSBNb3JuaW5nIEdsb3J5PyAoRGVsdXhlIFJlbWFzdGVyZWQgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIxOTk1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjQwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZ0T2U0ZUFGOHhOaEVrbDlXeXZzRTQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJpZCI6IjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJuYW1lIjoiT2FzaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTg3NzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlFDUDE0MDAxMDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzd5Z3B3eTJxUDNOYnJ4VmtIdlVoWFkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83eWdwd3kycVAzTmJyeFZrSHZVaFhZIiwiaWQiOiI3eWdwd3kycVAzTmJyeFZrSHZVaFhZIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldvbmRlcndhbGwgLSBSZW1hc3RlcmVkIiwidHJhY2tfbnVtYg==", + "ZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N3lncHd5MnFQM05icnhWa0h2VWhYWSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwiaWQiOiIyRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwibmFtZSI6Ik9hc2lzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xMkhaOFhRUHBEbWY2RzhBeGE4NUdqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTJIWjhYUVBwRG1mNkc4QXhhODVHaiIsImlkIjoiMTJIWjhYUVBwRG1mNkc4QXhhODVHaiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3MjI0Nzk5YTNkZDk1YTYzZDEwMjQ0M2YifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzIyNDc5OWEzZGQ5NWE2M2QxMDI0NDNmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3MjI0Nzk5YTNkZDk1YTYzZDEwMjQ0M2YifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV29uZGVyd2FsbCAoTGl2ZSBmcm9tIER1YmxpbiwgMTYgQXVndXN0ICcyNSkiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA5LTA0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxMkhaOFhRUHBEbWY2RzhBeGE4NUdqIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwiaWQiOiIyRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwibmFtZSI6Ik9hc2lzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjYxMQ==", + "MjQsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCUUNQMjUwMDE0MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN0NjMm9JVDEya2lwOUJuMXZjSTIzMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdDYzJvSVQxMmtpcDlCbjF2Y0kyMzIiLCJpZCI6IjdDYzJvSVQxMmtpcDlCbjF2Y0kyMzIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV29uZGVyd2FsbCAoTGl2ZSBmcm9tIER1YmxpbiwgMTYgQXVndXN0ICcyNSkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N0NjMm9JVDEya2lwOUJuMXZjSTIzMiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJpZCI6IjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJuYW1lIjoiT2FzaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVUQzlvU29sOVpRd1hRazhYY3NEN2kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81VEM5b1NvbDlaUXdYUWs4WGNzRDdpIiwiaWQiOiI1VEM5b1NvbDlaUXdYUWs4WGNzRDdpIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2NhMTQ3ZTBiNGU3ODIzYTlkMjQxNjU2MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjYTE0N2UwYjRlNzgyM2E5ZDI0MTY1NjIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWNhMTQ3ZTBiNGU3ODIzYTlkMjQxNjU2MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJLbmVid29ydGggMTk5NiAoTGl2ZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTExLTE5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVRDOW9Tb2w5WlF3WFFrOA==", + "WGNzRDdpIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwiaWQiOiIyRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwibmFtZSI6Ik9hc2lzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MjQ0NTA2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlFDUDIxMDAwMTQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzU5ZHVSbWptSFBRUERRN1hFU3UzVnAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81OWR1Um1qbUhQUVBEUTdYRVN1M1ZwIiwiaWQiOiI1OWR1Um1qbUhQUVBEUTdYRVN1M1ZwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldvbmRlcndhbGwgKExpdmUgYXQgS25lYndvcnRoLCAxMCBBdWd1c3QgJzk2KSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1OWR1Um1qbUhQUVBEUTdYRVN1M1ZwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsImlkIjoiMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsIm5hbWUiOiJPYXNpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRGF4cWdyT2hrZUgwZnBlaVFxMmY0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMjlIQ3JpbWc5Rk04NFhrbTFkeHAzQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzI5SENyaW1nOUZNODRYa20xZHhwM0IiLCJpZCI6IjI5SENyaW1nOUZNODRYa20xZHhwM0IiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjA0ZjNmNTEzZTRlZjZhZTU3M2NmMGM3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2Nw==", + "NjE2ZDAwMDAxZTAyYjA0ZjNmNTEzZTRlZjZhZTU3M2NmMGM3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiMDRmM2Y1MTNlNGVmNmFlNTczY2YwYzcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmFtaWxpYXIgVG8gTWlsbGlvbnMgKExpdmUpIiwicmVsZWFzZV9kYXRlIjoiMjAwMC0xMS0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjI5SENyaW1nOUZNODRYa20xZHhwM0IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJpZCI6IjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJuYW1lIjoiT2FzaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyODY0NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkJRWTAwMDIwMjUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJuQm54QUhGSXMyNElrWWlobUtsdDgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8ybkJueEFIRklzMjRJa1lpaG1LbHQ4IiwiaWQiOiIybkJueEFIRklzMjRJa1lpaG1LbHQ4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldvbmRlcndhbGwgLSBMaXZlIGF0IFdlbWJsZXkgU3RhZGl1bSwgSnVseSAyMDAwIiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJuQm54QUhGSXMyNElrWWlobUtsdDgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwiaWQiOiIyRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwibmFtZSI6Ik9hc2lzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeQ==", + "IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRFWWlhQ2ltT2IxTGkxYm5iN3BwaTYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80RVlpYUNpbU9iMUxpMWJuYjdwcGk2IiwiaWQiOiI0RVlpYUNpbU9iMUxpMWJuYjdwcGk2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzVkN2Y3YjMwZDFlY2Y2M2Q5ZGM3MDczYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1ZDdmN2IzMGQxZWNmNjNkOWRjNzA3M2MifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTVkN2Y3YjMwZDFlY2Y2M2Q5ZGM3MDczYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiIoV2hhdCdzIFRoZSBTdG9yeSkgTW9ybmluZyBHbG9yeT8gKDMwdGggQW5uaXZlcnNhcnkgRGVsdXhlIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0xMC0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRFWWlhQ2ltT2IxTGkxYm5iN3BwaTYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJpZCI6IjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJuYW1lIjoiT2FzaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjoyNTEwMjQsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlFDUDI1MDAwOTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJreW5nU3NXdkt6cUlXUnNPb0w5cUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8ya3luZ1NzV3ZLenFJV1JzT29MOXFBIiwiaWQiOiIya3luZ1NzV3ZLenFJV1JzT29MOXFBIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldvbmRlcndhbGwgKFVucGx1Z2dlZCkiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mmt5bmdTc1d2S3pxSQ==", + "V1JzT29MOXFBIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsImlkIjoiMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsIm5hbWUiOiJPYXNpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRGF4cWdyT2hrZUgwZnBlaVFxMmY0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNEVZaWFDaW1PYjFMaTFibmI3cHBpNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRFWWlhQ2ltT2IxTGkxYm5iN3BwaTYiLCJpZCI6IjRFWWlhQ2ltT2IxTGkxYm5iN3BwaTYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNWQ3ZjdiMzBkMWVjZjYzZDlkYzcwNzNjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjVkN2Y3YjMwZDFlY2Y2M2Q5ZGM3MDczYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNWQ3ZjdiMzBkMWVjZjYzZDlkYzcwNzNjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IihXaGF0J3MgVGhlIFN0b3J5KSBNb3JuaW5nIEdsb3J5PyAoMzB0aCBBbm5pdmVyc2FyeSBEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTEwLTAzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEVZaWFDaW1PYjFMaTFibmI3cHBpNiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsImlkIjoiMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsIm5hbWUiOiJPYXNpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRGF4cWdyT2hrZUgwZnBlaVFxMmY0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1ODc3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZA==", + "cyI6eyJpc3JjIjoiR0JRQ1AxNDAwMTA5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80YVpZbm5wNkw4eERYcEFRc2MyaXEyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGFaWW5ucDZMOHhEWHBBUXNjMmlxMiIsImlkIjoiNGFaWW5ucDZMOHhEWHBBUXNjMmlxMiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXb25kZXJ3YWxsIC0gUmVtYXN0ZXJlZCIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0YVpZbm5wNkw4eERYcEFRc2MyaXEyIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsImlkIjoiMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsIm5hbWUiOiJPYXNpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRGF4cWdyT2hrZUgwZnBlaVFxMmY0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMXphUHNDOGRCRmZlc29ZNjJNd01GYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzF6YVBzQzhkQkZmZXNvWTYyTXdNRmEiLCJpZCI6IjF6YVBzQzhkQkZmZXNvWTYyTXdNRmEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDcwYzQ4ZTM5ZWJlYzA1ZjI3YTcyMTFmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA3MGM0OGUzOWViZWMwNWYyN2E3MjExZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDcwYzQ4ZTM5ZWJlYzA1ZjI3YTcyMTFmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0b3AgVGhlIENsb2NrcyIsInJlbGVhc2VfZGF0ZSI6IjIwMDYtMTEtMjAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxemFQc0M4ZEJGZmVzb1k2Mk13TUZhIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dA==", + "cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJpZCI6IjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQiLCJuYW1lIjoiT2FzaXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTg2MTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFBVzk1MDAxODkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBkRDRteWFuZ2xuMVJSQnp3V1VjSVEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wZEQ0bXlhbmdsbjFSUkJ6d1dVY0lRIiwiaWQiOiIwZEQ0bXlhbmdsbjFSUkJ6d1dVY0lRIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldvbmRlcndhbGwiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGRENG15YW5nbG4xUlJCendXVWNJUSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkRheHFnck9oa2VIMGZwZWlRcTJmNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwiaWQiOiIyRGF4cWdyT2hrZUgwZnBlaVFxMmY0IiwibmFtZSI6Ik9hc2lzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zZXpJNEV0c29iTkVoVjBXU0VzQ0duIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2V6STRFdHNvYk5FaFYwV1NFc0NHbiIsImlkIjoiM2V6STRFdHNvYk5FaFYwV1NFc0NHbiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhNGU1ZGNiYjVkZGNmMTMwY2JlZGQxMDEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTRlNWRjYmI1ZGRjZjEzMGNiZWRkMTAxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLg==", + "Y28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWE0ZTVkY2JiNWRkY2YxMzBjYmVkZDEwMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXb25kZXJ3YWxsIiwicmVsZWFzZV9kYXRlIjoiMTk5NS0xMC0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2V6STRFdHNvYk5FaFYwV1NFc0NHbiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJEYXhxZ3JPaGtlSDBmcGVpUXEyZjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsImlkIjoiMkRheHFnck9oa2VIMGZwZWlRcTJmNCIsIm5hbWUiOiJPYXNpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRGF4cWdyT2hrZUgwZnBlaVFxMmY0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1ODkwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUFXOTUwMDE4OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2RQZDNkeDRpcEJlMTB4S3VoajllWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdkUGQzZHg0aXBCZTEweEt1aGo5ZVkiLCJpZCI6IjdkUGQzZHg0aXBCZTEweEt1aGo5ZVkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV29uZGVyd2FsbCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3ZFBkM2R4NGlwQmUxMHhLdWhqOWVZIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Wonderwall%22+artist%3A%22Oasis%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Waterfalls%22%20artist%3A%22TLC%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/5eg56dCpFn32neJak2vk0f"},"href":"https://api.spotify.com/v1/albums/5eg56dCpFn32neJak2vk0f","id":"5eg56dCpFn32neJak2vk0f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733ae63e3e2d9da8366e33fdab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023ae63e3e2d9da8366e33fdab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513ae63e3e2d9da8366e33fdab"}],"is_playable":true,"name":"Crazysexycool","release_date":"1994-11-15","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5eg56dCpFn32neJak2vk0f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":279506,"explicit":false,"external_ids":{"isrc":"USLF29400133"},"external_urls":{"spotify":"https://open.spotify.com/track/6qspW4YKycviDFjHBOaqUY"},"href":"https://api.spotify.com/v1/tracks/6qspW4YKycviDFjHBOaqUY","id":"6qspW4YKycviDFjHBOaqUY","is_local":false,"is_playable":true,"name":"Waterfalls","track_number":8,"type":"track","uri":"spotify:track:6qspW4YKycviDFjHBOaqUY"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/3tzcimbANTDy0VQKI1c0JJ"},"href":"https://api.spotify.com/v1/albums/3tzcimbANTDy0VQKI1c0JJ","id":"3tzcimbANTDy0VQKI1c0JJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b594fab6dd50595563adc50b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b594fab6dd50595563adc50b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b594fab6dd50595563adc50b"}],"is_playable":true,"name":"Waterfalls (Remixes)","release_date":"1995-05-29","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:3tzcimbANTDy0VQKI1c0JJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":259933,"explicit":false,"external_ids":{"isrc":"USLF20300005"},"external_urls":{"spotify":"https://open.spotify.com/track/76fn6jLgMwrQDS08ACFIU1"},"href":"https://api.spotify.com/v1/tracks/76fn6jLgMwrQDS08ACFIU1","id":"76fn6jLgMwrQDS08ACFIU1","is_local":false,"is_playable":true,"name":"Waterfalls - Single Edit","track_number":1,"type":"track","uri":"spotify:track:76fn6jLgMwrQDS08ACFIU1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/3dq455biBObErkzqox5TpS"},"href":"https://api.spotify.com/v1/albums/3dq455biBObErkzqox5TpS","id":"3dq455biBObErkzqox5TpS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273915ff4edf8a05d50b3a330fa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02915ff4edf8a05d50b3a330fa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851915ff4edf8a05d50b3a330fa"}],"is_playable":true,"name":"20","release_date":"2013-10-15","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:3dq455biBObErkzqox5TpS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":257064,"explicit":false,"external_ids":{"isrc":"USSM11306170"},"external_urls":{"spotify":"https://open.spotify.com/track/4utZwg1iDZW7WCNETKhduY"},"href":"https://api.spotify.com/v1/tracks/4utZwg1iDZW7WCNETKhduY","id":"4utZwg1iDZW7WCNETKhduY","is_local":false,"is_playable":true,"name":"Waterfalls","track_number":6,"type":"track","uri":"spotify:track:4utZwg1iDZW7WCNETKhduY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/1ohF0hXuHF9v1jlvSGZ7zx"},"href":"https://api.spotify.com/v1/albums/1ohF0hXuHF9v1jlvSGZ7zx","id":"1ohF0hXuHF9v1jlvSGZ7zx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335631b46ed126e73fbe71071"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235631b46ed126e73fbe71071"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135631b46ed126e73fbe71071"}],"is_playable":true,"name":"CrazySexyCool (30th Anniversary Edition)","release_date":"2024-11-15","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:1ohF0hXuHF9v1jlvSGZ7zx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1AMCtgWEnaZcHmIhD5wGjz"},"href":"https://api.spotify.com/v1/artists/1AMCtgWEnaZcHmIhD5wGjz","id":"1AMCtgWEnaZcHmIhD5wGjz","name":"DE SOFFER","type":"artist","uri":"spotify:artist:1AMCtgWEnaZcHmIhD5wGjz"}],"disc_number":1,"duration_ms":237966,"explicit":false,"external_ids":{"isrc":"USLF22400013"},"external_urls":{"spotify":"https://open.spotify.com/track/1Sh07eQm734Yff2q8Luhn3"},"href":"https://api.spotify.com/v1/tracks/1Sh07eQm734Yff2q8Luhn3","id":"1Sh07eQm734Yff2q8Luhn3","is_local":false,"is_playable":true,"name":"Waterfalls - DE SOFFER Official Remix","track_number":18,"type":"track","uri":"spotify:track:1Sh07eQm734Yff2q8Luhn3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/3tzcimbANTDy0VQKI1c0JJ"},"href":"https://api.spotify.com/v1/albums/3tzcimbANTDy0VQKI1c0JJ","id":"3tzcimbANTDy0VQKI1c0JJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b594fab6dd50595563adc50b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b594fab6dd50595563adc50b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b594fab6dd50595563adc50b"}],"is_playable":true,"name":"Waterfalls (Remixes)","release_date":"1995-05-29","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:3tzcimbANTDy0VQKI1c0JJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":213207,"explicit":false,"external_ids":{"isrc":"USLF20400001"},"external_urls":{"spotify":"https://open.spotify.com/track/4wyXAYfJyE04Kx0aICYk9y"},"href":"https://api.spotify.com/v1/tracks/4wyXAYfJyE04Kx0aICYk9y","id":"4wyXAYfJyE04Kx0aICYk9y","is_local":false,"is_playable":true,"name":"Waterfalls - No Rap Radio Edit","track_number":2,"type":"track","uri":"spotify:track:4wyXAYfJyE04Kx0aICYk9y"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/5qyn4jD90I0A7mLGAxJ2Fz"},"href":"https://api.spotify.com/v1/albums/5qyn4jD90I0A7mLGAxJ2Fz","id":"5qyn4jD90I0A7mLGAxJ2Fz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735d51a72a7a9b522495e453f0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025d51a72a7a9b522495e453f0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515d51a72a7a9b522495e453f0"}],"is_playable":true,"name":"Now & Forever - The Hits","release_date":"2003-09-30","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:5qyn4jD90I0A7mLGAxJ2Fz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":258600,"explicit":false,"external_ids":{"isrc":"USLF20300005"},"external_urls":{"spotify":"https://open.spotify.com/track/7jWu1xqelf7NN8bWtqVECE"},"href":"https://api.spotify.com/v1/tracks/7jWu1xqelf7NN8bWtqVECE","id":"7jWu1xqelf7NN8bWtqVECE","is_local":false,"is_playable":true,"name":"Waterfalls - Single Edit","track_number":8,"type":"track","uri":"spotify:track:7jWu1xqelf7NN8bWtqVECE"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6odcotWv2xd7NP7RrGBS5b"},"href":"https://api.spotify.com/v1/albums/6odcotWv2xd7NP7RrGBS5b","id":"6odcotWv2xd7NP7RrGBS5b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b212e660aec81b60a425d4f1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b212e660aec81b60a425d4f1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b212e660aec81b60a425d4f1"}],"is_playable":true,"name":"90s 100 Hits","release_date":"2014-11-28","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:6odcotWv2xd7NP7RrGBS5b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":258600,"explicit":false,"external_ids":{"isrc":"USLF20300005"},"external_urls":{"spotify":"https://open.spotify.com/track/5pTQYJu8tGm7bQMvww72dM"},"href":"https://api.spotify.com/v1/tracks/5pTQYJu8tGm7bQMvww72dM","id":"5pTQYJu8tGm7bQMvww72dM","is_local":false,"is_playable":true,"name":"Waterfalls - Single Edit","track_number":25,"type":"track","uri":"spotify:track:5pTQYJu8tGm7bQMvww72dM"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0QhwxYDUougJiVDtyN4Lhm"},"href":"https://api.spotify.com/v1/albums/0QhwxYDUougJiVDtyN4Lhm","id":"0QhwxYDUougJiVDtyN4Lhm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c3fd856b637a87c675d2f29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c3fd856b637a87c675d2f29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c3fd856b637a87c675d2f29"}],"is_playable":true,"name":"R&B - 100 Hits - The Greatest R n B album - 100 R & B Classics featuring Usher, Pitbull and Synthetic Listener Timberlake","release_date":"2013-06-24","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0QhwxYDUougJiVDtyN4Lhm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":212040,"explicit":false,"external_ids":{"isrc":"USLF20400001"},"external_urls":{"spotify":"https://open.spotify.com/track/0DEvEbv90r6Ex9h9KpaJus"},"href":"https://api.spotify.com/v1/tracks/0DEvEbv90r6Ex9h9KpaJus","id":"0DEvEbv90r6Ex9h9KpaJus","is_local":false,"is_playable":true,"name":"Waterfalls - No Rap Radio Edit","track_number":67,"type":"track","uri":"spotify:track:0DEvEbv90r6Ex9h9KpaJus"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/74RK3gsxjigff01cRt7pLL"},"href":"https://api.spotify.com/v1/albums/74RK3gsxjigff01cRt7pLL","id":"74RK3gsxjigff01cRt7pLL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273560ad11ec0217ab0655f05ed"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02560ad11ec0217ab0655f05ed"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851560ad11ec0217ab0655f05ed"}],"is_playable":true,"name":"Love Songs","release_date":"2009-02-02","release_date_precision":"day","total_tracks":90,"type":"album","uri":"spotify:album:74RK3gsxjigff01cRt7pLL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":279720,"explicit":false,"external_ids":{"isrc":"USLF29400133"},"external_urls":{"spotify":"https://open.spotify.com/track/4gsi0Rug2wkeqGv8bWraHv"},"href":"https://api.spotify.com/v1/tracks/4gsi0Rug2wkeqGv8bWraHv","id":"4gsi0Rug2wkeqGv8bWraHv","is_local":false,"is_playable":true,"name":"Waterfalls","track_number":52,"type":"track","uri":"spotify:track:4gsi0Rug2wkeqGv8bWraHv"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Waterfalls%22%20artist%3A%22TLC%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/5eg56dCpFn32neJak2vk0f"},"href":"https://api.spotify.com/v1/albums/5eg56dCpFn32neJak2vk0f","id":"5eg56dCpFn32neJak2vk0f","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733ae63e3e2d9da8366e33fdab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023ae63e3e2d9da8366e33fdab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513ae63e3e2d9da8366e33fdab"}],"is_playable":true,"name":"Crazysexycool","release_date":"1994-11-15","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5eg56dCpFn32neJak2vk0f"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":279506,"explicit":false,"external_ids":{"isrc":"USLF29400133"},"external_urls":{"spotify":"https://open.spotify.com/track/6qspW4YKycviDFjHBOaqUY"},"href":"https://api.spotify.com/v1/tracks/6qspW4YKycviDFjHBOaqUY","id":"6qspW4YKycviDFjHBOaqUY","is_local":false,"is_playable":true,"name":"Waterfalls","track_number":8,"type":"track","uri":"spotify:track:6qspW4YKycviDFjHBOaqUY"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/3tzcimbANTDy0VQKI1c0JJ"},"href":"https://api.spotify.com/v1/albums/3tzcimbANTDy0VQKI1c0JJ","id":"3tzcimbANTDy0VQKI1c0JJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b594fab6dd50595563adc50b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b594fab6dd50595563adc50b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b594fab6dd50595563adc50b"}],"is_playable":true,"name":"Waterfalls (Remixes)","release_date":"1995-05-29","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:3tzcimbANTDy0VQKI1c0JJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":259933,"explicit":false,"external_ids":{"isrc":"USLF20300005"},"external_urls":{"spotify":"https://open.spotify.com/track/76fn6jLgMwrQDS08ACFIU1"},"href":"https://api.spotify.com/v1/tracks/76fn6jLgMwrQDS08ACFIU1","id":"76fn6jLgMwrQDS08ACFIU1","is_local":false,"is_playable":true,"name":"Waterfalls - Single Edit","track_number":1,"type":"track","uri":"spotify:track:76fn6jLgMwrQDS08ACFIU1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/3dq455biBObErkzqox5TpS"},"href":"https://api.spotify.com/v1/albums/3dq455biBObErkzqox5TpS","id":"3dq455biBObErkzqox5TpS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273915ff4edf8a05d50b3a330fa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02915ff4edf8a05d50b3a330fa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851915ff4edf8a05d50b3a330fa"}],"is_playable":true,"name":"20","release_date":"2013-10-15","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:3dq455biBObErkzqox5TpS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":257064,"explicit":false,"external_ids":{"isrc":"USSM11306170"},"external_urls":{"spotify":"https://open.spotify.com/track/4utZwg1iDZW7WCNETKhduY"},"href":"https://api.spotify.com/v1/tracks/4utZwg1iDZW7WCNETKhduY","id":"4utZwg1iDZW7WCNETKhduY","is_local":false,"is_playable":true,"name":"Waterfalls","track_number":6,"type":"track","uri":"spotify:track:4utZwg1iDZW7WCNETKhduY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/1ohF0hXuHF9v1jlvSGZ7zx"},"href":"https://api.spotify.com/v1/albums/1ohF0hXuHF9v1jlvSGZ7zx","id":"1ohF0hXuHF9v1jlvSGZ7zx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27335631b46ed126e73fbe71071"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0235631b46ed126e73fbe71071"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485135631b46ed126e73fbe71071"}],"is_playable":true,"name":"CrazySexyCool (30th Anniversary Edition)","release_date":"2024-11-15","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:1ohF0hXuHF9v1jlvSGZ7zx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1AMCtgWEnaZcHmIhD5wGjz"},"href":"https://api.spotify.com/v1/artists/1AMCtgWEnaZcHmIhD5wGjz","id":"1AMCtgWEnaZcHmIhD5wGjz","name":"DE SOFFER","type":"artist","uri":"spotify:artist:1AMCtgWEnaZcHmIhD5wGjz"}],"disc_number":1,"duration_ms":237966,"explicit":false,"external_ids":{"isrc":"USLF22400013"},"external_urls":{"spotify":"https://open.spotify.com/track/1Sh07eQm734Yff2q8Luhn3"},"href":"https://api.spotify.com/v1/tracks/1Sh07eQm734Yff2q8Luhn3","id":"1Sh07eQm734Yff2q8Luhn3","is_local":false,"is_playable":true,"name":"Waterfalls - DE SOFFER Official Remix","track_number":18,"type":"track","uri":"spotify:track:1Sh07eQm734Yff2q8Luhn3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/3tzcimbANTDy0VQKI1c0JJ"},"href":"https://api.spotify.com/v1/albums/3tzcimbANTDy0VQKI1c0JJ","id":"3tzcimbANTDy0VQKI1c0JJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b594fab6dd50595563adc50b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b594fab6dd50595563adc50b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b594fab6dd50595563adc50b"}],"is_playable":true,"name":"Waterfalls (Remixes)","release_date":"1995-05-29","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:3tzcimbANTDy0VQKI1c0JJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":213207,"explicit":false,"external_ids":{"isrc":"USLF20400001"},"external_urls":{"spotify":"https://open.spotify.com/track/4wyXAYfJyE04Kx0aICYk9y"},"href":"https://api.spotify.com/v1/tracks/4wyXAYfJyE04Kx0aICYk9y","id":"4wyXAYfJyE04Kx0aICYk9y","is_local":false,"is_playable":true,"name":"Waterfalls - No Rap Radio Edit","track_number":2,"type":"track","uri":"spotify:track:4wyXAYfJyE04Kx0aICYk9y"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"external_urls":{"spotify":"https://open.spotify.com/album/5qyn4jD90I0A7mLGAxJ2Fz"},"href":"https://api.spotify.com/v1/albums/5qyn4jD90I0A7mLGAxJ2Fz","id":"5qyn4jD90I0A7mLGAxJ2Fz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735d51a72a7a9b522495e453f0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025d51a72a7a9b522495e453f0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515d51a72a7a9b522495e453f0"}],"is_playable":true,"name":"Now & Forever - The Hits","release_date":"2003-09-30","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:5qyn4jD90I0A7mLGAxJ2Fz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":258600,"explicit":false,"external_ids":{"isrc":"USLF20300005"},"external_urls":{"spotify":"https://open.spotify.com/track/7jWu1xqelf7NN8bWtqVECE"},"href":"https://api.spotify.com/v1/tracks/7jWu1xqelf7NN8bWtqVECE","id":"7jWu1xqelf7NN8bWtqVECE","is_local":false,"is_playable":true,"name":"Waterfalls - Single Edit","track_number":8,"type":"track","uri":"spotify:track:7jWu1xqelf7NN8bWtqVECE"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6odcotWv2xd7NP7RrGBS5b"},"href":"https://api.spotify.com/v1/albums/6odcotWv2xd7NP7RrGBS5b","id":"6odcotWv2xd7NP7RrGBS5b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b212e660aec81b60a425d4f1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b212e660aec81b60a425d4f1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b212e660aec81b60a425d4f1"}],"is_playable":true,"name":"90s 100 Hits","release_date":"2014-11-28","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:6odcotWv2xd7NP7RrGBS5b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":258600,"explicit":false,"external_ids":{"isrc":"USLF20300005"},"external_urls":{"spotify":"https://open.spotify.com/track/5pTQYJu8tGm7bQMvww72dM"},"href":"https://api.spotify.com/v1/tracks/5pTQYJu8tGm7bQMvww72dM","id":"5pTQYJu8tGm7bQMvww72dM","is_local":false,"is_playable":true,"name":"Waterfalls - Single Edit","track_number":25,"type":"track","uri":"spotify:track:5pTQYJu8tGm7bQMvww72dM"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0QhwxYDUougJiVDtyN4Lhm"},"href":"https://api.spotify.com/v1/albums/0QhwxYDUougJiVDtyN4Lhm","id":"0QhwxYDUougJiVDtyN4Lhm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c3fd856b637a87c675d2f29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c3fd856b637a87c675d2f29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c3fd856b637a87c675d2f29"}],"is_playable":true,"name":"R&B - 100 Hits - The Greatest R n B album - 100 R & B Classics featuring Usher, Pitbull and Synthetic Listener Timberlake","release_date":"2013-06-24","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0QhwxYDUougJiVDtyN4Lhm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":212040,"explicit":false,"external_ids":{"isrc":"USLF20400001"},"external_urls":{"spotify":"https://open.spotify.com/track/0DEvEbv90r6Ex9h9KpaJus"},"href":"https://api.spotify.com/v1/tracks/0DEvEbv90r6Ex9h9KpaJus","id":"0DEvEbv90r6Ex9h9KpaJus","is_local":false,"is_playable":true,"name":"Waterfalls - No Rap Radio Edit","track_number":67,"type":"track","uri":"spotify:track:0DEvEbv90r6Ex9h9KpaJus"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/74RK3gsxjigff01cRt7pLL"},"href":"https://api.spotify.com/v1/albums/74RK3gsxjigff01cRt7pLL","id":"74RK3gsxjigff01cRt7pLL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273560ad11ec0217ab0655f05ed"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02560ad11ec0217ab0655f05ed"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851560ad11ec0217ab0655f05ed"}],"is_playable":true,"name":"Love Songs","release_date":"2009-02-02","release_date_precision":"day","total_tracks":90,"type":"album","uri":"spotify:album:74RK3gsxjigff01cRt7pLL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0TImkz4nPqjegtVSMZnMRq"},"href":"https://api.spotify.com/v1/artists/0TImkz4nPqjegtVSMZnMRq","id":"0TImkz4nPqjegtVSMZnMRq","name":"TLC","type":"artist","uri":"spotify:artist:0TImkz4nPqjegtVSMZnMRq"}],"disc_number":1,"duration_ms":279720,"explicit":false,"external_ids":{"isrc":"USLF29400133"},"external_urls":{"spotify":"https://open.spotify.com/track/4gsi0Rug2wkeqGv8bWraHv"},"href":"https://api.spotify.com/v1/tracks/4gsi0Rug2wkeqGv8bWraHv","id":"4gsi0Rug2wkeqGv8bWraHv","is_local":false,"is_playable":true,"name":"Waterfalls","track_number":52,"type":"track","uri":"spotify:track:4gsi0Rug2wkeqGv8bWraHv"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Waterfalls%22+artist%3A%22TLC%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Basket%20Case%22%20artist%3A%22Green%20Day%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"external_urls":{"spotify":"https://open.spotify.com/album/4uG8q3GPuWHQlRbswMIRS6"},"href":"https://api.spotify.com/v1/albums/4uG8q3GPuWHQlRbswMIRS6","id":"4uG8q3GPuWHQlRbswMIRS6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273db89b08034de626ebee6823d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02db89b08034de626ebee6823d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851db89b08034de626ebee6823d"}],"is_playable":true,"name":"Dookie","release_date":"1994-02-01","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4uG8q3GPuWHQlRbswMIRS6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"disc_number":1,"duration_ms":181533,"explicit":false,"external_ids":{"isrc":"USRE19900151"},"external_urls":{"spotify":"https://open.spotify.com/track/6L89mwZXSOwYl76YXfX13s"},"href":"https://api.spotify.com/v1/tracks/6L89mwZXSOwYl76YXfX13s","id":"6L89mwZXSOwYl76YXfX13s","is_local":false,"is_playable":true,"name":"Basket Case","track_number":7,"type":"track","uri":"spotify:track:6L89mwZXSOwYl76YXfX13s"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"external_urls":{"spotify":"https://open.spotify.com/album/6HUIbDhzmqcwxrxUfTuHdW"},"href":"https://api.spotify.com/v1/albums/6HUIbDhzmqcwxrxUfTuHdW","id":"6HUIbDhzmqcwxrxUfTuHdW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f7bcced5cc8ee6e45f8f3330"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f7bcced5cc8ee6e45f8f3330"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f7bcced5cc8ee6e45f8f3330"}],"is_playable":true,"name":"International Superhits!","release_date":"2001-11-13","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:6HUIbDhzmqcwxrxUfTuHdW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"disc_number":1,"duration_ms":181533,"explicit":false,"external_ids":{"isrc":"USRE19900151"},"external_urls":{"spotify":"https://open.spotify.com/track/3wr2d7pc6n1uKXOXZCX8LT"},"href":"https://api.spotify.com/v1/tracks/3wr2d7pc6n1uKXOXZCX8LT","id":"3wr2d7pc6n1uKXOXZCX8LT","is_local":false,"is_playable":true,"name":"Basket Case","track_number":5,"type":"track","uri":"spotify:track:3wr2d7pc6n1uKXOXZCX8LT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Fz1Rz0WlGAbBSht1UPmNw"},"href":"https://api.spotify.com/v1/albums/4Fz1Rz0WlGAbBSht1UPmNw","id":"4Fz1Rz0WlGAbBSht1UPmNw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d4f83af0b4c9d646e6bd41c6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d4f83af0b4c9d646e6bd41c6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d4f83af0b4c9d646e6bd41c6"}],"is_playable":true,"name":"Nimrods Original Soundtrack","release_date":"2026-07-31","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:4Fz1Rz0WlGAbBSht1UPmNw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"disc_number":1,"duration_ms":182916,"explicit":false,"external_ids":{"isrc":"USRE11600554"},"external_urls":{"spotify":"https://open.spotify.com/track/2bOwNvZGmOGHrhtwHMpCvS"},"href":"https://api.spotify.com/v1/tracks/2bOwNvZGmOGHrhtwHMpCvS","id":"2bOwNvZGmOGHrhtwHMpCvS","is_local":false,"is_playable":true,"name":"Basket Case","track_number":11,"type":"track","uri":"spotify:track:2bOwNvZGmOGHrhtwHMpCvS"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"external_urls":{"spotify":"https://open.spotify.com/album/47l8TkJCLzHaekHImz1e9g"},"href":"https://api.spotify.com/v1/albums/47l8TkJCLzHaekHImz1e9g","id":"47l8TkJCLzHaekHImz1e9g","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e6a71e57f57e5a2abfb29a24"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e6a71e57f57e5a2abfb29a24"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e6a71e57f57e5a2abfb29a24"}],"is_playable":true,"name":"Dookie (30th Anniversary Deluxe Edition)","release_date":"2023-08-17","release_date_precision":"day","total_tracks":65,"type":"album","uri":"spotify:album:47l8TkJCLzHaekHImz1e9g"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"disc_number":1,"duration_ms":182916,"explicit":false,"external_ids":{"isrc":"USRE11600554"},"external_urls":{"spotify":"https://open.spotify.com/track/3IVRacQwKGORqcxNEPMXlA"},"href":"https://api.spotify.com/v1/tracks/3IVRacQwKGORqcxNEPMXlA","id":"3IVRacQwKGORqcxNEPMXlA","is_local":false,"is_playable":true,"name":"Basket Case","track_number":7,"type":"track","uri":"spotify:track:3IVRacQwKGORqcxNEPMXlA"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"external_urls":{"spotify":"https://open.spotify.com/album/3id4t9IqRoB1f1smOERtrY"},"href":"https://api.spotify.com/v1/albums/3id4t9IqRoB1f1smOERtrY","id":"3id4t9IqRoB1f1smOERtrY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737f213369d5265a60af5f7e82"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027f213369d5265a60af5f7e82"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517f213369d5265a60af5f7e82"}],"is_playable":true,"name":"Greatest Hits: God's Favorite Band","release_date":"2017-11-17","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:3id4t9IqRoB1f1smOERtrY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"disc_number":1,"duration_ms":181533,"explicit":false,"external_ids":{"isrc":"USRE19900151"},"external_urls":{"spotify":"https://open.spotify.com/track/2WtF8X3W7iHPF2KaJGUCuO"},"href":"https://api.spotify.com/v1/tracks/2WtF8X3W7iHPF2KaJGUCuO","id":"2WtF8X3W7iHPF2KaJGUCuO","is_local":false,"is_playable":true,"name":"Basket Case","track_number":4,"type":"track","uri":"spotify:track:2WtF8X3W7iHPF2KaJGUCuO"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2jO46Qg9k0nlkkQjz6lbel"},"href":"https://api.spotify.com/v1/albums/2jO46Qg9k0nlkkQjz6lbel","id":"2jO46Qg9k0nlkkQjz6lbel","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734c06eace1fe78eb0d6f4d426"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024c06eace1fe78eb0d6f4d426"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514c06eace1fe78eb0d6f4d426"}],"is_playable":true,"name":"Rock Classics","release_date":"2023-03-03","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:2jO46Qg9k0nlkkQjz6lbel"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"disc_number":1,"duration_ms":181533,"explicit":false,"external_ids":{"isrc":"USRE19900151"},"external_urls":{"spotify":"https://open.spotify.com/track/2V7W5smzQ7iT1DBsPcvpCN"},"href":"https://api.spotify.com/v1/tracks/2V7W5smzQ7iT1DBsPcvpCN","id":"2V7W5smzQ7iT1DBsPcvpCN","is_local":false,"is_playable":true,"name":"Basket Case","track_number":7,"type":"track","uri":"spotify:track:2V7W5smzQ7iT1DBsPcvpCN"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/28VHbgQCpKUSn0XfMzI4fN"},"href":"https://api.spotify.com/v1/albums/28VHbgQCpKUSn0XfMzI4fN","id":"28VHbgQCpKUSn0XfMzI4fN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d0f5e77d9d009d9e70138583"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d0f5e77d9d009d9e70138583"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d0f5e77d9d009d9e70138583"}],"is_playable":true,"name":"Bar Music 2025","release_date":"2025-06-13","release_date_precision":"day","total_tracks":55,"type":"album","uri":"spotify:album:28VHbgQCpKUSn0XfMzI4fN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7oPftvlwr6VrsViSDV7fJY"},"href":"https://api.spotify.com/v1/artists/7oPftvlwr6VrsViSDV7fJY","id":"7oPftvlwr6VrsViSDV7fJY","name":"Green Day","type":"artist","uri":"spotify:artist:7oPftvlwr6VrsViSDV7fJY"}],"disc_number":1,"duration_ms":181533,"explicit":false,"external_ids":{"isrc":"USRE19900151"},"external_urls":{"spotify":"https://open.spotify.com/track/4RxGerpvSMdekB6E7xS478"},"href":"https://api.spotify.com/v1/tracks/4RxGerpvSMdekB6E7xS478","id":"4RxGerpvSMdekB6E7xS478","is_local":false,"is_playable":true,"name":"Basket Case","track_number":25,"type":"track","uri":"spotify:track:4RxGerpvSMdekB6E7xS478"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJhc2tldCUyMENhc2UlMjIlMjBhcnRpc3QlM0ElMjJHcmVlbiUyMERheSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIiwiaWQiOiI3b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIiwibmFtZSI6IkdyZWVuIERheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNHVHOHEzR1B1V0hRbFJic3dNSVJTNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzR1RzhxM0dQdVdIUWxSYnN3TUlSUzYiLCJpZCI6IjR1RzhxM0dQdVdIUWxSYnN3TUlSUzYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9p", + "bWFnZS9hYjY3NjE2ZDAwMDBiMjczZGI4OWIwODAzNGRlNjI2ZWJlZTY4MjNkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmRiODliMDgwMzRkZTYyNmViZWU2ODIzZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZGI4OWIwODAzNGRlNjI2ZWJlZTY4MjNkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRvb2tpZSIsInJlbGVhc2VfZGF0ZSI6IjE5OTQtMDItMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0dUc4cTNHUHVXSFFsUmJzd01JUlM2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIiwiaWQiOiI3b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIiwibmFtZSI6IkdyZWVuIERheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4MTUzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkUxOTkwMDE1MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNkw4OW13WlhTT3dZbDc2WVhmWDEzcyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZMODltd1pYU093WWw3NllYZlgxM3MiLCJpZCI6IjZMODltd1pYU093WWw3NllYZlgxM3MiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmFza2V0IENhc2UiLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Nkw4OW13WlhTT3dZbDc2WVhmWDEzcyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJpZCI6IjdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJuYW1lIjoiR3JlZW4gRGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6Ig==", + "c3BvdGlmeTphcnRpc3Q6N29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZIVUliRGh6bXFjd3hyeFVmVHVIZFcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82SFVJYkRoem1xY3d4cnhVZlR1SGRXIiwiaWQiOiI2SFVJYkRoem1xY3d4cnhVZlR1SGRXIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2Y3YmNjZWQ1Y2M4ZWU2ZTQ1ZjhmMzMzMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmN2JjY2VkNWNjOGVlNmU0NWY4ZjMzMzAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWY3YmNjZWQ1Y2M4ZWU2ZTQ1ZjhmMzMzMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJbnRlcm5hdGlvbmFsIFN1cGVyaGl0cyEiLCJyZWxlYXNlX2RhdGUiOiIyMDAxLTExLTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkhVSWJEaHptcWN3eHJ4VWZUdUhkVyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSIsImlkIjoiN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSIsIm5hbWUiOiJHcmVlbiBEYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODE1MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JFMTk5MDAxNTEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzN3cjJkN3BjNm4xdUtYT1haQ1g4TFQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zd3IyZDdwYzZuMXVLWE9YWkNYOExUIiwiaWQiOiIzd3IyZDdwYzZuMXVLWE9YWkNYOExUIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhc2tldCBDYXNlIiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYQ==", + "Y2s6M3dyMmQ3cGM2bjF1S1hPWFpDWDhMVCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJpZCI6IjdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJuYW1lIjoiR3JlZW4gRGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80RnoxUnowV2xHQWJCU2h0MVVQbU53In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNEZ6MVJ6MFdsR0FiQlNodDFVUG1OdyIsImlkIjoiNEZ6MVJ6MFdsR0FiQlNodDFVUG1OdyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkNGY4M2FmMGI0YzlkNjQ2ZTZiZDQxYzYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZDRmODNhZjBiNGM5ZDY0NmU2YmQ0MWM2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkNGY4M2FmMGI0YzlkNjQ2ZTZiZDQxYzYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmltcm9kcyBPcmlnaW5hbCBTb3VuZHRyYWNrIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNy0zMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRGejFSejBXbEdBYkJTaHQxVVBtTncifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJpZCI6IjdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJuYW1lIjoiR3JlZW4gRGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTgyOTE2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSRQ==", + "MTE2MDA1NTQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJiT3dOdlpHbU9HSHJodHdITXBDdlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yYk93TnZaR21PR0hyaHR3SE1wQ3ZTIiwiaWQiOiIyYk93TnZaR21PR0hyaHR3SE1wQ3ZTIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhc2tldCBDYXNlIiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyYk93TnZaR21PR0hyaHR3SE1wQ3ZTIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSIsImlkIjoiN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSIsIm5hbWUiOiJHcmVlbiBEYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzQ3bDhUa0pDTHpIYWVrSEltejFlOWcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80N2w4VGtKQ0x6SGFla0hJbXoxZTlnIiwiaWQiOiI0N2w4VGtKQ0x6SGFla0hJbXoxZTlnIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2U2YTcxZTU3ZjU3ZTVhMmFiZmIyOWEyNCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlNmE3MWU1N2Y1N2U1YTJhYmZiMjlhMjQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWU2YTcxZTU3ZjU3ZTVhMmFiZmIyOWEyNCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEb29raWUgKDMwdGggQW5uaXZlcnNhcnkgRGVsdXhlIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wOC0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjY1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjQ3bDhUa0pDTHpIYWVrSEltejFlOWcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Lw==", + "L29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSIsImlkIjoiN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSIsIm5hbWUiOiJHcmVlbiBEYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODI5MTYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JFMTE2MDA1NTQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNJVlJhY1F3S0dPUnFjeE5FUE1YbEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zSVZSYWNRd0tHT1JxY3hORVBNWGxBIiwiaWQiOiIzSVZSYWNRd0tHT1JxY3hORVBNWGxBIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhc2tldCBDYXNlIiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNJVlJhY1F3S0dPUnFjeE5FUE1YbEEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIiwiaWQiOiI3b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIiwibmFtZSI6IkdyZWVuIERheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2lkNHQ5SXFSb0IxZjFzbU9FUnRyWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNpZDR0OUlxUm9CMWYxc21PRVJ0clkiLCJpZCI6IjNpZDR0OUlxUm9CMWYxc21PRVJ0clkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2YyMTMzNjlkNTI2NWE2MGFmNWY3ZTgyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdmMjEzMzY5ZDUyNjVhNjBhZjVmN2U4MiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwcw==", + "Oi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3ZjIxMzM2OWQ1MjY1YTYwYWY1ZjdlODIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3JlYXRlc3QgSGl0czogR29kJ3MgRmF2b3JpdGUgQmFuZCIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMTEtMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozaWQ0dDlJcVJvQjFmMXNtT0VSdHJZIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN29QZnR2bHdyNlZyc1ZpU0RWN2ZKWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIiwiaWQiOiI3b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIiwibmFtZSI6IkdyZWVuIERheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4MTUzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkUxOTkwMDE1MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMld0RjhYM1c3aUhQRjJLYUpHVUN1TyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJXdEY4WDNXN2lIUEYyS2FKR1VDdU8iLCJpZCI6IjJXdEY4WDNXN2lIUEYyS2FKR1VDdU8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmFza2V0IENhc2UiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mld0RjhYM1c3aUhQRjJLYUpHVUN1TyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yak80NlFnOWswbmxra1FqejZsYmVsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aQ==", + "ZnkuY29tL3YxL2FsYnVtcy8yak80NlFnOWswbmxra1FqejZsYmVsIiwiaWQiOiIyak80NlFnOWswbmxra1FqejZsYmVsIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRjMDZlYWNlMWZlNzhlYjBkNmY0ZDQyNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0YzA2ZWFjZTFmZTc4ZWIwZDZmNGQ0MjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRjMDZlYWNlMWZlNzhlYjBkNmY0ZDQyNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb2NrIENsYXNzaWNzIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wMy0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJqTzQ2UWc5azBubGtrUWp6NmxiZWwifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJpZCI6IjdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJuYW1lIjoiR3JlZW4gRGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTgxNTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSRTE5OTAwMTUxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yVjdXNXNtelE3aVQxREJzUGN2cENOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMlY3VzVzbXpRN2lUMURCc1BjdnBDTiIsImlkIjoiMlY3VzVzbXpRN2lUMURCc1BjdnBDTiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCYXNrZXQgQ2FzZSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyVjdXNXNtelE3aVQxREJzUGN2cENOIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifQ==", + "LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMjhWSGJnUUNwS1VTbjBYZk16STRmTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzI4VkhiZ1FDcEtVU24wWGZNekk0Zk4iLCJpZCI6IjI4VkhiZ1FDcEtVU24wWGZNekk0Zk4iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDBmNWU3N2Q5ZDAwOWQ5ZTcwMTM4NTgzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQwZjVlNzdkOWQwMDlkOWU3MDEzODU4MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDBmNWU3N2Q5ZDAwOWQ5ZTcwMTM4NTgzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhciBNdXNpYyAyMDI1IiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wNi0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjU1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjI4VkhiZ1FDcEtVU24wWGZNekk0Zk4ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83b1BmdHZsd3I2VnJzVmlTRFY3ZkpZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJpZCI6IjdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkiLCJuYW1lIjoiR3JlZW4gRGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdvUGZ0dmx3cjZWcnNWaVNEVjdmSlkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTgxNTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSRTE5OTAwMTUxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80UnhHZXJwdlNNZGVrQjZFN3hTNDc4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNFJ4R2VycHZTTWRla0I2RTd4UzQ3OCIsIg==", + "aWQiOiI0UnhHZXJwdlNNZGVrQjZFN3hTNDc4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhc2tldCBDYXNlIiwidHJhY2tfbnVtYmVyIjoyNSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0UnhHZXJwdlNNZGVrQjZFN3hTNDc4In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Basket+Case%22+artist%3A%22Green+Day%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Cryin%27%22%20artist%3A%22Aerosmith%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"external_urls":{"spotify":"https://open.spotify.com/album/180jTzor4W2MQ9HW5h5Fh4"},"href":"https://api.spotify.com/v1/albums/180jTzor4W2MQ9HW5h5Fh4","id":"180jTzor4W2MQ9HW5h5Fh4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27391b246743456e285a20a46ed"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0291b246743456e285a20a46ed"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485191b246743456e285a20a46ed"}],"is_playable":true,"name":"Get A Grip","release_date":"1993-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:180jTzor4W2MQ9HW5h5Fh4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"disc_number":1,"duration_ms":308560,"explicit":false,"external_ids":{"isrc":"USIR10000430"},"external_urls":{"spotify":"https://open.spotify.com/track/4t1fWWJQs5V9YErfsrDslC"},"href":"https://api.spotify.com/v1/tracks/4t1fWWJQs5V9YErfsrDslC","id":"4t1fWWJQs5V9YErfsrDslC","is_local":false,"is_playable":true,"name":"Cryin'","track_number":9,"type":"track","uri":"spotify:track:4t1fWWJQs5V9YErfsrDslC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"external_urls":{"spotify":"https://open.spotify.com/album/2uT123xlHuqvz14JR0KQSs"},"href":"https://api.spotify.com/v1/albums/2uT123xlHuqvz14JR0KQSs","id":"2uT123xlHuqvz14JR0KQSs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d5fdfcb083cb825348505a93"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d5fdfcb083cb825348505a93"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d5fdfcb083cb825348505a93"}],"is_playable":true,"name":"Big Ones","release_date":"1994-01-01","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:2uT123xlHuqvz14JR0KQSs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"disc_number":1,"duration_ms":309160,"explicit":false,"external_ids":{"isrc":"USIR10000430"},"external_urls":{"spotify":"https://open.spotify.com/track/52Rcr4f12OE9tpNRTU7rV8"},"href":"https://api.spotify.com/v1/tracks/52Rcr4f12OE9tpNRTU7rV8","id":"52Rcr4f12OE9tpNRTU7rV8","is_local":false,"is_playable":true,"name":"Cryin'","track_number":7,"type":"track","uri":"spotify:track:52Rcr4f12OE9tpNRTU7rV8"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"external_urls":{"spotify":"https://open.spotify.com/album/33lrptYaoQiDsAcZPXKFna"},"href":"https://api.spotify.com/v1/albums/33lrptYaoQiDsAcZPXKFna","id":"33lrptYaoQiDsAcZPXKFna","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27369968a4d04a773bef8c40f2c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0269968a4d04a773bef8c40f2c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485169968a4d04a773bef8c40f2c"}],"is_playable":true,"name":"Tough Love: Best Of The Ballads","release_date":"2011-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:33lrptYaoQiDsAcZPXKFna"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"disc_number":1,"duration_ms":308640,"explicit":false,"external_ids":{"isrc":"USIR10000430"},"external_urls":{"spotify":"https://open.spotify.com/track/6DrxbTWxIr2lATrvikvaTp"},"href":"https://api.spotify.com/v1/tracks/6DrxbTWxIr2lATrvikvaTp","id":"6DrxbTWxIr2lATrvikvaTp","is_local":false,"is_playable":true,"name":"Cryin'","track_number":4,"type":"track","uri":"spotify:track:6DrxbTWxIr2lATrvikvaTp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"external_urls":{"spotify":"https://open.spotify.com/album/2JgnqOt5m0QNEo3VbplePI"},"href":"https://api.spotify.com/v1/albums/2JgnqOt5m0QNEo3VbplePI","id":"2JgnqOt5m0QNEo3VbplePI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273548ccff5c2a8301e79e272d5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02548ccff5c2a8301e79e272d5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851548ccff5c2a8301e79e272d5"}],"is_playable":true,"name":"Big Ones","release_date":"1994-01-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:2JgnqOt5m0QNEo3VbplePI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"disc_number":1,"duration_ms":309133,"explicit":false,"external_ids":{"isrc":"USIR10000430"},"external_urls":{"spotify":"https://open.spotify.com/track/1JwzpUfjoPGoA1q9IV4Hu0"},"href":"https://api.spotify.com/v1/tracks/1JwzpUfjoPGoA1q9IV4Hu0","id":"1JwzpUfjoPGoA1q9IV4Hu0","is_local":false,"is_playable":true,"name":"Cryin'","track_number":7,"type":"track","uri":"spotify:track:1JwzpUfjoPGoA1q9IV4Hu0"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"external_urls":{"spotify":"https://open.spotify.com/album/2UhyWgiFb1ZDB1p0Uyljd4"},"href":"https://api.spotify.com/v1/albums/2UhyWgiFb1ZDB1p0Uyljd4","id":"2UhyWgiFb1ZDB1p0Uyljd4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ff95edb3382632a7565ef953"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ff95edb3382632a7565ef953"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ff95edb3382632a7565ef953"}],"is_playable":true,"name":"Tough Love: Best Of The Ballads (International Version)","release_date":"2011-01-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:2UhyWgiFb1ZDB1p0Uyljd4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"disc_number":1,"duration_ms":307960,"explicit":false,"external_ids":{"isrc":"USIR10000430"},"external_urls":{"spotify":"https://open.spotify.com/track/16YFSY0VM91QkDJWeC55VL"},"href":"https://api.spotify.com/v1/tracks/16YFSY0VM91QkDJWeC55VL","id":"16YFSY0VM91QkDJWeC55VL","is_local":false,"is_playable":true,"name":"Cryin'","track_number":6,"type":"track","uri":"spotify:track:16YFSY0VM91QkDJWeC55VL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ztZdAffTvNJzXABJ8S0RC"},"href":"https://api.spotify.com/v1/albums/5ztZdAffTvNJzXABJ8S0RC","id":"5ztZdAffTvNJzXABJ8S0RC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27386d467ec73aeaaf8c9cd5332"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0286d467ec73aeaaf8c9cd5332"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485186d467ec73aeaaf8c9cd5332"}],"is_playable":true,"name":"The Very Best Of Aerosmith: Devil's Got A New Disguise","release_date":"2006-10-17","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:5ztZdAffTvNJzXABJ8S0RC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"disc_number":1,"duration_ms":308639,"explicit":false,"external_ids":{"isrc":"USIR10000430"},"external_urls":{"spotify":"https://open.spotify.com/track/59eQjage6zX73paP0qrNSt"},"href":"https://api.spotify.com/v1/tracks/59eQjage6zX73paP0qrNSt","id":"59eQjage6zX73paP0qrNSt","is_local":false,"is_playable":true,"name":"Cryin'","track_number":14,"type":"track","uri":"spotify:track:59eQjage6zX73paP0qrNSt"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6jrlyouSL8PQ1KmBQ6VJxw"},"href":"https://api.spotify.com/v1/albums/6jrlyouSL8PQ1KmBQ6VJxw","id":"6jrlyouSL8PQ1KmBQ6VJxw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273df14bade21e9520d50f3e60d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02df14bade21e9520d50f3e60d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851df14bade21e9520d50f3e60d"}],"is_playable":true,"name":"Rock Anthems","release_date":"2026-04-24","release_date_precision":"day","total_tracks":38,"type":"album","uri":"spotify:album:6jrlyouSL8PQ1KmBQ6VJxw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"},"href":"https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH","id":"7Ey4PD4MYsKc5I2dolUwbH","name":"Aerosmith","type":"artist","uri":"spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"}],"disc_number":1,"duration_ms":308333,"explicit":false,"external_ids":{"isrc":"USIR10000430"},"external_urls":{"spotify":"https://open.spotify.com/track/1G3h4Ys0cyKD9zeKceqo3A"},"href":"https://api.spotify.com/v1/tracks/1G3h4Ys0cyKD9zeKceqo3A","id":"1G3h4Ys0cyKD9zeKceqo3A","is_local":false,"is_playable":true,"name":"Cryin'","track_number":9,"type":"track","uri":"spotify:track:1G3h4Ys0cyKD9zeKceqo3A"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNyeWluJTI3JTIyJTIwYXJ0aXN0JTNBJTIyQWVyb3NtaXRoJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo3LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83RXk0UEQ0TVlzS2M1STJkb2xVd2JIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdFeTRQRDRNWXNLYzVJMmRvbFV3YkgiLCJpZCI6IjdFeTRQRDRNWXNLYzVJMmRvbFV3YkgiLCJuYW1lIjoiQWVyb3NtaXRoIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdFeTRQRDRNWXNLYzVJMmRvbFV3YkgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xODBqVHpvcjRXMk1ROUhXNWg1Rmg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTgwalR6b3I0VzJNUTlIVzVoNUZoNCIsImlkIjoiMTgwalR6b3I0VzJNUTlIVzVoNUZoNCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2Fi", + "Njc2MTZkMDAwMGIyNzM5MWIyNDY3NDM0NTZlMjg1YTIwYTQ2ZWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTFiMjQ2NzQzNDU2ZTI4NWEyMGE0NmVkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5MWIyNDY3NDM0NTZlMjg1YTIwYTQ2ZWQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR2V0IEEgR3JpcCIsInJlbGVhc2VfZGF0ZSI6IjE5OTMtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxODBqVHpvcjRXMk1ROUhXNWg1Rmg0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwiaWQiOiI3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwibmFtZSI6IkFlcm9zbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwODU2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSVIxMDAwMDQzMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNHQxZldXSlFzNVY5WUVyZnNyRHNsQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzR0MWZXV0pRczVWOVlFcmZzckRzbEMiLCJpZCI6IjR0MWZXV0pRczVWOVlFcmZzckRzbEMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ3J5aW4nIiwidHJhY2tfbnVtYmVyIjo5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjR0MWZXV0pRczVWOVlFcmZzckRzbEMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwiaWQiOiI3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwibmFtZSI6IkFlcm9zbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5Og==", + "YXJ0aXN0OjdFeTRQRDRNWXNLYzVJMmRvbFV3YkgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8ydVQxMjN4bEh1cXZ6MTRKUjBLUVNzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMnVUMTIzeGxIdXF2ejE0SlIwS1FTcyIsImlkIjoiMnVUMTIzeGxIdXF2ejE0SlIwS1FTcyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkNWZkZmNiMDgzY2I4MjUzNDg1MDVhOTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZDVmZGZjYjA4M2NiODI1MzQ4NTA1YTkzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkNWZkZmNiMDgzY2I4MjUzNDg1MDVhOTMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmlnIE9uZXMiLCJyZWxlYXNlX2RhdGUiOiIxOTk0LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MnVUMTIzeGxIdXF2ejE0SlIwS1FTcyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdFeTRQRDRNWXNLYzVJMmRvbFV3YkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsImlkIjoiN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsIm5hbWUiOiJBZXJvc21pdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDkxNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0lSMTAwMDA0MzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzUyUmNyNGYxMk9FOXRwTlJUVTdyVjgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81MlJjcjRmMTJPRTl0cE5SVFU3clY4IiwiaWQiOiI1MlJjcjRmMTJPRTl0cE5SVFU3clY4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNyeWluJyIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1MlJjcjRmMTJPRTl0cE5SVFU3clY4In0sew==", + "ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwiaWQiOiI3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwibmFtZSI6IkFlcm9zbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMzNscnB0WWFvUWlEc0FjWlBYS0ZuYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzMzbHJwdFlhb1FpRHNBY1pQWEtGbmEiLCJpZCI6IjMzbHJwdFlhb1FpRHNBY1pQWEtGbmEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNjk5NjhhNGQwNGE3NzNiZWY4YzQwZjJjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjY5OTY4YTRkMDRhNzczYmVmOGM0MGYyYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjk5NjhhNGQwNGE3NzNiZWY4YzQwZjJjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvdWdoIExvdmU6IEJlc3QgT2YgVGhlIEJhbGxhZHMiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MzNscnB0WWFvUWlEc0FjWlBYS0ZuYSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdFeTRQRDRNWXNLYzVJMmRvbFV3YkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsImlkIjoiN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsIm5hbWUiOiJBZXJvc21pdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDg2NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0lSMTAwMDA0MzAifSwiZXh0ZXJuYQ==", + "bF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNkRyeGJUV3hJcjJsQVRydmlrdmFUcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZEcnhiVFd4SXIybEFUcnZpa3ZhVHAiLCJpZCI6IjZEcnhiVFd4SXIybEFUcnZpa3ZhVHAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ3J5aW4nIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZEcnhiVFd4SXIybEFUcnZpa3ZhVHAifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwiaWQiOiI3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwibmFtZSI6IkFlcm9zbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkpnbnFPdDVtMFFORW8zVmJwbGVQSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJKZ25xT3Q1bTBRTkVvM1ZicGxlUEkiLCJpZCI6IjJKZ25xT3Q1bTBRTkVvM1ZicGxlUEkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTQ4Y2NmZjVjMmE4MzAxZTc5ZTI3MmQ1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjU0OGNjZmY1YzJhODMwMWU3OWUyNzJkNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTQ4Y2NmZjVjMmE4MzAxZTc5ZTI3MmQ1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJpZyBPbmVzIiwicmVsZWFzZV9kYXRlIjoiMTk5NC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJKZ25xT3Q1bTBRTkVvM1ZicGxlUEkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83RXk0UEQ0TVlzS2M1STJkb2xVd2JIIn0sIg==", + "aHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsImlkIjoiN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsIm5hbWUiOiJBZXJvc21pdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDkxMzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0lSMTAwMDA0MzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFKd3pwVWZqb1BHb0ExcTlJVjRIdTAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xSnd6cFVmam9QR29BMXE5SVY0SHUwIiwiaWQiOiIxSnd6cFVmam9QR29BMXE5SVY0SHUwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNyeWluJyIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxSnd6cFVmam9QR29BMXE5SVY0SHUwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdFeTRQRDRNWXNLYzVJMmRvbFV3YkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsImlkIjoiN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsIm5hbWUiOiJBZXJvc21pdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJVaHlXZ2lGYjFaREIxcDBVeWxqZDQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yVWh5V2dpRmIxWkRCMXAwVXlsamQ0IiwiaWQiOiIyVWh5V2dpRmIxWkRCMXAwVXlsamQ0IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ZmOTVlZGIzMzgyNjMyYTc1NjVlZjk1MyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmZjk1ZWRiMzM4MjYzMmE3NTY1ZWY5NTMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWZmOTVlZGIzMzgyNjMyYTc1NjVlZg==", + "OTUzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvdWdoIExvdmU6IEJlc3QgT2YgVGhlIEJhbGxhZHMgKEludGVybmF0aW9uYWwgVmVyc2lvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MlVoeVdnaUZiMVpEQjFwMFV5bGpkNCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdFeTRQRDRNWXNLYzVJMmRvbFV3YkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsImlkIjoiN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsIm5hbWUiOiJBZXJvc21pdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDc5NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0lSMTAwMDA0MzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzE2WUZTWTBWTTkxUWtESldlQzU1VkwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xNllGU1kwVk05MVFrREpXZUM1NVZMIiwiaWQiOiIxNllGU1kwVk05MVFrREpXZUM1NVZMIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNyeWluJyIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxNllGU1kwVk05MVFrREpXZUM1NVZMIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdFeTRQRDRNWXNLYzVJMmRvbFV3YkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsImlkIjoiN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCIsIm5hbWUiOiJBZXJvc21pdGgiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzV6dFpkQWZmVHZOSnpYQUJKOFMwUkMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81enRaZEFmZlR2Tkp6WEFCSjhTMFJDIiwiaWQiOg==", + "IjV6dFpkQWZmVHZOSnpYQUJKOFMwUkMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODZkNDY3ZWM3M2FlYWFmOGM5Y2Q1MzMyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjg2ZDQ2N2VjNzNhZWFhZjhjOWNkNTMzMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODZkNDY3ZWM3M2FlYWFmOGM5Y2Q1MzMyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBWZXJ5IEJlc3QgT2YgQWVyb3NtaXRoOiBEZXZpbCdzIEdvdCBBIE5ldyBEaXNndWlzZSIsInJlbGVhc2VfZGF0ZSI6IjIwMDYtMTAtMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1enRaZEFmZlR2Tkp6WEFCSjhTMFJDIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwiaWQiOiI3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwibmFtZSI6IkFlcm9zbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwODYzOSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSVIxMDAwMDQzMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNTllUWphZ2U2elg3M3BhUDBxck5TdCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzU5ZVFqYWdlNnpYNzNwYVAwcXJOU3QiLCJpZCI6IjU5ZVFqYWdlNnpYNzNwYVAwcXJOU3QiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ3J5aW4nIiwidHJhY2tfbnVtYmVyIjoxNCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1OWVRamFnZTZ6WDczcGFQMHFyTlN0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Ig==", + "aHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNmpybHlvdVNMOFBRMUttQlE2Vkp4dyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZqcmx5b3VTTDhQUTFLbUJRNlZKeHciLCJpZCI6IjZqcmx5b3VTTDhQUTFLbUJRNlZKeHciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZGYxNGJhZGUyMWU5NTIwZDUwZjNlNjBkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmRmMTRiYWRlMjFlOTUyMGQ1MGYzZTYwZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZGYxNGJhZGUyMWU5NTIwZDUwZjNlNjBkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvY2sgQW50aGVtcyIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDQtMjQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2anJseW91U0w4UFExS21CUTZWSnh3In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0V5NFBENE1Zc0tjNUkyZG9sVXdiSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwiaWQiOiI3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIiwibmFtZSI6IkFlcm9zbWl0aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3RXk0UEQ0TVlzS2M1STJkb2xVd2JIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwODMzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSVIxMDAwMDQzMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUczaDRZczBjeUtEOXplS2NlcW8zQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFHM2g0WXMwY3lLRDl6ZUtjZXFvM0EiLCJpZCI6IjFHM2g0WQ==", + "czBjeUtEOXplS2NlcW8zQSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDcnlpbiciLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUczaDRZczBjeUtEOXplS2NlcW8zQSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Cryin%27%22+artist%3A%22Aerosmith%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Semi-Charmed%20Life%22%20artist%3A%22Third%20Eye%20Blind%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"external_urls":{"spotify":"https://open.spotify.com/album/2gToC0XAblE9h3UZD6aAaQ"},"href":"https://api.spotify.com/v1/albums/2gToC0XAblE9h3UZD6aAaQ","id":"2gToC0XAblE9h3UZD6aAaQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730c12ef918102b8d303dc9e9b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020c12ef918102b8d303dc9e9b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510c12ef918102b8d303dc9e9b"}],"is_playable":true,"name":"Third Eye Blind","release_date":"1997-04-08","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:2gToC0XAblE9h3UZD6aAaQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"disc_number":1,"duration_ms":268360,"explicit":false,"external_ids":{"isrc":"USEE19701203"},"external_urls":{"spotify":"https://open.spotify.com/track/42et6fnHCw1HIPSrdPprMl"},"href":"https://api.spotify.com/v1/tracks/42et6fnHCw1HIPSrdPprMl","id":"42et6fnHCw1HIPSrdPprMl","is_local":false,"is_playable":true,"name":"Semi-Charmed Life","track_number":3,"type":"track","uri":"spotify:track:42et6fnHCw1HIPSrdPprMl"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"external_urls":{"spotify":"https://open.spotify.com/album/5xf0RspeeHBh6hXsnPRzuX"},"href":"https://api.spotify.com/v1/albums/5xf0RspeeHBh6hXsnPRzuX","id":"5xf0RspeeHBh6hXsnPRzuX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27325d1260def08acd1cdb1a6f9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0225d1260def08acd1cdb1a6f9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485125d1260def08acd1cdb1a6f9"}],"is_playable":true,"name":"A Collection","release_date":"2006-07-18","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:5xf0RspeeHBh6hXsnPRzuX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"disc_number":1,"duration_ms":268640,"explicit":false,"external_ids":{"isrc":"USEE10608087"},"external_urls":{"spotify":"https://open.spotify.com/track/4XGdSnLIlE9BqySbTWxf7r"},"href":"https://api.spotify.com/v1/tracks/4XGdSnLIlE9BqySbTWxf7r","id":"4XGdSnLIlE9BqySbTWxf7r","is_local":false,"is_playable":true,"name":"Semi-Charmed Life - 2006 Remaster","track_number":1,"type":"track","uri":"spotify:track:4XGdSnLIlE9BqySbTWxf7r"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1cqv7joIiSKvaqvnMwHpw5"},"href":"https://api.spotify.com/v1/albums/1cqv7joIiSKvaqvnMwHpw5","id":"1cqv7joIiSKvaqvnMwHpw5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273127550f781b29842aa559c0a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02127550f781b29842aa559c0a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851127550f781b29842aa559c0a"}],"is_playable":true,"name":"Playlist: Rock","release_date":"2019-04-12","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:1cqv7joIiSKvaqvnMwHpw5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"disc_number":1,"duration_ms":268640,"explicit":false,"external_ids":{"isrc":"USEE10608087"},"external_urls":{"spotify":"https://open.spotify.com/track/3lc9WwdotE2ThL0IHq230T"},"href":"https://api.spotify.com/v1/tracks/3lc9WwdotE2ThL0IHq230T","id":"3lc9WwdotE2ThL0IHq230T","is_local":false,"is_playable":true,"name":"Semi-Charmed Life - 2006 Remaster","track_number":29,"type":"track","uri":"spotify:track:3lc9WwdotE2ThL0IHq230T"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6vX7nVUJGWP8BfLBAKLI0K"},"href":"https://api.spotify.com/v1/albums/6vX7nVUJGWP8BfLBAKLI0K","id":"6vX7nVUJGWP8BfLBAKLI0K","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733f77cd9f41c52613e7596b83"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023f77cd9f41c52613e7596b83"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513f77cd9f41c52613e7596b83"}],"is_playable":true,"name":"Movie Rock Hits","release_date":"2020-03-20","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:6vX7nVUJGWP8BfLBAKLI0K"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"disc_number":1,"duration_ms":268360,"explicit":false,"external_ids":{"isrc":"USEE19701203"},"external_urls":{"spotify":"https://open.spotify.com/track/010mCBOhXE20EcB5FOKzt0"},"href":"https://api.spotify.com/v1/tracks/010mCBOhXE20EcB5FOKzt0","id":"010mCBOhXE20EcB5FOKzt0","is_local":false,"is_playable":true,"name":"Semi-Charmed Life","track_number":4,"type":"track","uri":"spotify:track:010mCBOhXE20EcB5FOKzt0"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3D5BaRZxngDIZP811L4p1N"},"href":"https://api.spotify.com/v1/albums/3D5BaRZxngDIZP811L4p1N","id":"3D5BaRZxngDIZP811L4p1N","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273709b8d3bc3c18372eceebede"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02709b8d3bc3c18372eceebede"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851709b8d3bc3c18372eceebede"}],"is_playable":true,"name":"100 Greatest Driving Songs","release_date":"2022-08-19","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:3D5BaRZxngDIZP811L4p1N"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"disc_number":1,"duration_ms":268360,"explicit":false,"external_ids":{"isrc":"USEE19701203"},"external_urls":{"spotify":"https://open.spotify.com/track/6FFRVEo6HMdSCbnq4yvC9l"},"href":"https://api.spotify.com/v1/tracks/6FFRVEo6HMdSCbnq4yvC9l","id":"6FFRVEo6HMdSCbnq4yvC9l","is_local":false,"is_playable":true,"name":"Semi-Charmed Life","track_number":13,"type":"track","uri":"spotify:track:6FFRVEo6HMdSCbnq4yvC9l"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"external_urls":{"spotify":"https://open.spotify.com/album/1aNdNrl6qVlgh3YJLRklWj"},"href":"https://api.spotify.com/v1/albums/1aNdNrl6qVlgh3YJLRklWj","id":"1aNdNrl6qVlgh3YJLRklWj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27389b063c1a8f96d1dc0271f8c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0289b063c1a8f96d1dc0271f8c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485189b063c1a8f96d1dc0271f8c"}],"is_playable":true,"name":"The Third Eye Blind Collection","release_date":"2013-11-11","release_date_precision":"day","total_tracks":41,"type":"album","uri":"spotify:album:1aNdNrl6qVlgh3YJLRklWj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"disc_number":1,"duration_ms":268360,"explicit":false,"external_ids":{"isrc":"USEE19701203"},"external_urls":{"spotify":"https://open.spotify.com/track/2KUXfKopU8tHX5ynlhK9OS"},"href":"https://api.spotify.com/v1/tracks/2KUXfKopU8tHX5ynlhK9OS","id":"2KUXfKopU8tHX5ynlhK9OS","is_local":false,"is_playable":true,"name":"Semi-Charmed Life","track_number":3,"type":"track","uri":"spotify:track:2KUXfKopU8tHX5ynlhK9OS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1xlgEfvPidAnZW7aiVTa8y"},"href":"https://api.spotify.com/v1/albums/1xlgEfvPidAnZW7aiVTa8y","id":"1xlgEfvPidAnZW7aiVTa8y","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738cfea94dd282e290bcdf3cb6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028cfea94dd282e290bcdf3cb6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518cfea94dd282e290bcdf3cb6"}],"is_playable":true,"name":"Jaren 80 en 90","release_date":"2020-11-20","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:1xlgEfvPidAnZW7aiVTa8y"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"disc_number":1,"duration_ms":268640,"explicit":false,"external_ids":{"isrc":"USEE10608087"},"external_urls":{"spotify":"https://open.spotify.com/track/3soV1lTZWmlfOdtMo2b4yr"},"href":"https://api.spotify.com/v1/tracks/3soV1lTZWmlfOdtMo2b4yr","id":"3soV1lTZWmlfOdtMo2b4yr","is_local":false,"is_playable":true,"name":"Semi-Charmed Life","track_number":41,"type":"track","uri":"spotify:track:3soV1lTZWmlfOdtMo2b4yr"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2PImfuQ8ZF9U0TRTYPTbtD"},"href":"https://api.spotify.com/v1/albums/2PImfuQ8ZF9U0TRTYPTbtD","id":"2PImfuQ8ZF9U0TRTYPTbtD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737feaf31f2afb8ebc7de19341"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027feaf31f2afb8ebc7de19341"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517feaf31f2afb8ebc7de19341"}],"is_playable":true,"name":"90s Hits - Best 90s Music","release_date":"2024-10-31","release_date_precision":"day","total_tracks":70,"type":"album","uri":"spotify:album:2PImfuQ8ZF9U0TRTYPTbtD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6TcnmlCSxihzWOQJ8k0rNS"},"href":"https://api.spotify.com/v1/artists/6TcnmlCSxihzWOQJ8k0rNS","id":"6TcnmlCSxihzWOQJ8k0rNS","name":"Third Eye Blind","type":"artist","uri":"spotify:artist:6TcnmlCSxihzWOQJ8k0rNS"}],"disc_number":1,"duration_ms":268640,"explicit":false,"external_ids":{"isrc":"USEE10608087"},"external_urls":{"spotify":"https://open.spotify.com/track/1dScOil8YIiHS5DaPRGl6y"},"href":"https://api.spotify.com/v1/tracks/1dScOil8YIiHS5DaPRGl6y","id":"1dScOil8YIiHS5DaPRGl6y","is_local":false,"is_playable":true,"name":"Semi-charmed Life - 2006 Remaster","track_number":6,"type":"track","uri":"spotify:track:1dScOil8YIiHS5DaPRGl6y"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNlbWktQ2hhcm1lZCUyMExpZmUlMjIlMjBhcnRpc3QlM0ElMjJUaGlyZCUyMEV5ZSUyMEJsaW5kJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo4LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82VGNubWxDU3hpaHpXT1FKOGswck5TIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZUY25tbENTeGloeldPUUo4azByTlMiLCJpZCI6IjZUY25tbENTeGloeldPUUo4azByTlMiLCJuYW1lIjoiVGhpcmQgRXllIEJsaW5kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZUY25tbENTeGloeldPUUo4azByTlMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yZ1RvQzBYQWJsRTloM1VaRDZhQWFRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMmdUb0MwWEFibEU5aDNVWkQ2YUFhUSIsImlkIjoiMmdUb0MwWEFibEU5aDNVWkQ2YUFhUSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwYzEyZWY5MTgxMDJiOGQzMDNkYzllOWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGMxMmVmOTE4MTAyYjhkMzAzZGM5ZTliIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwYzEyZWY5MTgxMDJiOGQzMDNkYzllOWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhpcmQgRXllIEJsaW5kIiwicmVsZWFzZV9kYXRlIjoiMTk5Ny0wNC0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJnVG9DMFhBYmxFOWgzVVpENmFBYVEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82VGNubWxDU3hpaHpXT1FKOGswck5TIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZUY25tbENTeGloeldPUUo4azByTlMiLCJpZCI6IjZUY25tbENTeGloeldPUUo4azByTlMiLCJuYW1lIjoiVGhpcmQgRXllIEJsaW5kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZUY25tbENTeGloeldPUUo4azByTlMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY4MzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNFRTE5NzAxMjAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80MmV0NmZuSEN3MUhJUFNyZFBwck1sIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDJldDZmbkhDdzFISVBTcmRQcHJNbCIsImlkIjoiNDJldDZmbkhDdzFISVBTcmRQcHJNbCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTZW1pLUNoYXJtZWQgTGlmZSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0MmV0NmZuSEN3MUhJUFNyZFBwck1sIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZUY25tbENTeGloeldPUUo4azByTlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsImlkIjoiNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsIm5hbWUiOg==", + "IlRoaXJkIEV5ZSBCbGluZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2VGNubWxDU3hpaHpXT1FKOGswck5TIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNXhmMFJzcGVlSEJoNmhYc25QUnp1WCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzV4ZjBSc3BlZUhCaDZoWHNuUFJ6dVgiLCJpZCI6IjV4ZjBSc3BlZUhCaDZoWHNuUFJ6dVgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjVkMTI2MGRlZjA4YWNkMWNkYjFhNmY5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI1ZDEyNjBkZWYwOGFjZDFjZGIxYTZmOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjVkMTI2MGRlZjA4YWNkMWNkYjFhNmY5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkEgQ29sbGVjdGlvbiIsInJlbGVhc2VfZGF0ZSI6IjIwMDYtMDctMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1eGYwUnNwZWVIQmg2aFhzblBSenVYIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82VGNubWxDU3hpaHpXT1FKOGswck5TIiwiaWQiOiI2VGNubWxDU3hpaHpXT1FKOGswck5TIiwibmFtZSI6IlRoaXJkIEV5ZSBCbGluZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2VGNubWxDU3hpaHpXT1FKOGswck5TIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2ODY0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRUUxMDYwODA4NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFhHZFNuTElsRTlCcXlTYlRXeGY3ciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRYR2RTbkxJbEU5QnF5U2JUV3hmN3IiLCJpZCI6IjRYR2RTbkxJbEU5QnF5U2JUV3hmN3IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2VtaS1DaGFybWVkIExpZmUgLSAyMDA2IFJlbQ==", + "YXN0ZXIiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFhHZFNuTElsRTlCcXlTYlRXeGY3ciJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xY3F2N2pvSWlTS3ZhcXZuTXdIcHc1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWNxdjdqb0lpU0t2YXF2bk13SHB3NSIsImlkIjoiMWNxdjdqb0lpU0t2YXF2bk13SHB3NSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxMjc1NTBmNzgxYjI5ODQyYWE1NTljMGEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTI3NTUwZjc4MWIyOTg0MmFhNTU5YzBhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExMjc1NTBmNzgxYjI5ODQyYWE1NTljMGEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUGxheWxpc3Q6IFJvY2siLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA0LTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MWNxdjdqb0lpU0t2YXF2bk13SHB3NSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZUY25tbENTeGloeldPUUo4azByTlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsImlkIjoiNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsIm5hbWUiOiJUaGlyZCBFeWUgQmxpbmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlRjbm1sQ1N4aWh6V09RSjhrMHJOUyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cg==", + "YXRpb25fbXMiOjI2ODY0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRUUxMDYwODA4NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2xjOVd3ZG90RTJUaEwwSUhxMjMwVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNsYzlXd2RvdEUyVGhMMElIcTIzMFQiLCJpZCI6IjNsYzlXd2RvdEUyVGhMMElIcTIzMFQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2VtaS1DaGFybWVkIExpZmUgLSAyMDA2IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjoyOSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozbGM5V3dkb3RFMlRoTDBJSHEyMzBUIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZ2WDduVlVKR1dQOEJmTEJBS0xJMEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82dlg3blZVSkdXUDhCZkxCQUtMSTBLIiwiaWQiOiI2dlg3blZVSkdXUDhCZkxCQUtMSTBLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzNmNzdjZDlmNDFjNTI2MTNlNzU5NmI4MyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzZjc3Y2Q5ZjQxYzUyNjEzZTc1OTZiODMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTNmNzdjZDlmNDFjNTI2MTNlNzU5NmI4MyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb3ZpZSBSb2NrIEhpdHMiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTAzLTIwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Ng==", + "dlg3blZVSkdXUDhCZkxCQUtMSTBLIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82VGNubWxDU3hpaHpXT1FKOGswck5TIiwiaWQiOiI2VGNubWxDU3hpaHpXT1FKOGswck5TIiwibmFtZSI6IlRoaXJkIEV5ZSBCbGluZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2VGNubWxDU3hpaHpXT1FKOGswck5TIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2ODM2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRUUxOTcwMTIwMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMDEwbUNCT2hYRTIwRWNCNUZPS3p0MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzAxMG1DQk9oWEUyMEVjQjVGT0t6dDAiLCJpZCI6IjAxMG1DQk9oWEUyMEVjQjVGT0t6dDAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2VtaS1DaGFybWVkIExpZmUiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MDEwbUNCT2hYRTIwRWNCNUZPS3p0MCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zRDVCYVJaeG5nRElaUDgxMUw0cDFOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0Q1QmFSWnhuZ0RJWlA4MTFMNHAxTiIsImlkIjoiM0Q1QmFSWnhuZ0RJWlA4MTFMNHAxTiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3MDliOGQzYmMzYzE4MzcyZWNlZWJlZGUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbg==", + "LmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3MDliOGQzYmMzYzE4MzcyZWNlZWJlZGUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTcwOWI4ZDNiYzNjMTgzNzJlY2VlYmVkZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiIxMDAgR3JlYXRlc3QgRHJpdmluZyBTb25ncyIsInJlbGVhc2VfZGF0ZSI6IjIwMjItMDgtMTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M0Q1QmFSWnhuZ0RJWlA4MTFMNHAxTiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZUY25tbENTeGloeldPUUo4azByTlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsImlkIjoiNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsIm5hbWUiOiJUaGlyZCBFeWUgQmxpbmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlRjbm1sQ1N4aWh6V09RSjhrMHJOUyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjgzNjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0VFMTk3MDEyMDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZGRlJWRW82SE1kU0NibnE0eXZDOWwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82RkZSVkVvNkhNZFNDYm5xNHl2QzlsIiwiaWQiOiI2RkZSVkVvNkhNZFNDYm5xNHl2QzlsIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNlbWktQ2hhcm1lZCBMaWZlIiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2RkZSVkVvNkhNZFNDYm5xNHl2QzlsIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZUY25tbENTeGloeldPUUo4azByTlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsImlkIjoiNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsIm5hbWUiOiJUaGlyZCBFeWUgQmxpbmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlRjbm1sQ1N4aWh6V09RSjhrMHJOUyJ9XSwiZXh0ZXJuYWxfdXJscw==", + "Ijp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMWFOZE5ybDZxVmxnaDNZSkxSa2xXaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFhTmROcmw2cVZsZ2gzWUpMUmtsV2oiLCJpZCI6IjFhTmROcmw2cVZsZ2gzWUpMUmtsV2oiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODliMDYzYzFhOGY5NmQxZGMwMjcxZjhjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjg5YjA2M2MxYThmOTZkMWRjMDI3MWY4YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODliMDYzYzFhOGY5NmQxZGMwMjcxZjhjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBUaGlyZCBFeWUgQmxpbmQgQ29sbGVjdGlvbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMTEtMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxYU5kTnJsNnFWbGdoM1lKTFJrbFdqIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82VGNubWxDU3hpaHpXT1FKOGswck5TIiwiaWQiOiI2VGNubWxDU3hpaHpXT1FKOGswck5TIiwibmFtZSI6IlRoaXJkIEV5ZSBCbGluZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2VGNubWxDU3hpaHpXT1FKOGswck5TIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2ODM2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRUUxOTcwMTIwMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMktVWGZLb3BVOHRIWDV5bmxoSzlPUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJLVVhmS29wVTh0SFg1eW5saEs5T1MiLCJpZCI6IjJLVVhmS29wVTh0SFg1eW5saEs5T1MiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2VtaS1DaGFybWVkIExpZmUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MktVWGZLb3BVOHRIWDV5bmxoSzlPUyJ9LHsiYWxidW0iOg==", + "eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzF4bGdFZnZQaWRBblpXN2FpVlRhOHkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xeGxnRWZ2UGlkQW5aVzdhaVZUYTh5IiwiaWQiOiIxeGxnRWZ2UGlkQW5aVzdhaVZUYTh5IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzhjZmVhOTRkZDI4MmUyOTBiY2RmM2NiNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4Y2ZlYTk0ZGQyODJlMjkwYmNkZjNjYjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MThjZmVhOTRkZDI4MmUyOTBiY2RmM2NiNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJKYXJlbiA4MCBlbiA5MCIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTEtMjAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXhsZ0VmdlBpZEFuWlc3YWlWVGE4eSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZUY25tbENTeGloeldPUUo4azByTlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsImlkIjoiNlRjbm1sQ1N4aWh6V09RSjhrMHJOUyIsIm5hbWUiOiJUaGlyZCBFeWUgQmxpbmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlRjbm1sQ1N4aWh6V09RSjhrMHJOUyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjg2NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0VFMTA2MDgwODcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcA==", + "b3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM3NvVjFsVFpXbWxmT2R0TW8yYjR5ciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNzb1YxbFRaV21sZk9kdE1vMmI0eXIiLCJpZCI6IjNzb1YxbFRaV21sZk9kdE1vMmI0eXIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2VtaS1DaGFybWVkIExpZmUiLCJ0cmFja19udW1iZXIiOjQxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNzb1YxbFRaV21sZk9kdE1vMmI0eXIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlBJbWZ1UThaRjlVMFRSVFlQVGJ0RCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJQSW1mdVE4WkY5VTBUUlRZUFRidEQiLCJpZCI6IjJQSW1mdVE4WkY5VTBUUlRZUFRidEQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2ZlYWYzMWYyYWZiOGViYzdkZTE5MzQxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdmZWFmMzFmMmFmYjhlYmM3ZGUxOTM0MSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2ZlYWYzMWYyYWZiOGViYzdkZTE5MzQxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjkwcyBIaXRzIC0gQmVzdCA5MHMgTXVzaWMiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTEwLTMxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NzAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MlBJbWZ1UThaRjlVMFRSVFlQVGJ0RCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZUYw==", + "bm1sQ1N4aWh6V09RSjhrMHJOUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82VGNubWxDU3hpaHpXT1FKOGswck5TIiwiaWQiOiI2VGNubWxDU3hpaHpXT1FKOGswck5TIiwibmFtZSI6IlRoaXJkIEV5ZSBCbGluZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2VGNubWxDU3hpaHpXT1FKOGswck5TIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2ODY0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTRUUxMDYwODA4NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMWRTY09pbDhZSWlIUzVEYVBSR2w2eSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFkU2NPaWw4WUlpSFM1RGFQUkdsNnkiLCJpZCI6IjFkU2NPaWw4WUlpSFM1RGFQUkdsNnkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2VtaS1jaGFybWVkIExpZmUgLSAyMDA2IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFkU2NPaWw4WUlpSFM1RGFQUkdsNnkifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Semi-Charmed+Life%22+artist%3A%22Third+Eye+Blind%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Torn%22%20artist%3A%22Natalie%20Imbruglia%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":6,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"external_urls":{"spotify":"https://open.spotify.com/album/38alWeQVP9UUAGJvLptys9"},"href":"https://api.spotify.com/v1/albums/38alWeQVP9UUAGJvLptys9","id":"38alWeQVP9UUAGJvLptys9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27384bb2b1e87d5ba0bac8871a2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0284bb2b1e87d5ba0bac8871a2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485184bb2b1e87d5ba0bac8871a2"}],"is_playable":true,"name":"Left Of The Middle","release_date":"1997-11-10","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:38alWeQVP9UUAGJvLptys9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"disc_number":1,"duration_ms":244666,"explicit":false,"external_ids":{"isrc":"GBARL9700412"},"external_urls":{"spotify":"https://open.spotify.com/track/1Jaah2tmN9Hv81A87KZ1MU"},"href":"https://api.spotify.com/v1/tracks/1Jaah2tmN9Hv81A87KZ1MU","id":"1Jaah2tmN9Hv81A87KZ1MU","is_local":false,"is_playable":true,"name":"Torn","track_number":1,"type":"track","uri":"spotify:track:1Jaah2tmN9Hv81A87KZ1MU"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"external_urls":{"spotify":"https://open.spotify.com/album/6HOvWskl058duikMCVOLcW"},"href":"https://api.spotify.com/v1/albums/6HOvWskl058duikMCVOLcW","id":"6HOvWskl058duikMCVOLcW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27309ad93f3253de551558a73ab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0209ad93f3253de551558a73ab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485109ad93f3253de551558a73ab"}],"is_playable":true,"name":"Left Of The Middle","release_date":"1998-01-08","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:6HOvWskl058duikMCVOLcW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"disc_number":1,"duration_ms":244666,"explicit":false,"external_ids":{"isrc":"GBARL9700412"},"external_urls":{"spotify":"https://open.spotify.com/track/0KDaN0HL3TcJVTbXlQCEsS"},"href":"https://api.spotify.com/v1/tracks/0KDaN0HL3TcJVTbXlQCEsS","id":"0KDaN0HL3TcJVTbXlQCEsS","is_local":false,"is_playable":true,"name":"Torn","track_number":1,"type":"track","uri":"spotify:track:0KDaN0HL3TcJVTbXlQCEsS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"external_urls":{"spotify":"https://open.spotify.com/album/1aUCcefKzau4WzNASbg3mM"},"href":"https://api.spotify.com/v1/albums/1aUCcefKzau4WzNASbg3mM","id":"1aUCcefKzau4WzNASbg3mM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27329cb945999d6dff885601e57"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0229cb945999d6dff885601e57"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485129cb945999d6dff885601e57"}],"is_playable":true,"name":"Glorious: The Singles 97-07","release_date":"2007-09-10","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:1aUCcefKzau4WzNASbg3mM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"disc_number":1,"duration_ms":244813,"explicit":false,"external_ids":{"isrc":"GBARL9700412"},"external_urls":{"spotify":"https://open.spotify.com/track/0E5dnEMvy9yEpRqZ8OjT7F"},"href":"https://api.spotify.com/v1/tracks/0E5dnEMvy9yEpRqZ8OjT7F","id":"0E5dnEMvy9yEpRqZ8OjT7F","is_local":false,"is_playable":true,"name":"Torn","track_number":3,"type":"track","uri":"spotify:track:0E5dnEMvy9yEpRqZ8OjT7F"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6odcotWv2xd7NP7RrGBS5b"},"href":"https://api.spotify.com/v1/albums/6odcotWv2xd7NP7RrGBS5b","id":"6odcotWv2xd7NP7RrGBS5b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b212e660aec81b60a425d4f1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b212e660aec81b60a425d4f1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b212e660aec81b60a425d4f1"}],"is_playable":true,"name":"90s 100 Hits","release_date":"2014-11-28","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:6odcotWv2xd7NP7RrGBS5b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"disc_number":1,"duration_ms":244813,"explicit":false,"external_ids":{"isrc":"GBARL9700412"},"external_urls":{"spotify":"https://open.spotify.com/track/3xP9zsXKIpPIYBo2MZKMMV"},"href":"https://api.spotify.com/v1/tracks/3xP9zsXKIpPIYBo2MZKMMV","id":"3xP9zsXKIpPIYBo2MZKMMV","is_local":false,"is_playable":true,"name":"Torn","track_number":43,"type":"track","uri":"spotify:track:3xP9zsXKIpPIYBo2MZKMMV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"external_urls":{"spotify":"https://open.spotify.com/album/51jPYbDLNrkkc9DisBoSIo"},"href":"https://api.spotify.com/v1/albums/51jPYbDLNrkkc9DisBoSIo","id":"51jPYbDLNrkkc9DisBoSIo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733962a1999d943f694ac5e8b7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023962a1999d943f694ac5e8b7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513962a1999d943f694ac5e8b7"}],"is_playable":true,"name":"Left Of The Middle","release_date":"1997-11-24","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:51jPYbDLNrkkc9DisBoSIo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"disc_number":1,"duration_ms":244666,"explicit":false,"external_ids":{"isrc":"GBARL9700412"},"external_urls":{"spotify":"https://open.spotify.com/track/2HXSjnfVfBtc1kKawVhSd7"},"href":"https://api.spotify.com/v1/tracks/2HXSjnfVfBtc1kKawVhSd7","id":"2HXSjnfVfBtc1kKawVhSd7","is_local":false,"is_playable":true,"name":"Torn","track_number":1,"type":"track","uri":"spotify:track:2HXSjnfVfBtc1kKawVhSd7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"external_urls":{"spotify":"https://open.spotify.com/album/1p1ZcTuiwQqh5RQmei6R6I"},"href":"https://api.spotify.com/v1/albums/1p1ZcTuiwQqh5RQmei6R6I","id":"1p1ZcTuiwQqh5RQmei6R6I","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27353f9aa2f017eaa2309d8ed87"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0253f9aa2f017eaa2309d8ed87"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485153f9aa2f017eaa2309d8ed87"}],"is_playable":true,"name":"Left of the Middle","release_date":"1997-12-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1p1ZcTuiwQqh5RQmei6R6I"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0dlOr0VIysztGWvU1dpjmP"},"href":"https://api.spotify.com/v1/artists/0dlOr0VIysztGWvU1dpjmP","id":"0dlOr0VIysztGWvU1dpjmP","name":"Natalie Imbruglia","type":"artist","uri":"spotify:artist:0dlOr0VIysztGWvU1dpjmP"}],"disc_number":1,"duration_ms":244933,"explicit":false,"external_ids":{"isrc":"GBARL9700412"},"external_urls":{"spotify":"https://open.spotify.com/track/0tQMg8pVBMS0ii2o3we06F"},"href":"https://api.spotify.com/v1/tracks/0tQMg8pVBMS0ii2o3we06F","id":"0tQMg8pVBMS0ii2o3we06F","is_local":false,"is_playable":true,"name":"Torn","track_number":1,"type":"track","uri":"spotify:track:0tQMg8pVBMS0ii2o3we06F"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRvcm4lMjIlMjBhcnRpc3QlM0ElMjJOYXRhbGllJTIwSW1icnVnbGlhJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo2LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZGxPcjBWSXlzenRHV3ZVMWRwam1QIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBkbE9yMFZJeXN6dEdXdlUxZHBqbVAiLCJpZCI6IjBkbE9yMFZJeXN6dEdXdlUxZHBqbVAiLCJuYW1lIjoiTmF0YWxpZSBJbWJydWdsaWEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGRsT3IwVkl5c3p0R1d2VTFkcGptUCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzM4YWxXZVFWUDlVVUFHSnZMcHR5czkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zOGFsV2VRVlA5VVVBR0p2THB0eXM5IiwiaWQiOiIzOGFsV2VRVlA5VVVBR0p2THB0eXM5IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNj", + "ZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzg0YmIyYjFlODdkNWJhMGJhYzg4NzFhMiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4NGJiMmIxZTg3ZDViYTBiYWM4ODcxYTIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTg0YmIyYjFlODdkNWJhMGJhYzg4NzFhMiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMZWZ0IE9mIFRoZSBNaWRkbGUiLCJyZWxlYXNlX2RhdGUiOiIxOTk3LTExLTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MzhhbFdlUVZQOVVVQUdKdkxwdHlzOSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBkbE9yMFZJeXN6dEdXdlUxZHBqbVAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsImlkIjoiMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsIm5hbWUiOiJOYXRhbGllIEltYnJ1Z2xpYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZGxPcjBWSXlzenRHV3ZVMWRwam1QIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NDY2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQVJMOTcwMDQxMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUphYWgydG1OOUh2ODFBODdLWjFNVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFKYWFoMnRtTjlIdjgxQTg3S1oxTVUiLCJpZCI6IjFKYWFoMnRtTjlIdjgxQTg3S1oxTVUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVG9ybiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxSmFhaDJ0bU45SHY4MUE4N0taMU1VIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBkbE9yMFZJeXN6dEdXdlUxZHBqbVAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsImlkIjoiMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsIm5hbWUiOiJOYXRhbGllIEltYnJ1Z2xpYSIsIg==", + "dHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBkbE9yMFZJeXN6dEdXdlUxZHBqbVAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82SE92V3NrbDA1OGR1aWtNQ1ZPTGNXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNkhPdldza2wwNThkdWlrTUNWT0xjVyIsImlkIjoiNkhPdldza2wwNThkdWlrTUNWT0xjVyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwOWFkOTNmMzI1M2RlNTUxNTU4YTczYWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDlhZDkzZjMyNTNkZTU1MTU1OGE3M2FiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwOWFkOTNmMzI1M2RlNTUxNTU4YTczYWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGVmdCBPZiBUaGUgTWlkZGxlIiwicmVsZWFzZV9kYXRlIjoiMTk5OC0wMS0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZIT3ZXc2tsMDU4ZHVpa01DVk9MY1cifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZGxPcjBWSXlzenRHV3ZVMWRwam1QIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBkbE9yMFZJeXN6dEdXdlUxZHBqbVAiLCJpZCI6IjBkbE9yMFZJeXN6dEdXdlUxZHBqbVAiLCJuYW1lIjoiTmF0YWxpZSBJbWJydWdsaWEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGRsT3IwVkl5c3p0R1d2VTFkcGptUCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDQ2NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFSTDk3MDA0MTIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBLRGFOMEhMM1RjSlZUYlhsUUNFc1MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wS0RhTjBITDNUY0pWVGJYbFFDRXNTIiwiaWQiOiIwS0RhTjBITDNUY0pWVGJYbFFDRXNTIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvcm4iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsIg==", + "dXJpIjoic3BvdGlmeTp0cmFjazowS0RhTjBITDNUY0pWVGJYbFFDRXNTIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBkbE9yMFZJeXN6dEdXdlUxZHBqbVAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsImlkIjoiMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsIm5hbWUiOiJOYXRhbGllIEltYnJ1Z2xpYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZGxPcjBWSXlzenRHV3ZVMWRwam1QIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMWFVQ2NlZkt6YXU0V3pOQVNiZzNtTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFhVUNjZWZLemF1NFd6TkFTYmczbU0iLCJpZCI6IjFhVUNjZWZLemF1NFd6TkFTYmczbU0iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjljYjk0NTk5OWQ2ZGZmODg1NjAxZTU3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI5Y2I5NDU5OTlkNmRmZjg4NTYwMWU1NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjljYjk0NTk5OWQ2ZGZmODg1NjAxZTU3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ikdsb3Jpb3VzOiBUaGUgU2luZ2xlcyA5Ny0wNyIsInJlbGVhc2VfZGF0ZSI6IjIwMDctMDktMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxYVVDY2VmS3phdTRXek5BU2JnM21NIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGRsT3IwVkl5c3p0R1d2VTFkcGptUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wZGxPcjBWSXlzenRHV3ZVMWRwam1QIiwiaWQiOiIwZGxPcjBWSXlzenRHV3ZVMWRwam1QIiwibmFtZSI6Ik5hdGFsaWUgSW1icnVnbGlhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBkbE9yMFZJeXN6dEdXdlUxZHBqbVAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ0ODEzLCJleHBsaQ==", + "Y2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFSTDk3MDA0MTIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBFNWRuRU12eTl5RXBScVo4T2pUN0YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wRTVkbkVNdnk5eUVwUnFaOE9qVDdGIiwiaWQiOiIwRTVkbkVNdnk5eUVwUnFaOE9qVDdGIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvcm4iLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MEU1ZG5FTXZ5OXlFcFJxWjhPalQ3RiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82b2Rjb3RXdjJ4ZDdOUDdSckdCUzViIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNm9kY290V3YyeGQ3TlA3UnJHQlM1YiIsImlkIjoiNm9kY290V3YyeGQ3TlA3UnJHQlM1YiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiMjEyZTY2MGFlYzgxYjYwYTQyNWQ0ZjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjIxMmU2NjBhZWM4MWI2MGE0MjVkNGYxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiMjEyZTY2MGFlYzgxYjYwYTQyNWQ0ZjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiOTBzIDEwMCBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMjAxNC0xMS0yOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2b2Rjb3RXdjJ4ZDdOUDdSckdCUzViIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsicw==", + "cG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZGxPcjBWSXlzenRHV3ZVMWRwam1QIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBkbE9yMFZJeXN6dEdXdlUxZHBqbVAiLCJpZCI6IjBkbE9yMFZJeXN6dEdXdlUxZHBqbVAiLCJuYW1lIjoiTmF0YWxpZSBJbWJydWdsaWEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGRsT3IwVkl5c3p0R1d2VTFkcGptUCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDQ4MTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFSTDk3MDA0MTIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzN4UDl6c1hLSXBQSVlCbzJNWktNTVYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zeFA5enNYS0lwUElZQm8yTVpLTU1WIiwiaWQiOiIzeFA5enNYS0lwUElZQm8yTVpLTU1WIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvcm4iLCJ0cmFja19udW1iZXIiOjQzLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjN4UDl6c1hLSXBQSVlCbzJNWktNTVYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGRsT3IwVkl5c3p0R1d2VTFkcGptUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wZGxPcjBWSXlzenRHV3ZVMWRwam1QIiwiaWQiOiIwZGxPcjBWSXlzenRHV3ZVMWRwam1QIiwibmFtZSI6Ik5hdGFsaWUgSW1icnVnbGlhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBkbE9yMFZJeXN6dEdXdlUxZHBqbVAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81MWpQWWJETE5ya2tjOURpc0JvU0lvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNTFqUFliRExOcmtrYzlEaXNCb1NJbyIsImlkIjoiNTFqUFliRExOcmtrYzlEaXNCb1NJbyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzOTYyYTE5OTlkOTQzZjY5NGFjNWU4YjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzk2MmExOTk5ZDk0M2Y2OTRhYzVlOGI3In0seyJoZWlnaHQiOjY0LCJ3aQ==", + "ZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTM5NjJhMTk5OWQ5NDNmNjk0YWM1ZThiNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMZWZ0IE9mIFRoZSBNaWRkbGUiLCJyZWxlYXNlX2RhdGUiOiIxOTk3LTExLTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NTFqUFliRExOcmtrYzlEaXNCb1NJbyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBkbE9yMFZJeXN6dEdXdlUxZHBqbVAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsImlkIjoiMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsIm5hbWUiOiJOYXRhbGllIEltYnJ1Z2xpYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZGxPcjBWSXlzenRHV3ZVMWRwam1QIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NDY2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQVJMOTcwMDQxMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMkhYU2puZlZmQnRjMWtLYXdWaFNkNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJIWFNqbmZWZkJ0YzFrS2F3VmhTZDciLCJpZCI6IjJIWFNqbmZWZkJ0YzFrS2F3VmhTZDciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVG9ybiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoySFhTam5mVmZCdGMxa0thd1ZoU2Q3In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBkbE9yMFZJeXN6dEdXdlUxZHBqbVAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsImlkIjoiMGRsT3IwVkl5c3p0R1d2VTFkcGptUCIsIm5hbWUiOiJOYXRhbGllIEltYnJ1Z2xpYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowZGxPcjBWSXlzenRHV3ZVMWRwam1QIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMXAxWmNUdWl3UXFoNVJRbWVpNlI2SSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdA==", + "aWZ5LmNvbS92MS9hbGJ1bXMvMXAxWmNUdWl3UXFoNVJRbWVpNlI2SSIsImlkIjoiMXAxWmNUdWl3UXFoNVJRbWVpNlI2SSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1M2Y5YWEyZjAxN2VhYTIzMDlkOGVkODcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTNmOWFhMmYwMTdlYWEyMzA5ZDhlZDg3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1M2Y5YWEyZjAxN2VhYTIzMDlkOGVkODcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGVmdCBvZiB0aGUgTWlkZGxlIiwicmVsZWFzZV9kYXRlIjoiMTk5Ny0xMi0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFwMVpjVHVpd1FxaDVSUW1laTZSNkkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wZGxPcjBWSXlzenRHV3ZVMWRwam1QIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBkbE9yMFZJeXN6dEdXdlUxZHBqbVAiLCJpZCI6IjBkbE9yMFZJeXN6dEdXdlUxZHBqbVAiLCJuYW1lIjoiTmF0YWxpZSBJbWJydWdsaWEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGRsT3IwVkl5c3p0R1d2VTFkcGptUCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDQ5MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFSTDk3MDA0MTIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzB0UU1nOHBWQk1TMGlpMm8zd2UwNkYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wdFFNZzhwVkJNUzBpaTJvM3dlMDZGIiwiaWQiOiIwdFFNZzhwVkJNUzBpaTJvM3dlMDZGIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvcm4iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHRRTWc4cFZCTVMwaWkybzN3ZTA2RiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Torn%22+artist%3A%22Natalie+Imbruglia%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Ironic%22%20artist%3A%22Alanis%20Morissette%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"external_urls":{"spotify":"https://open.spotify.com/album/4N7LuZYpstQrtcHIoOKzqg"},"href":"https://api.spotify.com/v1/albums/4N7LuZYpstQrtcHIoOKzqg","id":"4N7LuZYpstQrtcHIoOKzqg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d00e49003543a5bb5aa5b873"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d00e49003543a5bb5aa5b873"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d00e49003543a5bb5aa5b873"}],"is_playable":true,"name":"The Collection (Standard Edition)","release_date":"2005-11-11","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:4N7LuZYpstQrtcHIoOKzqg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"disc_number":1,"duration_ms":228573,"explicit":false,"external_ids":{"isrc":"USMV20500296"},"external_urls":{"spotify":"https://open.spotify.com/track/29YBihzQOmat0U74k4ukdx"},"href":"https://api.spotify.com/v1/tracks/29YBihzQOmat0U74k4ukdx","id":"29YBihzQOmat0U74k4ukdx","is_local":false,"is_playable":true,"name":"Ironic","track_number":6,"type":"track","uri":"spotify:track:29YBihzQOmat0U74k4ukdx"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Ap3F8CxjjsQKZGASDcHNA"},"href":"https://api.spotify.com/v1/albums/5Ap3F8CxjjsQKZGASDcHNA","id":"5Ap3F8CxjjsQKZGASDcHNA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273242e643ea07118ecf677a6ef"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02242e643ea07118ecf677a6ef"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851242e643ea07118ecf677a6ef"}],"is_playable":true,"name":"Jagged Little Pill (2015 Remaster)","release_date":"1995","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:5Ap3F8CxjjsQKZGASDcHNA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"disc_number":1,"duration_ms":230000,"explicit":false,"external_ids":{"isrc":"USMV21500010"},"external_urls":{"spotify":"https://open.spotify.com/track/1d6KS9GH06JAd19uiBy9IE"},"href":"https://api.spotify.com/v1/tracks/1d6KS9GH06JAd19uiBy9IE","id":"1d6KS9GH06JAd19uiBy9IE","is_local":false,"is_playable":true,"name":"Ironic - 2015 Remaster","track_number":10,"type":"track","uri":"spotify:track:1d6KS9GH06JAd19uiBy9IE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"external_urls":{"spotify":"https://open.spotify.com/album/6j1k8wmYevBQURQjzl7tCt"},"href":"https://api.spotify.com/v1/albums/6j1k8wmYevBQURQjzl7tCt","id":"6j1k8wmYevBQURQjzl7tCt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27319ecf99afd8f0942c60f255f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0219ecf99afd8f0942c60f255f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485119ecf99afd8f0942c60f255f"}],"is_playable":true,"name":"Jagged Little Pill (25th Anniversary Deluxe Edition)","release_date":"2020-06-26","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:6j1k8wmYevBQURQjzl7tCt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"disc_number":1,"duration_ms":225933,"explicit":false,"external_ids":{"isrc":"USMV29400003"},"external_urls":{"spotify":"https://open.spotify.com/track/0YrqlzPliyMZJ3IN8HbKbW"},"href":"https://api.spotify.com/v1/tracks/0YrqlzPliyMZJ3IN8HbKbW","id":"0YrqlzPliyMZJ3IN8HbKbW","is_local":false,"is_playable":true,"name":"Ironic","track_number":10,"type":"track","uri":"spotify:track:0YrqlzPliyMZJ3IN8HbKbW"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"external_urls":{"spotify":"https://open.spotify.com/album/0VrE5rgQmrasa6Kg7GKqKE"},"href":"https://api.spotify.com/v1/albums/0VrE5rgQmrasa6Kg7GKqKE","id":"0VrE5rgQmrasa6Kg7GKqKE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273572eeb58e8ee977b3658b67f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02572eeb58e8ee977b3658b67f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851572eeb58e8ee977b3658b67f"}],"is_playable":true,"name":"Jagged Little Pill (Collector's Edition)","release_date":"2015-10-30","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:0VrE5rgQmrasa6Kg7GKqKE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"disc_number":1,"duration_ms":230000,"explicit":false,"external_ids":{"isrc":"USMV21500010"},"external_urls":{"spotify":"https://open.spotify.com/track/5Fu0SNxvodqiHkwujDfhTC"},"href":"https://api.spotify.com/v1/tracks/5Fu0SNxvodqiHkwujDfhTC","id":"5Fu0SNxvodqiHkwujDfhTC","is_local":false,"is_playable":true,"name":"Ironic - 2015 Remaster","track_number":10,"type":"track","uri":"spotify:track:5Fu0SNxvodqiHkwujDfhTC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"external_urls":{"spotify":"https://open.spotify.com/album/53PMAZQe9VoLQ3U87SjFkd"},"href":"https://api.spotify.com/v1/albums/53PMAZQe9VoLQ3U87SjFkd","id":"53PMAZQe9VoLQ3U87SjFkd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730dcbdc23276705804e94f958"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020dcbdc23276705804e94f958"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510dcbdc23276705804e94f958"}],"is_playable":true,"name":"Jagged Little Pill (Deluxe Edition)","release_date":"2015-10-30","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:53PMAZQe9VoLQ3U87SjFkd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"disc_number":1,"duration_ms":230000,"explicit":false,"external_ids":{"isrc":"USMV21500010"},"external_urls":{"spotify":"https://open.spotify.com/track/7kJ7ZIYIHh7JFEWReZbcuc"},"href":"https://api.spotify.com/v1/tracks/7kJ7ZIYIHh7JFEWReZbcuc","id":"7kJ7ZIYIHh7JFEWReZbcuc","is_local":false,"is_playable":true,"name":"Ironic - 2015 Remaster","track_number":10,"type":"track","uri":"spotify:track:7kJ7ZIYIHh7JFEWReZbcuc"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"external_urls":{"spotify":"https://open.spotify.com/album/18IXUhJqikhJ0Th7TvmGQ8"},"href":"https://api.spotify.com/v1/albums/18IXUhJqikhJ0Th7TvmGQ8","id":"18IXUhJqikhJ0Th7TvmGQ8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fa12a3d9bcbd9fd71de5804d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fa12a3d9bcbd9fd71de5804d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fa12a3d9bcbd9fd71de5804d"}],"is_playable":true,"name":"Jagged Little Pill","release_date":"1995","release_date_precision":"year","total_tracks":12,"type":"album","uri":"spotify:album:18IXUhJqikhJ0Th7TvmGQ8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"disc_number":1,"duration_ms":227533,"explicit":false,"external_ids":{"isrc":"USMV21500045"},"external_urls":{"spotify":"https://open.spotify.com/track/5T0MnMg35OTjEtBFOe4W6Z"},"href":"https://api.spotify.com/v1/tracks/5T0MnMg35OTjEtBFOe4W6Z","id":"5T0MnMg35OTjEtBFOe4W6Z","is_local":false,"is_playable":true,"name":"Ironic - 2015 Remaster","track_number":10,"type":"track","uri":"spotify:track:5T0MnMg35OTjEtBFOe4W6Z"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"external_urls":{"spotify":"https://open.spotify.com/album/2qBU3ZnUg2OQXiMp4ta4zt"},"href":"https://api.spotify.com/v1/albums/2qBU3ZnUg2OQXiMp4ta4zt","id":"2qBU3ZnUg2OQXiMp4ta4zt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346cd47fe71f8e16f2095c3ec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246cd47fe71f8e16f2095c3ec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146cd47fe71f8e16f2095c3ec"}],"is_playable":true,"name":"Jagged Little Pill (25th Anniversary Deluxe Edition)","release_date":"2020-06-18","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2qBU3ZnUg2OQXiMp4ta4zt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"disc_number":1,"duration_ms":225933,"explicit":false,"external_ids":{"isrc":"USMV29400003"},"external_urls":{"spotify":"https://open.spotify.com/track/1XrzKaChKdDxMlUwbkLuD6"},"href":"https://api.spotify.com/v1/tracks/1XrzKaChKdDxMlUwbkLuD6","id":"1XrzKaChKdDxMlUwbkLuD6","is_local":false,"is_playable":true,"name":"Ironic","track_number":10,"type":"track","uri":"spotify:track:1XrzKaChKdDxMlUwbkLuD6"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6oDBWvVoHYxiAr5PPChA3l"},"href":"https://api.spotify.com/v1/albums/6oDBWvVoHYxiAr5PPChA3l","id":"6oDBWvVoHYxiAr5PPChA3l","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c164b1a439733e92b5044700"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c164b1a439733e92b5044700"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c164b1a439733e92b5044700"}],"is_playable":true,"name":"Greatest Hits Ever","release_date":"2021-03-26","release_date_precision":"day","total_tracks":97,"type":"album","uri":"spotify:album:6oDBWvVoHYxiAr5PPChA3l"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ogn9necmbUdCppmNnGOdi"},"href":"https://api.spotify.com/v1/artists/6ogn9necmbUdCppmNnGOdi","id":"6ogn9necmbUdCppmNnGOdi","name":"Alanis Morissette","type":"artist","uri":"spotify:artist:6ogn9necmbUdCppmNnGOdi"}],"disc_number":1,"duration_ms":228573,"explicit":false,"external_ids":{"isrc":"USMV20500296"},"external_urls":{"spotify":"https://open.spotify.com/track/1wFxUCSuuXodzp0CQUhQDm"},"href":"https://api.spotify.com/v1/tracks/1wFxUCSuuXodzp0CQUhQDm","id":"1wFxUCSuuXodzp0CQUhQDm","is_local":false,"is_playable":true,"name":"Ironic","track_number":8,"type":"track","uri":"spotify:track:1wFxUCSuuXodzp0CQUhQDm"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMklyb25pYyUyMiUyMGFydGlzdCUzQSUyMkFsYW5pcyUyME1vcmlzc2V0dGUlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjgsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZvZ245bmVjbWJVZENwcG1ObkdPZGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsImlkIjoiNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsIm5hbWUiOiJBbGFuaXMgTW9yaXNzZXR0ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2duOW5lY21iVWRDcHBtTm5HT2RpIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNE43THVaWXBzdFFydGNISW9PS3pxZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRON0x1Wllwc3RRcnRjSElvT0t6cWciLCJpZCI6IjRON0x1Wllwc3RRcnRjSElvT0t6cWciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDAwZTQ5MDAzNTQzYTViYjVhYTViODczIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQwMGU0OTAwMzU0M2E1YmI1YWE1Yjg3MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDAwZTQ5MDAzNTQzYTViYjVhYTViODczIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBDb2xsZWN0aW9uIChTdGFuZGFyZCBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjIwMDUtMTEtMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0TjdMdVpZcHN0UXJ0Y0hJb09LenFnIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82b2duOW5lY21iVQ==", + "ZENwcG1ObkdPZGkiLCJpZCI6IjZvZ245bmVjbWJVZENwcG1ObkdPZGkiLCJuYW1lIjoiQWxhbmlzIE1vcmlzc2V0dGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm9nbjluZWNtYlVkQ3BwbU5uR09kaSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjg1NzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU01WMjA1MDAyOTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzI5WUJpaHpRT21hdDBVNzRrNHVrZHgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yOVlCaWh6UU9tYXQwVTc0azR1a2R4IiwiaWQiOiIyOVlCaWh6UU9tYXQwVTc0azR1a2R4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Iklyb25pYyIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyOVlCaWh6UU9tYXQwVTc0azR1a2R4In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZvZ245bmVjbWJVZENwcG1ObkdPZGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsImlkIjoiNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsIm5hbWUiOiJBbGFuaXMgTW9yaXNzZXR0ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2duOW5lY21iVWRDcHBtTm5HT2RpIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUFwM0Y4Q3hqanNRS1pHQVNEY0hOQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVBcDNGOEN4ampzUUtaR0FTRGNITkEiLCJpZCI6IjVBcDNGOEN4ampzUUtaR0FTRGNITkEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjQyZTY0M2VhMDcxMThlY2Y2NzdhNmVmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI0MmU2NDNlYTA3MTE4ZWNmNjc3YTZlZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjQyZTY0M2VhMDcxMThlY2Y2NzdhNmVmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkphZ2dlZCBMaQ==", + "dHRsZSBQaWxsICgyMDE1IFJlbWFzdGVyKSIsInJlbGVhc2VfZGF0ZSI6IjE5OTUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUFwM0Y4Q3hqanNRS1pHQVNEY0hOQSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZvZ245bmVjbWJVZENwcG1ObkdPZGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsImlkIjoiNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsIm5hbWUiOiJBbGFuaXMgTW9yaXNzZXR0ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2duOW5lY21iVWRDcHBtTm5HT2RpIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzMDAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTTVYyMTUwMDAxMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMWQ2S1M5R0gwNkpBZDE5dWlCeTlJRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFkNktTOUdIMDZKQWQxOXVpQnk5SUUiLCJpZCI6IjFkNktTOUdIMDZKQWQxOXVpQnk5SUUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSXJvbmljIC0gMjAxNSBSZW1hc3RlciIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MWQ2S1M5R0gwNkpBZDE5dWlCeTlJRSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82b2duOW5lY21iVWRDcHBtTm5HT2RpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZvZ245bmVjbWJVZENwcG1ObkdPZGkiLCJpZCI6IjZvZ245bmVjbWJVZENwcG1ObkdPZGkiLCJuYW1lIjoiQWxhbmlzIE1vcmlzc2V0dGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm9nbjluZWNtYlVkQ3BwbU5uR09kaSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZqMWs4d21ZZXZCUVVSUWp6bDd0Q3QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82ajFrOHdtWWV2QlFVUlFqemw3dEN0IiwiaWQiOiI2ajFrOHdtWWV2QlFVUlFqemw3dEN0IiwiaW1hZ2VzIjpbeyJoZWlnaA==", + "dCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMTllY2Y5OWFmZDhmMDk0MmM2MGYyNTVmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE5ZWNmOTlhZmQ4ZjA5NDJjNjBmMjU1ZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTllY2Y5OWFmZDhmMDk0MmM2MGYyNTVmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkphZ2dlZCBMaXR0bGUgUGlsbCAoMjV0aCBBbm5pdmVyc2FyeSBEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTA2LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nmoxazh3bVlldkJRVVJRanpsN3RDdCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZvZ245bmVjbWJVZENwcG1ObkdPZGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsImlkIjoiNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsIm5hbWUiOiJBbGFuaXMgTW9yaXNzZXR0ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2duOW5lY21iVWRDcHBtTm5HT2RpIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyNTkzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTTVYyOTQwMDAwMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMFlycWx6UGxpeU1aSjNJTjhIYktiVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBZcnFselBsaXlNWkozSU44SGJLYlciLCJpZCI6IjBZcnFselBsaXlNWkozSU44SGJLYlciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSXJvbmljIiwidHJhY2tfbnVtYmVyIjoxMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowWXJxbHpQbGl5TVpKM0lOOEhiS2JXIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZvZ245bmVjbWJVZENwcG1ObkdPZGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm9nbjluZQ==", + "Y21iVWRDcHBtTm5HT2RpIiwiaWQiOiI2b2duOW5lY21iVWRDcHBtTm5HT2RpIiwibmFtZSI6IkFsYW5pcyBNb3Jpc3NldHRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZvZ245bmVjbWJVZENwcG1ObkdPZGkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wVnJFNXJnUW1yYXNhNktnN0dLcUtFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMFZyRTVyZ1FtcmFzYTZLZzdHS3FLRSIsImlkIjoiMFZyRTVyZ1FtcmFzYTZLZzdHS3FLRSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1NzJlZWI1OGU4ZWU5NzdiMzY1OGI2N2YifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTcyZWViNThlOGVlOTc3YjM2NThiNjdmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1NzJlZWI1OGU4ZWU5NzdiMzY1OGI2N2YifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSmFnZ2VkIExpdHRsZSBQaWxsIChDb2xsZWN0b3IncyBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTUtMTAtMzAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0OCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowVnJFNXJnUW1yYXNhNktnN0dLcUtFIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82b2duOW5lY21iVWRDcHBtTm5HT2RpIiwiaWQiOiI2b2duOW5lY21iVWRDcHBtTm5HT2RpIiwibmFtZSI6IkFsYW5pcyBNb3Jpc3NldHRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZvZ245bmVjbWJVZENwcG1ObkdPZGkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMwMDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNVjIxNTAwMDEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81RnUwU054dm9kcWlIa3d1akRmaFRDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNUZ1MFNOeHZvZHFpSGt3dWpEZmhUQyIsImlkIjoiNUZ1MFNOeHZvZA==", + "cWlIa3d1akRmaFRDIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Iklyb25pYyAtIDIwMTUgUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVGdTBTTnh2b2RxaUhrd3VqRGZoVEMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82b2duOW5lY21iVWRDcHBtTm5HT2RpIiwiaWQiOiI2b2duOW5lY21iVWRDcHBtTm5HT2RpIiwibmFtZSI6IkFsYW5pcyBNb3Jpc3NldHRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZvZ245bmVjbWJVZENwcG1ObkdPZGkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81M1BNQVpRZTlWb0xRM1U4N1NqRmtkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNTNQTUFaUWU5Vm9MUTNVODdTakZrZCIsImlkIjoiNTNQTUFaUWU5Vm9MUTNVODdTakZrZCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZGNiZGMyMzI3NjcwNTgwNGU5NGY5NTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGRjYmRjMjMyNzY3MDU4MDRlOTRmOTU4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwZGNiZGMyMzI3NjcwNTgwNGU5NGY5NTgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSmFnZ2VkIExpdHRsZSBQaWxsIChEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDE1LTEwLTMwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NTNQTUFaUWU5Vm9MUTNVODdTakZrZCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZvZ245bmVjbWJVZENwcG1ObkdPZGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsImlkIjoiNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsIm5hbWUiOiJBbGFuaXMgTQ==", + "b3Jpc3NldHRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZvZ245bmVjbWJVZENwcG1ObkdPZGkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMwMDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNVjIxNTAwMDEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83a0o3WklZSUhoN0pGRVdSZVpiY3VjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2tKN1pJWUlIaDdKRkVXUmVaYmN1YyIsImlkIjoiN2tKN1pJWUlIaDdKRkVXUmVaYmN1YyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJcm9uaWMgLSAyMDE1IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjoxMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3a0o3WklZSUhoN0pGRVdSZVpiY3VjIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZvZ245bmVjbWJVZENwcG1ObkdPZGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsImlkIjoiNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsIm5hbWUiOiJBbGFuaXMgTW9yaXNzZXR0ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2duOW5lY21iVWRDcHBtTm5HT2RpIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMThJWFVoSnFpa2hKMFRoN1R2bUdROCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzE4SVhVaEpxaWtoSjBUaDdUdm1HUTgiLCJpZCI6IjE4SVhVaEpxaWtoSjBUaDdUdm1HUTgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmExMmEzZDliY2JkOWZkNzFkZTU4MDRkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZhMTJhM2Q5YmNiZDlmZDcxZGU1ODA0ZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmExMmEzZDliY2JkOWZkNzFkZTU4MDRkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkphZ2dlZCBMaXR0bGUgUGlsbCIsInJlbGVhc2VfZGF0ZSI6IjE5OTUiLCJyZWxlYXNlXw==", + "ZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxOElYVWhKcWlraEowVGg3VHZtR1E4In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82b2duOW5lY21iVWRDcHBtTm5HT2RpIiwiaWQiOiI2b2duOW5lY21iVWRDcHBtTm5HT2RpIiwibmFtZSI6IkFsYW5pcyBNb3Jpc3NldHRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZvZ245bmVjbWJVZENwcG1ObkdPZGkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI3NTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNVjIxNTAwMDQ1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81VDBNbk1nMzVPVGpFdEJGT2U0VzZaIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNVQwTW5NZzM1T1RqRXRCRk9lNFc2WiIsImlkIjoiNVQwTW5NZzM1T1RqRXRCRk9lNFc2WiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJcm9uaWMgLSAyMDE1IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjoxMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1VDBNbk1nMzVPVGpFdEJGT2U0VzZaIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZvZ245bmVjbWJVZENwcG1ObkdPZGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsImlkIjoiNm9nbjluZWNtYlVkQ3BwbU5uR09kaSIsIm5hbWUiOiJBbGFuaXMgTW9yaXNzZXR0ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2b2duOW5lY21iVWRDcHBtTm5HT2RpIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMnFCVTNablVnMk9RWGlNcDR0YTR6dCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJxQlUzWm5VZzJPUVhpTXA0dGE0enQiLCJpZCI6IjJxQlUzWm5VZzJPUVhpTXA0dGE0enQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZA==", + "MDAwMGIyNzM0NmNkNDdmZTcxZjhlMTZmMjA5NWMzZWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDZjZDQ3ZmU3MWY4ZTE2ZjIwOTVjM2VjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0NmNkNDdmZTcxZjhlMTZmMjA5NWMzZWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSmFnZ2VkIExpdHRsZSBQaWxsICgyNXRoIEFubml2ZXJzYXJ5IERlbHV4ZSBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDYtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToycUJVM1puVWcyT1FYaU1wNHRhNHp0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm9nbjluZWNtYlVkQ3BwbU5uR09kaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82b2duOW5lY21iVWRDcHBtTm5HT2RpIiwiaWQiOiI2b2duOW5lY21iVWRDcHBtTm5HT2RpIiwibmFtZSI6IkFsYW5pcyBNb3Jpc3NldHRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZvZ245bmVjbWJVZENwcG1ObkdPZGkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI1OTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNVjI5NDAwMDAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xWHJ6S2FDaEtkRHhNbFV3YmtMdUQ2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVhyekthQ2hLZER4TWxVd2JrTHVENiIsImlkIjoiMVhyekthQ2hLZER4TWxVd2JrTHVENiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJcm9uaWMiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFYcnpLYUNoS2REeE1sVXdia0x1RDYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZQ==", + "IjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82b0RCV3ZWb0hZeGlBcjVQUENoQTNsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNm9EQld2Vm9IWXhpQXI1UFBDaEEzbCIsImlkIjoiNm9EQld2Vm9IWXhpQXI1UFBDaEEzbCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjMTY0YjFhNDM5NzMzZTkyYjUwNDQ3MDAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzE2NGIxYTQzOTczM2U5MmI1MDQ0NzAwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjMTY0YjFhNDM5NzMzZTkyYjUwNDQ3MDAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3JlYXRlc3QgSGl0cyBFdmVyIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wMy0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjk3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZvREJXdlZvSFl4aUFyNVBQQ2hBM2wifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82b2duOW5lY21iVWRDcHBtTm5HT2RpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZvZ245bmVjbWJVZENwcG1ObkdPZGkiLCJpZCI6IjZvZ245bmVjbWJVZENwcG1ObkdPZGkiLCJuYW1lIjoiQWxhbmlzIE1vcmlzc2V0dGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm9nbjluZWNtYlVkQ3BwbU5uR09kaSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjg1NzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU01WMjA1MDAyOTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzF3RnhVQ1N1dVhvZHpwMENRVWhRRG0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xd0Z4VUNTdXVYb2R6cDBDUVVoUURtIiwiaWQiOiIxd0Z4VUNTdXVYb2R6cDBDUVVoUURtIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Iklyb25pYyIsInRyYWNrX251bQ==", + "YmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjF3RnhVQ1N1dVhvZHpwMENRVWhRRG0ifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Ironic%22+artist%3A%22Alanis+Morissette%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Mmmbop%22%20artist%3A%22Hanson%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"external_urls":{"spotify":"https://open.spotify.com/album/3StpQT9Qd87FSeWeQAdg1h"},"href":"https://api.spotify.com/v1/albums/3StpQT9Qd87FSeWeQAdg1h","id":"3StpQT9Qd87FSeWeQAdg1h","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273184227f002623fc19f44551a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02184227f002623fc19f44551a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851184227f002623fc19f44551a"}],"is_playable":true,"name":"Middle Of Nowhere","release_date":"1997-01-01","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3StpQT9Qd87FSeWeQAdg1h"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"disc_number":1,"duration_ms":268653,"explicit":false,"external_ids":{"isrc":"USMR19786791"},"external_urls":{"spotify":"https://open.spotify.com/track/0lnxrQAd9ZxbhBBe7d8FO8"},"href":"https://api.spotify.com/v1/tracks/0lnxrQAd9ZxbhBBe7d8FO8","id":"0lnxrQAd9ZxbhBBe7d8FO8","is_local":false,"is_playable":true,"name":"MMMBop","track_number":2,"type":"track","uri":"spotify:track:0lnxrQAd9ZxbhBBe7d8FO8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"external_urls":{"spotify":"https://open.spotify.com/album/1M2yu8efuS6XDYiUzKQzOw"},"href":"https://api.spotify.com/v1/albums/1M2yu8efuS6XDYiUzKQzOw","id":"1M2yu8efuS6XDYiUzKQzOw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e5cb14ae7a6202869ce72e3f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e5cb14ae7a6202869ce72e3f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e5cb14ae7a6202869ce72e3f"}],"is_playable":true,"name":"Live From Albertane","release_date":"1998-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1M2yu8efuS6XDYiUzKQzOw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"disc_number":1,"duration_ms":270173,"explicit":false,"external_ids":{"isrc":"USMR19889338"},"external_urls":{"spotify":"https://open.spotify.com/track/6UAcKdJGXesncrluJ15eRe"},"href":"https://api.spotify.com/v1/tracks/6UAcKdJGXesncrluJ15eRe","id":"6UAcKdJGXesncrluJ15eRe","is_local":false,"is_playable":true,"name":"MMMBop","track_number":11,"type":"track","uri":"spotify:track:6UAcKdJGXesncrluJ15eRe"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"external_urls":{"spotify":"https://open.spotify.com/album/1SNNc4pb0aA0GS2PsLr5b5"},"href":"https://api.spotify.com/v1/albums/1SNNc4pb0aA0GS2PsLr5b5","id":"1SNNc4pb0aA0GS2PsLr5b5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273765b5b2e04bbe8443952d022"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02765b5b2e04bbe8443952d022"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851765b5b2e04bbe8443952d022"}],"is_playable":true,"name":"The Best Of Hanson 20th Century Masters The Millennium Collection","release_date":"2006-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1SNNc4pb0aA0GS2PsLr5b5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"disc_number":1,"duration_ms":238733,"explicit":false,"external_ids":{"isrc":"USMR19786993"},"external_urls":{"spotify":"https://open.spotify.com/track/2HNZxbvFvasRtlOJ9M6DgR"},"href":"https://api.spotify.com/v1/tracks/2HNZxbvFvasRtlOJ9M6DgR","id":"2HNZxbvFvasRtlOJ9M6DgR","is_local":false,"is_playable":true,"name":"MMMBop - Single Version","track_number":1,"type":"track","uri":"spotify:track:2HNZxbvFvasRtlOJ9M6DgR"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3Z6IRCo7umuk8K2XQy0ZDj"},"href":"https://api.spotify.com/v1/artists/3Z6IRCo7umuk8K2XQy0ZDj","id":"3Z6IRCo7umuk8K2XQy0ZDj","name":"Busted","type":"artist","uri":"spotify:artist:3Z6IRCo7umuk8K2XQy0ZDj"}],"external_urls":{"spotify":"https://open.spotify.com/album/2XWO1jEuigClyJgkMvk3rx"},"href":"https://api.spotify.com/v1/albums/2XWO1jEuigClyJgkMvk3rx","id":"2XWO1jEuigClyJgkMvk3rx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a57caaa1fbc4a559f020e3b0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a57caaa1fbc4a559f020e3b0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a57caaa1fbc4a559f020e3b0"}],"is_playable":true,"name":"Greatest Hits 2.0 (Guest Features Edition)","release_date":"2023-09-15","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:2XWO1jEuigClyJgkMvk3rx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3Z6IRCo7umuk8K2XQy0ZDj"},"href":"https://api.spotify.com/v1/artists/3Z6IRCo7umuk8K2XQy0ZDj","id":"3Z6IRCo7umuk8K2XQy0ZDj","name":"Busted","type":"artist","uri":"spotify:artist:3Z6IRCo7umuk8K2XQy0ZDj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"disc_number":1,"duration_ms":176222,"explicit":false,"external_ids":{"isrc":"UKW3Z2301188"},"external_urls":{"spotify":"https://open.spotify.com/track/7MnqGkKia4STbmgMTEwzLk"},"href":"https://api.spotify.com/v1/tracks/7MnqGkKia4STbmgMTEwzLk","id":"7MnqGkKia4STbmgMTEwzLk","is_local":false,"is_playable":true,"name":"MMMBop 2.0","track_number":10,"type":"track","uri":"spotify:track:7MnqGkKia4STbmgMTEwzLk"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3Z6IRCo7umuk8K2XQy0ZDj"},"href":"https://api.spotify.com/v1/artists/3Z6IRCo7umuk8K2XQy0ZDj","id":"3Z6IRCo7umuk8K2XQy0ZDj","name":"Busted","type":"artist","uri":"spotify:artist:3Z6IRCo7umuk8K2XQy0ZDj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"external_urls":{"spotify":"https://open.spotify.com/album/3D4ChwgtoX9oOTKf7YenFP"},"href":"https://api.spotify.com/v1/albums/3D4ChwgtoX9oOTKf7YenFP","id":"3D4ChwgtoX9oOTKf7YenFP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27394e75ae5de56f787e1955e6d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0294e75ae5de56f787e1955e6d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485194e75ae5de56f787e1955e6d"}],"is_playable":true,"name":"MMMBop 2.0","release_date":"2023-05-26","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3D4ChwgtoX9oOTKf7YenFP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3Z6IRCo7umuk8K2XQy0ZDj"},"href":"https://api.spotify.com/v1/artists/3Z6IRCo7umuk8K2XQy0ZDj","id":"3Z6IRCo7umuk8K2XQy0ZDj","name":"Busted","type":"artist","uri":"spotify:artist:3Z6IRCo7umuk8K2XQy0ZDj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"disc_number":1,"duration_ms":176222,"explicit":false,"external_ids":{"isrc":"UKW3Z2301188"},"external_urls":{"spotify":"https://open.spotify.com/track/3lngW7QTDn2ZsWTuRgGyIT"},"href":"https://api.spotify.com/v1/tracks/3lngW7QTDn2ZsWTuRgGyIT","id":"3lngW7QTDn2ZsWTuRgGyIT","is_local":false,"is_playable":true,"name":"MMMBop 2.0","track_number":1,"type":"track","uri":"spotify:track:3lngW7QTDn2ZsWTuRgGyIT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Yv1iUvF60SaPmxJoCQc5r"},"href":"https://api.spotify.com/v1/albums/3Yv1iUvF60SaPmxJoCQc5r","id":"3Yv1iUvF60SaPmxJoCQc5r","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bad7636d6896491e72704e6a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bad7636d6896491e72704e6a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bad7636d6896491e72704e6a"}],"is_playable":true,"name":"MmmBop : The Collection","release_date":"2005-01-01","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:3Yv1iUvF60SaPmxJoCQc5r"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"disc_number":1,"duration_ms":267946,"explicit":false,"external_ids":{"isrc":"USMR19786791"},"external_urls":{"spotify":"https://open.spotify.com/track/0YYbQESOOReEZjVzbYJtMC"},"href":"https://api.spotify.com/v1/tracks/0YYbQESOOReEZjVzbYJtMC","id":"0YYbQESOOReEZjVzbYJtMC","is_local":false,"is_playable":true,"name":"MMMBop","track_number":1,"type":"track","uri":"spotify:track:0YYbQESOOReEZjVzbYJtMC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6ETmUseYO0h2BTRlZ495jL"},"href":"https://api.spotify.com/v1/albums/6ETmUseYO0h2BTRlZ495jL","id":"6ETmUseYO0h2BTRlZ495jL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273132316f1a1027dac8e96680f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02132316f1a1027dac8e96680f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851132316f1a1027dac8e96680f"}],"is_playable":true,"name":"Absolute 90's","release_date":"2013-01-01","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:6ETmUseYO0h2BTRlZ495jL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"disc_number":2,"duration_ms":268240,"explicit":false,"external_ids":{"isrc":"USMR19786791"},"external_urls":{"spotify":"https://open.spotify.com/track/42XDh1584BWmgRDePjcwuq"},"href":"https://api.spotify.com/v1/tracks/42XDh1584BWmgRDePjcwuq","id":"42XDh1584BWmgRDePjcwuq","is_local":false,"is_playable":true,"name":"MMMBop","track_number":5,"type":"track","uri":"spotify:track:42XDh1584BWmgRDePjcwuq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2acdsJka7kONvnpqZ5mghI"},"href":"https://api.spotify.com/v1/albums/2acdsJka7kONvnpqZ5mghI","id":"2acdsJka7kONvnpqZ5mghI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273086c809c23a6a62c84ddb9dd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02086c809c23a6a62c84ddb9dd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851086c809c23a6a62c84ddb9dd"}],"is_playable":true,"name":"Best of Boy Bands","release_date":"2019-08-30","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:2acdsJka7kONvnpqZ5mghI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"disc_number":1,"duration_ms":268360,"explicit":false,"external_ids":{"isrc":"USMR19786791"},"external_urls":{"spotify":"https://open.spotify.com/track/061cfrzdP5YqpDlEFk1NJo"},"href":"https://api.spotify.com/v1/tracks/061cfrzdP5YqpDlEFk1NJo","id":"061cfrzdP5YqpDlEFk1NJo","is_local":false,"is_playable":true,"name":"MMMBop","track_number":2,"type":"track","uri":"spotify:track:061cfrzdP5YqpDlEFk1NJo"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7ezMl3K2sBaWXm7gsQNP9T"},"href":"https://api.spotify.com/v1/albums/7ezMl3K2sBaWXm7gsQNP9T","id":"7ezMl3K2sBaWXm7gsQNP9T","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730a0d61375cfba3d29ffb33b6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020a0d61375cfba3d29ffb33b6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510a0d61375cfba3d29ffb33b6"}],"is_playable":true,"name":"One Hit Wonders","release_date":"2019-08-16","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:7ezMl3K2sBaWXm7gsQNP9T"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SdiiPkr02EUdekHZJkt58"},"href":"https://api.spotify.com/v1/artists/0SdiiPkr02EUdekHZJkt58","id":"0SdiiPkr02EUdekHZJkt58","name":"Hanson","type":"artist","uri":"spotify:artist:0SdiiPkr02EUdekHZJkt58"}],"disc_number":1,"duration_ms":268360,"explicit":false,"external_ids":{"isrc":"USMR19786791"},"external_urls":{"spotify":"https://open.spotify.com/track/1kMWXciZdcjBykRADIvCnR"},"href":"https://api.spotify.com/v1/tracks/1kMWXciZdcjBykRADIvCnR","id":"1kMWXciZdcjBykRADIvCnR","is_local":false,"is_playable":true,"name":"MMMBop","track_number":2,"type":"track","uri":"spotify:track:1kMWXciZdcjBykRADIvCnR"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1tbWJvcCUyMiUyMGFydGlzdCUzQSUyMkhhbnNvbiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU2RpaVBrcjAyRVVkZWtIWkprdDU4IiwiaWQiOiIwU2RpaVBrcjAyRVVkZWtIWkprdDU4IiwibmFtZSI6IkhhbnNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU2RpaVBrcjAyRVVkZWtIWkprdDU4In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM1N0cFFUOVFkODdGU2VXZVFBZGcxaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNTdHBRVDlRZDg3RlNlV2VRQWRnMWgiLCJpZCI6IjNTdHBRVDlRZDg3RlNlV2VRQWRnMWgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3", + "NjE2ZDAwMDBiMjczMTg0MjI3ZjAwMjYyM2ZjMTlmNDQ1NTFhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjE4NDIyN2YwMDI2MjNmYzE5ZjQ0NTUxYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTg0MjI3ZjAwMjYyM2ZjMTlmNDQ1NTFhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1pZGRsZSBPZiBOb3doZXJlIiwicmVsZWFzZV9kYXRlIjoiMTk5Ny0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNTdHBRVDlRZDg3RlNlV2VRQWRnMWgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU2RpaVBrcjAyRVVkZWtIWkprdDU4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJpZCI6IjBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJuYW1lIjoiSGFuc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTZGlpUGtyMDJFVWRla0haSmt0NTgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY4NjUzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNUjE5Nzg2NzkxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wbG54clFBZDlaeGJoQkJlN2Q4Rk84In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGxueHJRQWQ5WnhiaEJCZTdkOEZPOCIsImlkIjoiMGxueHJRQWQ5WnhiaEJCZTdkOEZPOCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNTU1Cb3AiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGxueHJRQWQ5WnhiaEJCZTdkOEZPOCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU2RpaVBrcjAyRVVkZWtIWkprdDU4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJpZCI6IjBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJuYW1lIjoiSGFuc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Og==", + "MFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFNMnl1OGVmdVM2WERZaVV6S1F6T3cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xTTJ5dThlZnVTNlhEWWlVektRek93IiwiaWQiOiIxTTJ5dThlZnVTNlhEWWlVektRek93IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2U1Y2IxNGFlN2E2MjAyODY5Y2U3MmUzZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlNWNiMTRhZTdhNjIwMjg2OWNlNzJlM2YifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWU1Y2IxNGFlN2E2MjAyODY5Y2U3MmUzZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMaXZlIEZyb20gQWxiZXJ0YW5lIiwicmVsZWFzZV9kYXRlIjoiMTk5OC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFNMnl1OGVmdVM2WERZaVV6S1F6T3cifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU2RpaVBrcjAyRVVkZWtIWkprdDU4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJpZCI6IjBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJuYW1lIjoiSGFuc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTZGlpUGtyMDJFVWRla0haSmt0NTgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjcwMTczLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNUjE5ODg5MzM4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82VUFjS2RKR1hlc25jcmx1SjE1ZVJlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNlVBY0tkSkdYZXNuY3JsdUoxNWVSZSIsImlkIjoiNlVBY0tkSkdYZXNuY3JsdUoxNWVSZSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNTU1Cb3AiLCJ0cmFja19udW1iZXIiOjExLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZVQWNLZEpHWGVzbmNybHVKMTVlUmUifQ==", + "LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU2RpaVBrcjAyRVVkZWtIWkprdDU4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJpZCI6IjBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJuYW1lIjoiSGFuc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTZGlpUGtyMDJFVWRla0haSmt0NTgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xU05OYzRwYjBhQTBHUzJQc0xyNWI1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVNOTmM0cGIwYUEwR1MyUHNMcjViNSIsImlkIjoiMVNOTmM0cGIwYUEwR1MyUHNMcjViNSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3NjViNWIyZTA0YmJlODQ0Mzk1MmQwMjIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzY1YjViMmUwNGJiZTg0NDM5NTJkMDIyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3NjViNWIyZTA0YmJlODQ0Mzk1MmQwMjIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEJlc3QgT2YgSGFuc29uIDIwdGggQ2VudHVyeSBNYXN0ZXJzIFRoZSBNaWxsZW5uaXVtIENvbGxlY3Rpb24iLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVNOTmM0cGIwYUEwR1MyUHNMcjViNSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTZGlpUGtyMDJFVWRla0haSmt0NTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCIsImlkIjoiMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCIsIm5hbWUiOiJIYW5zb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzg3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7Ig==", + "aXNyYyI6IlVTTVIxOTc4Njk5MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMkhOWnhidkZ2YXNSdGxPSjlNNkRnUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJITlp4YnZGdmFzUnRsT0o5TTZEZ1IiLCJpZCI6IjJITlp4YnZGdmFzUnRsT0o5TTZEZ1IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTU1NQm9wIC0gU2luZ2xlIFZlcnNpb24iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MkhOWnhidkZ2YXNSdGxPSjlNNkRnUiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zWjZJUkNvN3VtdWs4SzJYUXkwWkRqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNaNklSQ283dW11azhLMlhReTBaRGoiLCJpZCI6IjNaNklSQ283dW11azhLMlhReTBaRGoiLCJuYW1lIjoiQnVzdGVkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNaNklSQ283dW11azhLMlhReTBaRGoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yWFdPMWpFdWlnQ2x5SmdrTXZrM3J4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMlhXTzFqRXVpZ0NseUpna012azNyeCIsImlkIjoiMlhXTzFqRXVpZ0NseUpna012azNyeCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhNTdjYWFhMWZiYzRhNTU5ZjAyMGUzYjAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTU3Y2FhYTFmYmM0YTU1OWYwMjBlM2IwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhNTdjYWFhMWZiYzRhNTU5ZjAyMGUzYjAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3JlYXRlc3QgSGl0cyAyLjAgKEd1ZXN0IEZlYXR1cmVzIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wOS0xNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJYV08xakV1aWdDbHlKZ2tNdmszcngifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscw==", + "Ijp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNaNklSQ283dW11azhLMlhReTBaRGoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM1o2SVJDbzd1bXVrOEsyWFF5MFpEaiIsImlkIjoiM1o2SVJDbzd1bXVrOEsyWFF5MFpEaiIsIm5hbWUiOiJCdXN0ZWQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1o2SVJDbzd1bXVrOEsyWFF5MFpEaiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU2RpaVBrcjAyRVVkZWtIWkprdDU4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJpZCI6IjBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJuYW1lIjoiSGFuc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTZGlpUGtyMDJFVWRla0haSmt0NTgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc2MjIyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVUtXM1oyMzAxMTg4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83TW5xR2tLaWE0U1RibWdNVEV3ekxrIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN01ucUdrS2lhNFNUYm1nTVRFd3pMayIsImlkIjoiN01ucUdrS2lhNFNUYm1nTVRFd3pMayIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNTU1Cb3AgMi4wIiwidHJhY2tfbnVtYmVyIjoxMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3TW5xR2tLaWE0U1RibWdNVEV3ekxrIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zWjZJUkNvN3VtdWs4SzJYUXkwWkRqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNaNklSQ283dW11azhLMlhReTBaRGoiLCJpZCI6IjNaNklSQ283dW11azhLMlhReTBaRGoiLCJuYW1lIjoiQnVzdGVkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNaNklSQ283dW11azhLMlhReTBaRGoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU2RpaVBrcjAyRVVkZWtIWkprdDU4IiwiaQ==", + "ZCI6IjBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJuYW1lIjoiSGFuc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTZGlpUGtyMDJFVWRla0haSmt0NTgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zRDRDaHdndG9YOW9PVEtmN1llbkZQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM0Q0Q2h3Z3RvWDlvT1RLZjdZZW5GUCIsImlkIjoiM0Q0Q2h3Z3RvWDlvT1RLZjdZZW5GUCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5NGU3NWFlNWRlNTZmNzg3ZTE5NTVlNmQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTRlNzVhZTVkZTU2Zjc4N2UxOTU1ZTZkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5NGU3NWFlNWRlNTZmNzg3ZTE5NTVlNmQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTU1NQm9wIDIuMCIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDUtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNENENod2d0b1g5b09US2Y3WWVuRlAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zWjZJUkNvN3VtdWs4SzJYUXkwWkRqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNaNklSQ283dW11azhLMlhReTBaRGoiLCJpZCI6IjNaNklSQ283dW11azhLMlhReTBaRGoiLCJuYW1lIjoiQnVzdGVkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNaNklSQ283dW11azhLMlhReTBaRGoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU2RpaVBrcjAyRVVkZWtIWkprdDU4IiwiaWQiOiIwU2RpaVBrcjAyRVVkZWtIWkprdDU4IiwibmFtZSI6IkhhbnNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU2RpaVBrcjAyRVVkZWtIWkprdDU4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3NjIyMiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOg==", + "eyJpc3JjIjoiVUtXM1oyMzAxMTg4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zbG5nVzdRVERuMlpzV1R1UmdHeUlUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM2xuZ1c3UVREbjJac1dUdVJnR3lJVCIsImlkIjoiM2xuZ1c3UVREbjJac1dUdVJnR3lJVCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNTU1Cb3AgMi4wIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNsbmdXN1FURG4yWnNXVHVSZ0d5SVQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wU2RpaVBrcjAyRVVkZWtIWkprdDU4IiwiaWQiOiIwU2RpaVBrcjAyRVVkZWtIWkprdDU4IiwibmFtZSI6IkhhbnNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU2RpaVBrcjAyRVVkZWtIWkprdDU4In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM1l2MWlVdkY2MFNhUG14Sm9DUWM1ciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNZdjFpVXZGNjBTYVBteEpvQ1FjNXIiLCJpZCI6IjNZdjFpVXZGNjBTYVBteEpvQ1FjNXIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYmFkNzYzNmQ2ODk2NDkxZTcyNzA0ZTZhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJhZDc2MzZkNjg5NjQ5MWU3MjcwNGU2YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYmFkNzYzNmQ2ODk2NDkxZTcyNzA0ZTZhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1tbUJvcCA6IFRoZSBDb2xsZWN0aW9uIiwicmVsZWFzZV9kYXRlIjoiMjAwNS0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNZdjFpVXZGNjBTYVBteEpvQ1FjNXIifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcA==", + "ZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTZGlpUGtyMDJFVWRla0haSmt0NTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCIsImlkIjoiMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCIsIm5hbWUiOiJIYW5zb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjc5NDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU01SMTk3ODY3OTEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBZWWJRRVNPT1JlRVpqVnpiWUp0TUMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wWVliUUVTT09SZUVaalZ6YllKdE1DIiwiaWQiOiIwWVliUUVTT09SZUVaalZ6YllKdE1DIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1NTUJvcCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowWVliUUVTT09SZUVaalZ6YllKdE1DIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZFVG1Vc2VZTzBoMkJUUmxaNDk1akwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82RVRtVXNlWU8waDJCVFJsWjQ5NWpMIiwiaWQiOiI2RVRtVXNlWU8waDJCVFJsWjQ5NWpMIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzEzMjMxNmYxYTEwMjdkYWM4ZTk2NjgwZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxMzIzMTZmMWExMDI3ZGFjOGU5NjY4MGYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLg==", + "c2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTMyMzE2ZjFhMTAyN2RhYzhlOTY2ODBmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFic29sdXRlIDkwJ3MiLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkVUbVVzZVlPMGgyQlRSbFo0OTVqTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTZGlpUGtyMDJFVWRla0haSmt0NTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCIsImlkIjoiMFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCIsIm5hbWUiOiJIYW5zb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFNkaWlQa3IwMkVVZGVrSFpKa3Q1OCJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjoyNjgyNDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU01SMTk3ODY3OTEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzQyWERoMTU4NEJXbWdSRGVQamN3dXEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80MlhEaDE1ODRCV21nUkRlUGpjd3VxIiwiaWQiOiI0MlhEaDE1ODRCV21nUkRlUGpjd3VxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1NTUJvcCIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0MlhEaDE1ODRCV21nUkRlUGpjd3VxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJhY2RzSmthN2tPTnZucHFaNW1naEkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yYWNkc0prYTdrT052bnBxWg==", + "NW1naEkiLCJpZCI6IjJhY2RzSmthN2tPTnZucHFaNW1naEkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDg2YzgwOWMyM2E2YTYyYzg0ZGRiOWRkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA4NmM4MDljMjNhNmE2MmM4NGRkYjlkZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDg2YzgwOWMyM2E2YTYyYzg0ZGRiOWRkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlc3Qgb2YgQm95IEJhbmRzIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wOC0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJhY2RzSmthN2tPTnZucHFaNW1naEkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wU2RpaVBrcjAyRVVkZWtIWkprdDU4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJpZCI6IjBTZGlpUGtyMDJFVWRla0haSmt0NTgiLCJuYW1lIjoiSGFuc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBTZGlpUGtyMDJFVWRla0haSmt0NTgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY4MzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNNUjE5Nzg2NzkxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wNjFjZnJ6ZFA1WXFwRGxFRmsxTkpvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDYxY2ZyemRQNVlxcERsRUZrMU5KbyIsImlkIjoiMDYxY2ZyemRQNVlxcERsRUZrMU5KbyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNTU1Cb3AiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MDYxY2ZyemRQNVlxcERsRUZrMU5KbyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcg==", + "dGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdlek1sM0syc0JhV1htN2dzUU5QOVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83ZXpNbDNLMnNCYVdYbTdnc1FOUDlUIiwiaWQiOiI3ZXpNbDNLMnNCYVdYbTdnc1FOUDlUIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzBhMGQ2MTM3NWNmYmEzZDI5ZmZiMzNiNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwYTBkNjEzNzVjZmJhM2QyOWZmYjMzYjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTBhMGQ2MTM3NWNmYmEzZDI5ZmZiMzNiNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPbmUgSGl0IFdvbmRlcnMiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA4LTE2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N2V6TWwzSzJzQmFXWG03Z3NRTlA5VCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBTZGlpUGtyMDJFVWRla0haSmt0NTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tLw==", + "djEvYXJ0aXN0cy8wU2RpaVBrcjAyRVVkZWtIWkprdDU4IiwiaWQiOiIwU2RpaVBrcjAyRVVkZWtIWkprdDU4IiwibmFtZSI6IkhhbnNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowU2RpaVBrcjAyRVVkZWtIWkprdDU4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2ODM2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTTVIxOTc4Njc5MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMWtNV1hjaVpkY2pCeWtSQURJdkNuUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFrTVdYY2laZGNqQnlrUkFESXZDblIiLCJpZCI6IjFrTVdYY2laZGNqQnlrUkFESXZDblIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTU1NQm9wIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFrTVdYY2laZGNqQnlrUkFESXZDblIifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Mmmbop%22+artist%3A%22Hanson%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%221979%22%20artist%3A%22The%20Smashing%20Pumpkins%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"external_urls":{"spotify":"https://open.spotify.com/album/55RhFRyQFihIyGf61MgcfV"},"href":"https://api.spotify.com/v1/albums/55RhFRyQFihIyGf61MgcfV","id":"55RhFRyQFihIyGf61MgcfV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273431ac6e6f393acf475730ec6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02431ac6e6f393acf475730ec6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851431ac6e6f393acf475730ec6"}],"is_playable":true,"name":"Mellon Collie And The Infinite Sadness (Deluxe Edition)","release_date":"1995","release_date_precision":"year","total_tracks":92,"type":"album","uri":"spotify:album:55RhFRyQFihIyGf61MgcfV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"disc_number":2,"duration_ms":266200,"explicit":false,"external_ids":{"isrc":"USVI21200910"},"external_urls":{"spotify":"https://open.spotify.com/track/5QLHGv0DfpeXLNFo7SFEy1"},"href":"https://api.spotify.com/v1/tracks/5QLHGv0DfpeXLNFo7SFEy1","id":"5QLHGv0DfpeXLNFo7SFEy1","is_local":false,"is_playable":true,"name":"1979 - Remastered 2012","track_number":5,"type":"track","uri":"spotify:track:5QLHGv0DfpeXLNFo7SFEy1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"external_urls":{"spotify":"https://open.spotify.com/album/1cUnNrx2TxvrpwPRtvpGwn"},"href":"https://api.spotify.com/v1/albums/1cUnNrx2TxvrpwPRtvpGwn","id":"1cUnNrx2TxvrpwPRtvpGwn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c48f42fdafcffcedbdbce025"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c48f42fdafcffcedbdbce025"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c48f42fdafcffcedbdbce025"}],"is_playable":true,"name":"(Rotten Apples) The Smashing Pumpkins Greatest Hits","release_date":"2001-01-01","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:1cUnNrx2TxvrpwPRtvpGwn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"disc_number":1,"duration_ms":263573,"explicit":false,"external_ids":{"isrc":"USVI29500052"},"external_urls":{"spotify":"https://open.spotify.com/track/3h5zik31hTTat9jmpCZZNC"},"href":"https://api.spotify.com/v1/tracks/3h5zik31hTTat9jmpCZZNC","id":"3h5zik31hTTat9jmpCZZNC","is_local":false,"is_playable":true,"name":"1979","track_number":9,"type":"track","uri":"spotify:track:3h5zik31hTTat9jmpCZZNC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"external_urls":{"spotify":"https://open.spotify.com/album/4bPT6Q8ppaSNppk1kbEbLl"},"href":"https://api.spotify.com/v1/albums/4bPT6Q8ppaSNppk1kbEbLl","id":"4bPT6Q8ppaSNppk1kbEbLl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734c42e40240028664f939f81c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024c42e40240028664f939f81c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514c42e40240028664f939f81c"}],"is_playable":true,"name":"Mellon Collie And The Infinite Sadness (Remastered)","release_date":"1995-12-12","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:4bPT6Q8ppaSNppk1kbEbLl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"disc_number":2,"duration_ms":266200,"explicit":false,"external_ids":{"isrc":"USVI21200910"},"external_urls":{"spotify":"https://open.spotify.com/track/3Y8Ff1nH44jFywAtpgmleZ"},"href":"https://api.spotify.com/v1/tracks/3Y8Ff1nH44jFywAtpgmleZ","id":"3Y8Ff1nH44jFywAtpgmleZ","is_local":false,"is_playable":true,"name":"1979 - Remastered 2012","track_number":5,"type":"track","uri":"spotify:track:3Y8Ff1nH44jFywAtpgmleZ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nrppjPtyFRWoZbVJyQqgk"},"href":"https://api.spotify.com/v1/albums/6nrppjPtyFRWoZbVJyQqgk","id":"6nrppjPtyFRWoZbVJyQqgk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f04ed92dca9611bdcd3120b3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f04ed92dca9611bdcd3120b3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f04ed92dca9611bdcd3120b3"}],"is_playable":true,"name":"Mellon Collie And The Infinite Sadness (30th Anniversary Edition)","release_date":"2025-11-21","release_date_precision":"day","total_tracks":42,"type":"album","uri":"spotify:album:6nrppjPtyFRWoZbVJyQqgk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"disc_number":1,"duration_ms":266197,"explicit":false,"external_ids":{"isrc":"USVI21200910"},"external_urls":{"spotify":"https://open.spotify.com/track/0jiEKj0fXevcv46JXUdcKh"},"href":"https://api.spotify.com/v1/tracks/0jiEKj0fXevcv46JXUdcKh","id":"0jiEKj0fXevcv46JXUdcKh","is_local":false,"is_playable":true,"name":"1979","track_number":19,"type":"track","uri":"spotify:track:0jiEKj0fXevcv46JXUdcKh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2Ev0rXjsYBwY1cRztGn4MZ"},"href":"https://api.spotify.com/v1/albums/2Ev0rXjsYBwY1cRztGn4MZ","id":"2Ev0rXjsYBwY1cRztGn4MZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737a8fd9e20f741debf9eb3f48"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027a8fd9e20f741debf9eb3f48"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517a8fd9e20f741debf9eb3f48"}],"is_playable":true,"name":"90s Summer Nostalgia","release_date":"2025-08-22","release_date_precision":"day","total_tracks":49,"type":"album","uri":"spotify:album:2Ev0rXjsYBwY1cRztGn4MZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"disc_number":1,"duration_ms":266197,"explicit":false,"external_ids":{"isrc":"USVI21200910"},"external_urls":{"spotify":"https://open.spotify.com/track/31qfXX9jYQFpqCCIHRW1FK"},"href":"https://api.spotify.com/v1/tracks/31qfXX9jYQFpqCCIHRW1FK","id":"31qfXX9jYQFpqCCIHRW1FK","is_local":false,"is_playable":true,"name":"1979 - Remastered 2012","track_number":1,"type":"track","uri":"spotify:track:31qfXX9jYQFpqCCIHRW1FK"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5qLAR6GFTdQSFDouxyYc2m"},"href":"https://api.spotify.com/v1/albums/5qLAR6GFTdQSFDouxyYc2m","id":"5qLAR6GFTdQSFDouxyYc2m","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27396c0615b0a1978ef3e9f2e98"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0296c0615b0a1978ef3e9f2e98"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485196c0615b0a1978ef3e9f2e98"}],"is_playable":true,"name":"Best Rock Ever","release_date":"2019-07-19","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:5qLAR6GFTdQSFDouxyYc2m"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"disc_number":1,"duration_ms":266197,"explicit":false,"external_ids":{"isrc":"USVI21200910"},"external_urls":{"spotify":"https://open.spotify.com/track/5nffGByZNM2kPcJ5YqCi7a"},"href":"https://api.spotify.com/v1/tracks/5nffGByZNM2kPcJ5YqCi7a","id":"5nffGByZNM2kPcJ5YqCi7a","is_local":false,"is_playable":true,"name":"1979 - Remastered 2012","track_number":10,"type":"track","uri":"spotify:track:5nffGByZNM2kPcJ5YqCi7a"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6aplv695DFyKOet82AW1Jt"},"href":"https://api.spotify.com/v1/albums/6aplv695DFyKOet82AW1Jt","id":"6aplv695DFyKOet82AW1Jt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a7ac97ba88e2332e106f22b5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a7ac97ba88e2332e106f22b5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a7ac97ba88e2332e106f22b5"}],"is_playable":true,"name":"90's Grunge/Rock","release_date":"2026-02-06","release_date_precision":"day","total_tracks":72,"type":"album","uri":"spotify:album:6aplv695DFyKOet82AW1Jt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"disc_number":1,"duration_ms":266197,"explicit":false,"external_ids":{"isrc":"USVI21200910"},"external_urls":{"spotify":"https://open.spotify.com/track/4CThPsYNqden8agDt2nivD"},"href":"https://api.spotify.com/v1/tracks/4CThPsYNqden8agDt2nivD","id":"4CThPsYNqden8agDt2nivD","is_local":false,"is_playable":true,"name":"1979 - Remastered 2012","track_number":2,"type":"track","uri":"spotify:track:4CThPsYNqden8agDt2nivD"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2L5KDszgmnv9ZCeLuUxc6u"},"href":"https://api.spotify.com/v1/albums/2L5KDszgmnv9ZCeLuUxc6u","id":"2L5KDszgmnv9ZCeLuUxc6u","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f1b3da5986132461b3235661"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f1b3da5986132461b3235661"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f1b3da5986132461b3235661"}],"is_playable":true,"name":"Songs That Feel Like Fall","release_date":"2025-10-10","release_date_precision":"day","total_tracks":46,"type":"album","uri":"spotify:album:2L5KDszgmnv9ZCeLuUxc6u"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"disc_number":1,"duration_ms":266197,"explicit":false,"external_ids":{"isrc":"USVI21200910"},"external_urls":{"spotify":"https://open.spotify.com/track/0vFIuhUL0cHl6mx6boplTy"},"href":"https://api.spotify.com/v1/tracks/0vFIuhUL0cHl6mx6boplTy","id":"0vFIuhUL0cHl6mx6boplTy","is_local":false,"is_playable":true,"name":"1979 - Remastered 2012","track_number":1,"type":"track","uri":"spotify:track:0vFIuhUL0cHl6mx6boplTy"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0PmgXoT1fU4O0JhQb153i0"},"href":"https://api.spotify.com/v1/albums/0PmgXoT1fU4O0JhQb153i0","id":"0PmgXoT1fU4O0JhQb153i0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736e6725a16b3cb80ac7aa4040"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026e6725a16b3cb80ac7aa4040"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516e6725a16b3cb80ac7aa4040"}],"is_playable":true,"name":"Forever Favorites","release_date":"2026-04-17","release_date_precision":"day","total_tracks":66,"type":"album","uri":"spotify:album:0PmgXoT1fU4O0JhQb153i0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/40Yq4vzPs9VNUrIBG5Jr2i"},"href":"https://api.spotify.com/v1/artists/40Yq4vzPs9VNUrIBG5Jr2i","id":"40Yq4vzPs9VNUrIBG5Jr2i","name":"The Smashing Pumpkins","type":"artist","uri":"spotify:artist:40Yq4vzPs9VNUrIBG5Jr2i"}],"disc_number":1,"duration_ms":266197,"explicit":false,"external_ids":{"isrc":"USVI21200910"},"external_urls":{"spotify":"https://open.spotify.com/track/3CWxn4c8hzMfvBRQ0iApRq"},"href":"https://api.spotify.com/v1/tracks/3CWxn4c8hzMfvBRQ0iApRq","id":"3CWxn4c8hzMfvBRQ0iApRq","is_local":false,"is_playable":true,"name":"1979 - Remastered 2012","track_number":22,"type":"track","uri":"spotify:track:3CWxn4c8hzMfvBRQ0iApRq"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMjE5NzklMjIlMjBhcnRpc3QlM0ElMjJUaGUlMjBTbWFzaGluZyUyMFB1bXBraW5zJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo5LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzQwWXE0dnpQczlWTlVySUJHNUpyMmkiLCJpZCI6IjQwWXE0dnpQczlWTlVySUJHNUpyMmkiLCJuYW1lIjoiVGhlIFNtYXNoaW5nIFB1bXBraW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjQwWXE0dnpQczlWTlVySUJHNUpyMmkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81NVJoRlJ5UUZpaEl5R2Y2MU1nY2ZWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNTVSaEZSeVFGaWhJeUdmNjFNZ2NmViIsImlkIjoiNTVSaEZSeVFGaWhJeUdmNjFNZ2NmViIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0MzFhYzZlNmYzOTNhY2Y0NzU3MzBlYzYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDMxYWM2ZTZmMzkzYWNmNDc1NzMwZWM2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0MzFhYzZlNmYzOTNhY2Y0NzU3MzBlYzYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWVsbG9uIENvbGxpZSBBbmQgVGhlIEluZmluaXRlIFNhZG5lc3MgKERlbHV4ZSBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjE5OTUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6OTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NTVSaEZSeVFGaWhJeUdmNjFNZ2NmViJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzQwWXE0dnpQczlWTlVySUJHNUpyMmkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxLw==", + "YXJ0aXN0cy80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwiaWQiOiI0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwibmFtZSI6IlRoZSBTbWFzaGluZyBQdW1wa2lucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjI2NjIwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVkkyMTIwMDkxMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVFMSEd2MERmcGVYTE5GbzdTRkV5MSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVRTEhHdjBEZnBlWExORm83U0ZFeTEiLCJpZCI6IjVRTEhHdjBEZnBlWExORm83U0ZFeTEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMTk3OSAtIFJlbWFzdGVyZWQgMjAxMiIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1UUxIR3YwRGZwZVhMTkZvN1NGRXkxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzQwWXE0dnpQczlWTlVySUJHNUpyMmkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNDBZcTR2elBzOVZOVXJJQkc1SnIyaSIsImlkIjoiNDBZcTR2elBzOVZOVXJJQkc1SnIyaSIsIm5hbWUiOiJUaGUgU21hc2hpbmcgUHVtcGtpbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDBZcTR2elBzOVZOVXJJQkc1SnIyaSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFjVW5OcngyVHh2cnB3UFJ0dnBHd24ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xY1VuTnJ4MlR4dnJwd1BSdHZwR3duIiwiaWQiOiIxY1VuTnJ4MlR4dnJwd1BSdHZwR3duIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2M0OGY0MmZkYWZjZmZjZWRiZGJjZTAyNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjNDhmNDJmZGFmY2ZmY2VkYmRiY2UwMjUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM0OGY0MmZkYWZjZmZjZQ==", + "ZGJkYmNlMDI1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IihSb3R0ZW4gQXBwbGVzKSBUaGUgU21hc2hpbmcgUHVtcGtpbnMgR3JlYXRlc3QgSGl0cyIsInJlbGVhc2VfZGF0ZSI6IjIwMDEtMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxY1VuTnJ4MlR4dnJwd1BSdHZwR3duIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDBZcTR2elBzOVZOVXJJQkc1SnIyaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwiaWQiOiI0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwibmFtZSI6IlRoZSBTbWFzaGluZyBQdW1wa2lucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2MzU3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVkkyOTUwMDA1MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2g1emlrMzFoVFRhdDlqbXBDWlpOQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNoNXppazMxaFRUYXQ5am1wQ1paTkMiLCJpZCI6IjNoNXppazMxaFRUYXQ5am1wQ1paTkMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMTk3OSIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozaDV6aWszMWhUVGF0OWptcENaWk5DIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzQwWXE0dnpQczlWTlVySUJHNUpyMmkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNDBZcTR2elBzOVZOVXJJQkc1SnIyaSIsImlkIjoiNDBZcTR2elBzOVZOVXJJQkc1SnIyaSIsIm5hbWUiOiJUaGUgU21hc2hpbmcgUHVtcGtpbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDBZcTR2elBzOVZOVXJJQkc1SnIyaSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRiUFQ2UThwcGFTTnBwazFrYkViTGwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80YlBUNlE4cHBhUw==", + "TnBwazFrYkViTGwiLCJpZCI6IjRiUFQ2UThwcGFTTnBwazFrYkViTGwiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNGM0MmU0MDI0MDAyODY2NGY5MzlmODFjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjRjNDJlNDAyNDAwMjg2NjRmOTM5ZjgxYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNGM0MmU0MDI0MDAyODY2NGY5MzlmODFjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1lbGxvbiBDb2xsaWUgQW5kIFRoZSBJbmZpbml0ZSBTYWRuZXNzIChSZW1hc3RlcmVkKSIsInJlbGVhc2VfZGF0ZSI6IjE5OTUtMTItMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0YlBUNlE4cHBhU05wcGsxa2JFYkxsIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDBZcTR2elBzOVZOVXJJQkc1SnIyaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwiaWQiOiI0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwibmFtZSI6IlRoZSBTbWFzaGluZyBQdW1wa2lucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn1dLCJkaXNjX251bWJlciI6MiwiZHVyYXRpb25fbXMiOjI2NjIwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVkkyMTIwMDkxMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM1k4RmYxbkg0NGpGeXdBdHBnbWxlWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNZOEZmMW5INDRqRnl3QXRwZ21sZVoiLCJpZCI6IjNZOEZmMW5INDRqRnl3QXRwZ21sZVoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMTk3OSAtIFJlbWFzdGVyZWQgMjAxMiIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozWThGZjFuSDQ0akZ5d0F0cGdtbGVaIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aQ==", + "c3QvNDBZcTR2elBzOVZOVXJJQkc1SnIyaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwiaWQiOiI0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwibmFtZSI6IlRoZSBTbWFzaGluZyBQdW1wa2lucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNm5ycHBqUHR5RlJXb1piVkp5UXFnayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZucnBwalB0eUZSV29aYlZKeVFxZ2siLCJpZCI6IjZucnBwalB0eUZSV29aYlZKeVFxZ2siLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjA0ZWQ5MmRjYTk2MTFiZGNkMzEyMGIzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmYwNGVkOTJkY2E5NjExYmRjZDMxMjBiMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjA0ZWQ5MmRjYTk2MTFiZGNkMzEyMGIzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1lbGxvbiBDb2xsaWUgQW5kIFRoZSBJbmZpbml0ZSBTYWRuZXNzICgzMHRoIEFubml2ZXJzYXJ5IEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0xMS0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZucnBwalB0eUZSV29aYlZKeVFxZ2sifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzQwWXE0dnpQczlWTlVySUJHNUpyMmkiLCJpZCI6IjQwWXE0dnpQczlWTlVySUJHNUpyMmkiLCJuYW1lIjoiVGhlIFNtYXNoaW5nIFB1bXBraW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjQwWXE0dnpQczlWTlVySUJHNUpyMmkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY2MTk3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNWSTIxMjAwOTEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cg==", + "YWNrLzBqaUVLajBmWGV2Y3Y0NkpYVWRjS2gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wamlFS2owZlhldmN2NDZKWFVkY0toIiwiaWQiOiIwamlFS2owZlhldmN2NDZKWFVkY0toIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjE5NzkiLCJ0cmFja19udW1iZXIiOjE5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBqaUVLajBmWGV2Y3Y0NkpYVWRjS2gifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkV2MHJYanNZQndZMWNSenRHbjRNWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJFdjByWGpzWUJ3WTFjUnp0R240TVoiLCJpZCI6IjJFdjByWGpzWUJ3WTFjUnp0R240TVoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2E4ZmQ5ZTIwZjc0MWRlYmY5ZWIzZjQ4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdhOGZkOWUyMGY3NDFkZWJmOWViM2Y0OCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2E4ZmQ5ZTIwZjc0MWRlYmY5ZWIzZjQ4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjkwcyBTdW1tZXIgTm9zdGFsZ2lhIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wOC0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJFdjByWGpzWUJ3WTFjUnp0R240TVoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbQ==", + "L3YxL2FydGlzdHMvNDBZcTR2elBzOVZOVXJJQkc1SnIyaSIsImlkIjoiNDBZcTR2elBzOVZOVXJJQkc1SnIyaSIsIm5hbWUiOiJUaGUgU21hc2hpbmcgUHVtcGtpbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDBZcTR2elBzOVZOVXJJQkc1SnIyaSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjYxOTcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1ZJMjEyMDA5MTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzMxcWZYWDlqWVFGcHFDQ0lIUlcxRksifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zMXFmWFg5allRRnBxQ0NJSFJXMUZLIiwiaWQiOiIzMXFmWFg5allRRnBxQ0NJSFJXMUZLIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjE5NzkgLSBSZW1hc3RlcmVkIDIwMTIiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MzFxZlhYOWpZUUZwcUNDSUhSVzFGSyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81cUxBUjZHRlRkUVNGRG91eHlZYzJtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNXFMQVI2R0ZUZFFTRkRvdXh5WWMybSIsImlkIjoiNXFMQVI2R0ZUZFFTRkRvdXh5WWMybSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5NmMwNjE1YjBhMTk3OGVmM2U5ZjJlOTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTZjMDYxNWIwYTE5NzhlZjNlOWYyZTk4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5NmMwNjE1YjBhMTk3OGVmMw==", + "ZTlmMmU5OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCZXN0IFJvY2sgRXZlciIsInJlbGVhc2VfZGF0ZSI6IjIwMTktMDctMTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0MCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1cUxBUjZHRlRkUVNGRG91eHlZYzJtIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDBZcTR2elBzOVZOVXJJQkc1SnIyaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwiaWQiOiI0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwibmFtZSI6IlRoZSBTbWFzaGluZyBQdW1wa2lucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2NjE5NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVkkyMTIwMDkxMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNW5mZkdCeVpOTTJrUGNKNVlxQ2k3YSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVuZmZHQnlaTk0ya1BjSjVZcUNpN2EiLCJpZCI6IjVuZmZHQnlaTk0ya1BjSjVZcUNpN2EiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMTk3OSAtIFJlbWFzdGVyZWQgMjAxMiIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NW5mZkdCeVpOTTJrUGNKNVlxQ2k3YSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82YXBsdjY5NURGeUtPZXQ4MkFXMUp0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNmFwbHY2OTVERnlLT2V0ODJBVzFKdCIsImlkIjoiNg==", + "YXBsdjY5NURGeUtPZXQ4MkFXMUp0IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2E3YWM5N2JhODhlMjMzMmUxMDZmMjJiNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhN2FjOTdiYTg4ZTIzMzJlMTA2ZjIyYjUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWE3YWM5N2JhODhlMjMzMmUxMDZmMjJiNSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiI5MCdzIEdydW5nZS9Sb2NrIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wMi0wNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjcyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZhcGx2Njk1REZ5S09ldDgyQVcxSnQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzQwWXE0dnpQczlWTlVySUJHNUpyMmkiLCJpZCI6IjQwWXE0dnpQczlWTlVySUJHNUpyMmkiLCJuYW1lIjoiVGhlIFNtYXNoaW5nIFB1bXBraW5zIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjQwWXE0dnpQczlWTlVySUJHNUpyMmkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY2MTk3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNWSTIxMjAwOTEwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80Q1RoUHNZTnFkZW44YWdEdDJuaXZEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNENUaFBzWU5xZGVuOGFnRHQybml2RCIsImlkIjoiNENUaFBzWU5xZGVuOGFnRHQybml2RCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiIxOTc5IC0gUmVtYXN0ZXJlZCAyMDEyIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRDVGhQc1lOcWRlbjhhZ0R0Mm5pdkQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkucw==", + "cG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yTDVLRHN6Z21udjlaQ2VMdVV4YzZ1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMkw1S0RzemdtbnY5WkNlTHVVeGM2dSIsImlkIjoiMkw1S0RzemdtbnY5WkNlTHVVeGM2dSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmMWIzZGE1OTg2MTMyNDYxYjMyMzU2NjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjFiM2RhNTk4NjEzMjQ2MWIzMjM1NjYxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmMWIzZGE1OTg2MTMyNDYxYjMyMzU2NjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU29uZ3MgVGhhdCBGZWVsIExpa2UgRmFsbCIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMTAtMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0NiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyTDVLRHN6Z21udjlaQ2VMdVV4YzZ1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNDBZcTR2elBzOVZOVXJJQkc1SnIyaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwiaWQiOiI0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIiwibmFtZSI6IlRoZSBTbWFzaGluZyBQdW1wa2lucyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2NjE5NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVkkyMTIwMDkxMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHZGSXVoVUwwY0hsNm14NmJvcGxUeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzB2Rkl1aFVMMGNIbDZteDZib3BsVHkiLA==", + "ImlkIjoiMHZGSXVoVUwwY0hsNm14NmJvcGxUeSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiIxOTc5IC0gUmVtYXN0ZXJlZCAyMDEyIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjB2Rkl1aFVMMGNIbDZteDZib3BsVHkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMFBtZ1hvVDFmVTRPMEpoUWIxNTNpMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBQbWdYb1QxZlU0TzBKaFFiMTUzaTAiLCJpZCI6IjBQbWdYb1QxZlU0TzBKaFFiMTUzaTAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmU2NzI1YTE2YjNjYjgwYWM3YWE0MDQwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZlNjcyNWExNmIzY2I4MGFjN2FhNDA0MCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmU2NzI1YTE2YjNjYjgwYWM3YWE0MDQwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZvcmV2ZXIgRmF2b3JpdGVzIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNC0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjY2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBQbWdYb1QxZlU0TzBKaFFiMTUzaTAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80MFlxNHZ6UHM5Vk5VcklCRzVKcjJpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzQwWXE0dnpQczlWTlVySUJHNUpyMmkiLCJpZCI6IjQwWXE0dnpQczlWTlVySUJHNUpyMmkiLCJuYW1lIjoiVGhlIFNtYQ==", + "c2hpbmcgUHVtcGtpbnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDBZcTR2elBzOVZOVXJJQkc1SnIyaSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjYxOTcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1ZJMjEyMDA5MTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNDV3huNGM4aHpNZnZCUlEwaUFwUnEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zQ1d4bjRjOGh6TWZ2QlJRMGlBcFJxIiwiaWQiOiIzQ1d4bjRjOGh6TWZ2QlJRMGlBcFJxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjE5NzkgLSBSZW1hc3RlcmVkIDIwMTIiLCJ0cmFja19udW1iZXIiOjIyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNDV3huNGM4aHpNZnZCUlEwaUFwUnEifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%221979%22+artist%3A%22The+Smashing+Pumpkins%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Zombie%22%20artist%3A%22The%20Cranberries%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":6,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7t0rwkOPGlDPEhaOcVtOt9"},"href":"https://api.spotify.com/v1/artists/7t0rwkOPGlDPEhaOcVtOt9","id":"7t0rwkOPGlDPEhaOcVtOt9","name":"The Cranberries","type":"artist","uri":"spotify:artist:7t0rwkOPGlDPEhaOcVtOt9"}],"external_urls":{"spotify":"https://open.spotify.com/album/5zjZVqXPI7J5qtBsZMjlI8"},"href":"https://api.spotify.com/v1/albums/5zjZVqXPI7J5qtBsZMjlI8","id":"5zjZVqXPI7J5qtBsZMjlI8","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d6e06307a0b89eb7586716e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d6e06307a0b89eb7586716e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d6e06307a0b89eb7586716e7"}],"is_playable":true,"name":"Gold","release_date":"2008-03-11","release_date_precision":"day","total_tracks":31,"type":"album","uri":"spotify:album:5zjZVqXPI7J5qtBsZMjlI8"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7t0rwkOPGlDPEhaOcVtOt9"},"href":"https://api.spotify.com/v1/artists/7t0rwkOPGlDPEhaOcVtOt9","id":"7t0rwkOPGlDPEhaOcVtOt9","name":"The Cranberries","type":"artist","uri":"spotify:artist:7t0rwkOPGlDPEhaOcVtOt9"}],"disc_number":1,"duration_ms":307520,"explicit":false,"external_ids":{"isrc":"USIR29400443"},"external_urls":{"spotify":"https://open.spotify.com/track/49wOjOkS4pBK3PQnPnNYjb"},"href":"https://api.spotify.com/v1/tracks/49wOjOkS4pBK3PQnPnNYjb","id":"49wOjOkS4pBK3PQnPnNYjb","is_local":false,"is_playable":true,"name":"Zombie","track_number":8,"type":"track","uri":"spotify:track:49wOjOkS4pBK3PQnPnNYjb"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7t0rwkOPGlDPEhaOcVtOt9"},"href":"https://api.spotify.com/v1/artists/7t0rwkOPGlDPEhaOcVtOt9","id":"7t0rwkOPGlDPEhaOcVtOt9","name":"The Cranberries","type":"artist","uri":"spotify:artist:7t0rwkOPGlDPEhaOcVtOt9"}],"external_urls":{"spotify":"https://open.spotify.com/album/6E2UIe7qUVYi6v2fVbGddX"},"href":"https://api.spotify.com/v1/albums/6E2UIe7qUVYi6v2fVbGddX","id":"6E2UIe7qUVYi6v2fVbGddX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27320a28883cdd0fc7d5f85a9a9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0220a28883cdd0fc7d5f85a9a9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485120a28883cdd0fc7d5f85a9a9"}],"is_playable":true,"name":"No Need To Argue (2025 Remastered)","release_date":"1994","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:6E2UIe7qUVYi6v2fVbGddX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7t0rwkOPGlDPEhaOcVtOt9"},"href":"https://api.spotify.com/v1/artists/7t0rwkOPGlDPEhaOcVtOt9","id":"7t0rwkOPGlDPEhaOcVtOt9","name":"The Cranberries","type":"artist","uri":"spotify:artist:7t0rwkOPGlDPEhaOcVtOt9"}],"disc_number":1,"duration_ms":305626,"explicit":false,"external_ids":{"isrc":"USUM72009888"},"external_urls":{"spotify":"https://open.spotify.com/track/3gjHnylel3PTRpjS44ocqr"},"href":"https://api.spotify.com/v1/tracks/3gjHnylel3PTRpjS44ocqr","id":"3gjHnylel3PTRpjS44ocqr","is_local":false,"is_playable":true,"name":"Zombie - 2025 Remastered","track_number":4,"type":"track","uri":"spotify:track:3gjHnylel3PTRpjS44ocqr"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ZI75nwlv0bbAiYB3sX5xz"},"href":"https://api.spotify.com/v1/albums/3ZI75nwlv0bbAiYB3sX5xz","id":"3ZI75nwlv0bbAiYB3sX5xz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732f8a30b256d4edc4da189851"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022f8a30b256d4edc4da189851"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512f8a30b256d4edc4da189851"}],"is_playable":true,"name":"The Very Best of Rock","release_date":"2023-10-26","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:3ZI75nwlv0bbAiYB3sX5xz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7t0rwkOPGlDPEhaOcVtOt9"},"href":"https://api.spotify.com/v1/artists/7t0rwkOPGlDPEhaOcVtOt9","id":"7t0rwkOPGlDPEhaOcVtOt9","name":"The Cranberries","type":"artist","uri":"spotify:artist:7t0rwkOPGlDPEhaOcVtOt9"}],"disc_number":1,"duration_ms":307440,"explicit":false,"external_ids":{"isrc":"USIR29400443"},"external_urls":{"spotify":"https://open.spotify.com/track/00A4MqA6ENV2U5OciLbPuK"},"href":"https://api.spotify.com/v1/tracks/00A4MqA6ENV2U5OciLbPuK","id":"00A4MqA6ENV2U5OciLbPuK","is_local":false,"is_playable":true,"name":"Zombie","track_number":5,"type":"track","uri":"spotify:track:00A4MqA6ENV2U5OciLbPuK"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7t0rwkOPGlDPEhaOcVtOt9"},"href":"https://api.spotify.com/v1/artists/7t0rwkOPGlDPEhaOcVtOt9","id":"7t0rwkOPGlDPEhaOcVtOt9","name":"The Cranberries","type":"artist","uri":"spotify:artist:7t0rwkOPGlDPEhaOcVtOt9"}],"external_urls":{"spotify":"https://open.spotify.com/album/4yRohkbSHhDhlmqlcnY1AE"},"href":"https://api.spotify.com/v1/albums/4yRohkbSHhDhlmqlcnY1AE","id":"4yRohkbSHhDhlmqlcnY1AE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736a9239356b0d3d29f184aa66"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026a9239356b0d3d29f184aa66"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516a9239356b0d3d29f184aa66"}],"is_playable":true,"name":"20th Century Masters - The Millennium Collection: The Best Of The Cranberries","release_date":"2005-09-27","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4yRohkbSHhDhlmqlcnY1AE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7t0rwkOPGlDPEhaOcVtOt9"},"href":"https://api.spotify.com/v1/artists/7t0rwkOPGlDPEhaOcVtOt9","id":"7t0rwkOPGlDPEhaOcVtOt9","name":"The Cranberries","type":"artist","uri":"spotify:artist:7t0rwkOPGlDPEhaOcVtOt9"}],"disc_number":1,"duration_ms":307440,"explicit":false,"external_ids":{"isrc":"USIR29400443"},"external_urls":{"spotify":"https://open.spotify.com/track/0vrZoFXahwpthoKGWI4L96"},"href":"https://api.spotify.com/v1/tracks/0vrZoFXahwpthoKGWI4L96","id":"0vrZoFXahwpthoKGWI4L96","is_local":false,"is_playable":true,"name":"Zombie","track_number":3,"type":"track","uri":"spotify:track:0vrZoFXahwpthoKGWI4L96"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2H6DPjcMaPbCZzxINySIQD"},"href":"https://api.spotify.com/v1/albums/2H6DPjcMaPbCZzxINySIQD","id":"2H6DPjcMaPbCZzxINySIQD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bb01568108f9156dbfe59684"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bb01568108f9156dbfe59684"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bb01568108f9156dbfe59684"}],"is_playable":true,"name":"Het Beste Uit De Top 2000 (Editie 2017)","release_date":"2017-11-17","release_date_precision":"day","total_tracks":36,"type":"album","uri":"spotify:album:2H6DPjcMaPbCZzxINySIQD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7t0rwkOPGlDPEhaOcVtOt9"},"href":"https://api.spotify.com/v1/artists/7t0rwkOPGlDPEhaOcVtOt9","id":"7t0rwkOPGlDPEhaOcVtOt9","name":"The Cranberries","type":"artist","uri":"spotify:artist:7t0rwkOPGlDPEhaOcVtOt9"}],"disc_number":1,"duration_ms":308613,"explicit":false,"external_ids":{"isrc":"USIR29400443"},"external_urls":{"spotify":"https://open.spotify.com/track/7GIAm1i4I6XYA6PURMFO8H"},"href":"https://api.spotify.com/v1/tracks/7GIAm1i4I6XYA6PURMFO8H","id":"7GIAm1i4I6XYA6PURMFO8H","is_local":false,"is_playable":true,"name":"Zombie","track_number":11,"type":"track","uri":"spotify:track:7GIAm1i4I6XYA6PURMFO8H"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6poU48oc5zPTjUh04ljWUT"},"href":"https://api.spotify.com/v1/albums/6poU48oc5zPTjUh04ljWUT","id":"6poU48oc5zPTjUh04ljWUT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739237a283d2d017ca3bf1edd6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029237a283d2d017ca3bf1edd6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519237a283d2d017ca3bf1edd6"}],"is_playable":true,"name":"Yellowjackets Season 2 (Music From The Original Series)","release_date":"2023-10-20","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:6poU48oc5zPTjUh04ljWUT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7t0rwkOPGlDPEhaOcVtOt9"},"href":"https://api.spotify.com/v1/artists/7t0rwkOPGlDPEhaOcVtOt9","id":"7t0rwkOPGlDPEhaOcVtOt9","name":"The Cranberries","type":"artist","uri":"spotify:artist:7t0rwkOPGlDPEhaOcVtOt9"}],"disc_number":1,"duration_ms":308767,"explicit":false,"external_ids":{"isrc":"USIR29400443"},"external_urls":{"spotify":"https://open.spotify.com/track/38IKCoILT0uq0ZCI1HLAW7"},"href":"https://api.spotify.com/v1/tracks/38IKCoILT0uq0ZCI1HLAW7","id":"38IKCoILT0uq0ZCI1HLAW7","is_local":false,"is_playable":true,"name":"Zombie","track_number":5,"type":"track","uri":"spotify:track:38IKCoILT0uq0ZCI1HLAW7"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlpvbWJpZSUyMiUyMGFydGlzdCUzQSUyMlRoZSUyMENyYW5iZXJyaWVzJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo2LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83dDByd2tPUEdsRFBFaGFPY1Z0T3Q5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd0MHJ3a09QR2xEUEVoYU9jVnRPdDkiLCJpZCI6Ijd0MHJ3a09QR2xEUEVoYU9jVnRPdDkiLCJuYW1lIjoiVGhlIENyYW5iZXJyaWVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd0MHJ3a09QR2xEUEVoYU9jVnRPdDkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81empaVnFYUEk3SjVxdEJzWk1qbEk4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNXpqWlZxWFBJN0o1cXRCc1pNamxJOCIsImlkIjoiNXpqWlZxWFBJN0o1cXRCc1pNamxJOCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8v", + "aS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkNmUwNjMwN2EwYjg5ZWI3NTg2NzE2ZTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZDZlMDYzMDdhMGI4OWViNzU4NjcxNmU3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkNmUwNjMwN2EwYjg5ZWI3NTg2NzE2ZTcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR29sZCIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMDMtMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1empaVnFYUEk3SjVxdEJzWk1qbEk4In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3QwcndrT1BHbERQRWhhT2NWdE90OSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwiaWQiOiI3dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwibmFtZSI6IlRoZSBDcmFuYmVycmllcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3dDByd2tPUEdsRFBFaGFPY1Z0T3Q5In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwNzUyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSVIyOTQwMDQ0MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDl3T2pPa1M0cEJLM1BRblBuTllqYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQ5d09qT2tTNHBCSzNQUW5Qbk5ZamIiLCJpZCI6IjQ5d09qT2tTNHBCSzNQUW5Qbk5ZamIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWm9tYmllIiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjQ5d09qT2tTNHBCSzNQUW5Qbk5ZamIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3QwcndrT1BHbERQRWhhT2NWdE90OSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwiaWQiOiI3dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwibmFtZSI6IlRoZSBDcmFuYmVycmllcyIsInR5cGUiOiJhcnRpcw==", + "dCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd0MHJ3a09QR2xEUEVoYU9jVnRPdDkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82RTJVSWU3cVVWWWk2djJmVmJHZGRYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNkUyVUllN3FVVllpNnYyZlZiR2RkWCIsImlkIjoiNkUyVUllN3FVVllpNnYyZlZiR2RkWCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMyMGEyODg4M2NkZDBmYzdkNWY4NWE5YTkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMjBhMjg4ODNjZGQwZmM3ZDVmODVhOWE5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyMGEyODg4M2NkZDBmYzdkNWY4NWE5YTkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTm8gTmVlZCBUbyBBcmd1ZSAoMjAyNSBSZW1hc3RlcmVkKSIsInJlbGVhc2VfZGF0ZSI6IjE5OTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkUyVUllN3FVVllpNnYyZlZiR2RkWCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzd0MHJ3a09QR2xEUEVoYU9jVnRPdDkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN3QwcndrT1BHbERQRWhhT2NWdE90OSIsImlkIjoiN3QwcndrT1BHbERQRWhhT2NWdE90OSIsIm5hbWUiOiJUaGUgQ3JhbmJlcnJpZXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N3QwcndrT1BHbERQRWhhT2NWdE90OSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDU2MjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzIwMDk4ODgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNnakhueWxlbDNQVFJwalM0NG9jcXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zZ2pIbnlsZWwzUFRScGpTNDRvY3FyIiwiaWQiOiIzZ2pIbnlsZWwzUFRScGpTNDRvY3FyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlpvbWJpZSAtIDIwMjUgUmVtYXN0ZXJlZCIsInRyYWNrX251bWJlciI6NA==", + "LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNnakhueWxlbDNQVFJwalM0NG9jcXIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM1pJNzVud2x2MGJiQWlZQjNzWDV4eiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNaSTc1bndsdjBiYkFpWUIzc1g1eHoiLCJpZCI6IjNaSTc1bndsdjBiYkFpWUIzc1g1eHoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMmY4YTMwYjI1NmQ0ZWRjNGRhMTg5ODUxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjJmOGEzMGIyNTZkNGVkYzRkYTE4OTg1MSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMmY4YTMwYjI1NmQ0ZWRjNGRhMTg5ODUxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBWZXJ5IEJlc3Qgb2YgUm9jayIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMTAtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozWkk3NW53bHYwYmJBaVlCM3NYNXh6In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3QwcndrT1BHbERQRWhhT2NWdE90OSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwiaWQiOiI3dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwibmFtZSI6IlRoZSBDcmFuYmVycmllcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3dDByd2tPUEdsRFBFaGFPY1Z0T3Q5In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwNzQ0MA==", + "LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNJUjI5NDAwNDQzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wMEE0TXFBNkVOVjJVNU9jaUxiUHVLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDBBNE1xQTZFTlYyVTVPY2lMYlB1SyIsImlkIjoiMDBBNE1xQTZFTlYyVTVPY2lMYlB1SyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJab21iaWUiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MDBBNE1xQTZFTlYyVTVPY2lMYlB1SyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83dDByd2tPUEdsRFBFaGFPY1Z0T3Q5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd0MHJ3a09QR2xEUEVoYU9jVnRPdDkiLCJpZCI6Ijd0MHJ3a09QR2xEUEVoYU9jVnRPdDkiLCJuYW1lIjoiVGhlIENyYW5iZXJyaWVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd0MHJ3a09QR2xEUEVoYU9jVnRPdDkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80eVJvaGtiU0hoRGhsbXFsY25ZMUFFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHlSb2hrYlNIaERobG1xbGNuWTFBRSIsImlkIjoiNHlSb2hrYlNIaERobG1xbGNuWTFBRSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2YTkyMzkzNTZiMGQzZDI5ZjE4NGFhNjYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNmE5MjM5MzU2YjBkM2QyOWYxODRhYTY2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2YTkyMzkzNTZiMGQzZDI5ZjE4NGFhNjYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiMjB0aCBDZW50dXJ5IE1hc3RlcnMgLSBUaGUgTWlsbGVubml1bSBDb2xsZWN0aW9uOiBUaGUgQmVzdCBPZiBUaGUgQ3JhbmJlcnJpZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTA5LTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaQ==", + "Ijoic3BvdGlmeTphbGJ1bTo0eVJvaGtiU0hoRGhsbXFsY25ZMUFFIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3QwcndrT1BHbERQRWhhT2NWdE90OSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwiaWQiOiI3dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwibmFtZSI6IlRoZSBDcmFuYmVycmllcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3dDByd2tPUEdsRFBFaGFPY1Z0T3Q5In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwNzQ0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSVIyOTQwMDQ0MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHZyWm9GWGFod3B0aG9LR1dJNEw5NiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzB2clpvRlhhaHdwdGhvS0dXSTRMOTYiLCJpZCI6IjB2clpvRlhhaHdwdGhvS0dXSTRMOTYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWm9tYmllIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjB2clpvRlhhaHdwdGhvS0dXSTRMOTYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkg2RFBqY01hUGJDWnp4SU55U0lRRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJINkRQamNNYVBiQ1p6eElOeVNJUUQiLCJpZCI6IjJINkRQamNNYVBiQ1p6eElOeVNJUUQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYmIwMTU2ODEwOGY5MTU2ZGJmZTU5Njg0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Lw==", + "L2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmIwMTU2ODEwOGY5MTU2ZGJmZTU5Njg0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiYjAxNTY4MTA4ZjkxNTZkYmZlNTk2ODQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGV0IEJlc3RlIFVpdCBEZSBUb3AgMjAwMCAoRWRpdGllIDIwMTcpIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0xMS0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJINkRQamNNYVBiQ1p6eElOeVNJUUQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83dDByd2tPUEdsRFBFaGFPY1Z0T3Q5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzd0MHJ3a09QR2xEUEVoYU9jVnRPdDkiLCJpZCI6Ijd0MHJ3a09QR2xEUEVoYU9jVnRPdDkiLCJuYW1lIjoiVGhlIENyYW5iZXJyaWVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojd0MHJ3a09QR2xEUEVoYU9jVnRPdDkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzA4NjEzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNJUjI5NDAwNDQzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83R0lBbTFpNEk2WFlBNlBVUk1GTzhIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN0dJQW0xaTRJNlhZQTZQVVJNRk84SCIsImlkIjoiN0dJQW0xaTRJNlhZQTZQVVJNRk84SCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJab21iaWUiLCJ0cmFja19udW1iZXIiOjExLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdHSUFtMWk0STZYWUE2UFVSTUZPOEgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcg==", + "bmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82cG9VNDhvYzV6UFRqVWgwNGxqV1VUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnBvVTQ4b2M1elBUalVoMDRsaldVVCIsImlkIjoiNnBvVTQ4b2M1elBUalVoMDRsaldVVCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5MjM3YTI4M2QyZDAxN2NhM2JmMWVkZDYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTIzN2EyODNkMmQwMTdjYTNiZjFlZGQ2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5MjM3YTI4M2QyZDAxN2NhM2JmMWVkZDYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWWVsbG93amFja2V0cyBTZWFzb24gMiAoTXVzaWMgRnJvbSBUaGUgT3JpZ2luYWwgU2VyaWVzKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMTAtMjAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2cG9VNDhvYzV6UFRqVWgwNGxqV1VUIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN3QwcndrT1BHbERQRWhhT2NWdE90OSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwiaWQiOiI3dDByd2tPUEdsRFBFaGFPY1Z0T3Q5IiwibmFtZSI6IlRoZSBDcmFuYmVycmllcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3dDByd2tPUEdsRFBFaGFPY1Z0T3Q5In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMwODc2NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSVIyOTQwMDQ0MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMzhJS0NvSUxUMHVxMFpDSTFITEFXNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzM4SUtDb0lMVDB1cTBaQ0kxSExBVzciLCJpZCI6IjM4SUtDb0lMVDB1cTBaQ0kxSExBVzciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWm9tYmllIiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjM4SUtDb0lMVDB1cQ==", + "MFpDSTFITEFXNyJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Zombie%22+artist%3A%22The+Cranberries%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22C%27mon%20N%27%20Ride%20It%20%28The%20Train%29%22%20artist%3A%22Quad%20City%20DJ%27s%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"external_urls":{"spotify":"https://open.spotify.com/album/1xipzu4eNAdr8oBnqP0eaS"},"href":"https://api.spotify.com/v1/albums/1xipzu4eNAdr8oBnqP0eaS","id":"1xipzu4eNAdr8oBnqP0eaS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731f01cd016c3c1bc834778fa7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021f01cd016c3c1bc834778fa7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511f01cd016c3c1bc834778fa7"}],"is_playable":true,"name":"Get On Up And Dance","release_date":"1996","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:1xipzu4eNAdr8oBnqP0eaS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":451440,"explicit":false,"external_ids":{"isrc":"USAT20103455"},"external_urls":{"spotify":"https://open.spotify.com/track/2QLEN3RVunMas7j0PHjeAT"},"href":"https://api.spotify.com/v1/tracks/2QLEN3RVunMas7j0PHjeAT","id":"2QLEN3RVunMas7j0PHjeAT","is_local":false,"is_playable":true,"name":"C'mon N' Ride It (The Train)","track_number":1,"type":"track","uri":"spotify:track:2QLEN3RVunMas7j0PHjeAT"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"external_urls":{"spotify":"https://open.spotify.com/album/16nDsAEdUFbq21g5RcWYiJ"},"href":"https://api.spotify.com/v1/albums/16nDsAEdUFbq21g5RcWYiJ","id":"16nDsAEdUFbq21g5RcWYiJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f4fde867b6197000749d2c69"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f4fde867b6197000749d2c69"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f4fde867b6197000749d2c69"}],"is_playable":true,"name":"C'mon N' Ride It (The Train)","release_date":"1996-06-25","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:16nDsAEdUFbq21g5RcWYiJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":248373,"explicit":false,"external_ids":{"isrc":"USAT20623735"},"external_urls":{"spotify":"https://open.spotify.com/track/7AYr5rYQFXJzLSJK9vx6om"},"href":"https://api.spotify.com/v1/tracks/7AYr5rYQFXJzLSJK9vx6om","id":"7AYr5rYQFXJzLSJK9vx6om","is_local":false,"is_playable":true,"name":"C'mon N' Ride It (The Train) - Radio Mix","track_number":2,"type":"track","uri":"spotify:track:7AYr5rYQFXJzLSJK9vx6om"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"external_urls":{"spotify":"https://open.spotify.com/album/1xipzu4eNAdr8oBnqP0eaS"},"href":"https://api.spotify.com/v1/albums/1xipzu4eNAdr8oBnqP0eaS","id":"1xipzu4eNAdr8oBnqP0eaS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731f01cd016c3c1bc834778fa7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021f01cd016c3c1bc834778fa7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511f01cd016c3c1bc834778fa7"}],"is_playable":true,"name":"Get On Up And Dance","release_date":"1996","release_date_precision":"year","total_tracks":13,"type":"album","uri":"spotify:album:1xipzu4eNAdr8oBnqP0eaS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":485040,"explicit":false,"external_ids":{"isrc":"USAT20103456"},"external_urls":{"spotify":"https://open.spotify.com/track/1YDQ5dDGadJtrmpEqDz4J4"},"href":"https://api.spotify.com/v1/tracks/1YDQ5dDGadJtrmpEqDz4J4","id":"1YDQ5dDGadJtrmpEqDz4J4","is_local":false,"is_playable":true,"name":"C'mon N' Ride It (The Train) - Dance Remix","track_number":13,"type":"track","uri":"spotify:track:1YDQ5dDGadJtrmpEqDz4J4"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"external_urls":{"spotify":"https://open.spotify.com/album/16nDsAEdUFbq21g5RcWYiJ"},"href":"https://api.spotify.com/v1/albums/16nDsAEdUFbq21g5RcWYiJ","id":"16nDsAEdUFbq21g5RcWYiJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f4fde867b6197000749d2c69"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f4fde867b6197000749d2c69"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f4fde867b6197000749d2c69"}],"is_playable":true,"name":"C'mon N' Ride It (The Train)","release_date":"1996-06-25","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:16nDsAEdUFbq21g5RcWYiJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":453866,"explicit":false,"external_ids":{"isrc":"USAT20623738"},"external_urls":{"spotify":"https://open.spotify.com/track/7hC3GVxJh4l6RayGGX6YDJ"},"href":"https://api.spotify.com/v1/tracks/7hC3GVxJh4l6RayGGX6YDJ","id":"7hC3GVxJh4l6RayGGX6YDJ","is_local":false,"is_playable":true,"name":"C'mon N' Ride It (The Train) - Club Mix","track_number":1,"type":"track","uri":"spotify:track:7hC3GVxJh4l6RayGGX6YDJ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5RGm1hliGZ2UTXyOsAunre"},"href":"https://api.spotify.com/v1/albums/5RGm1hliGZ2UTXyOsAunre","id":"5RGm1hliGZ2UTXyOsAunre","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f7f317af78f724cdaa282115"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f7f317af78f724cdaa282115"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f7f317af78f724cdaa282115"}],"is_playable":true,"name":"70s, 80s, 90s & 2000s","release_date":"2025-03-15","release_date_precision":"day","total_tracks":63,"type":"album","uri":"spotify:album:5RGm1hliGZ2UTXyOsAunre"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":451440,"explicit":false,"external_ids":{"isrc":"USAT20103455"},"external_urls":{"spotify":"https://open.spotify.com/track/5EylQueBZsm6IkMgbUlqWB"},"href":"https://api.spotify.com/v1/tracks/5EylQueBZsm6IkMgbUlqWB","id":"5EylQueBZsm6IkMgbUlqWB","is_local":false,"is_playable":true,"name":"C'mon n' Ride It (The Train)","track_number":35,"type":"track","uri":"spotify:track:5EylQueBZsm6IkMgbUlqWB"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2UhdjFthoaXB0nGpQwsslP"},"href":"https://api.spotify.com/v1/albums/2UhdjFthoaXB0nGpQwsslP","id":"2UhdjFthoaXB0nGpQwsslP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733b17b346c608b219ed3a1874"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023b17b346c608b219ed3a1874"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513b17b346c608b219ed3a1874"}],"is_playable":true,"name":"90's Dance Classics","release_date":"2017-02-11","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:2UhdjFthoaXB0nGpQwsslP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":451440,"explicit":false,"external_ids":{"isrc":"USAT20103455"},"external_urls":{"spotify":"https://open.spotify.com/track/5ilvWSPmAyUUwZsNmWfVMd"},"href":"https://api.spotify.com/v1/tracks/5ilvWSPmAyUUwZsNmWfVMd","id":"5ilvWSPmAyUUwZsNmWfVMd","is_local":false,"is_playable":true,"name":"C'mon N' Ride It (The Train)","track_number":9,"type":"track","uri":"spotify:track:5ilvWSPmAyUUwZsNmWfVMd"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1iSde2pm2FFAWNl8X6WYrc"},"href":"https://api.spotify.com/v1/albums/1iSde2pm2FFAWNl8X6WYrc","id":"1iSde2pm2FFAWNl8X6WYrc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bc0d8d05553a8bd740a4b03b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bc0d8d05553a8bd740a4b03b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bc0d8d05553a8bd740a4b03b"}],"is_playable":true,"name":"90s Rap","release_date":"2018-04-20","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:1iSde2pm2FFAWNl8X6WYrc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":451440,"explicit":false,"external_ids":{"isrc":"USAT20103455"},"external_urls":{"spotify":"https://open.spotify.com/track/2CAPipBcfS9wxcvanCQrWn"},"href":"https://api.spotify.com/v1/tracks/2CAPipBcfS9wxcvanCQrWn","id":"2CAPipBcfS9wxcvanCQrWn","is_local":false,"is_playable":true,"name":"C'mon 'N' Ride It (The Train)","track_number":12,"type":"track","uri":"spotify:track:2CAPipBcfS9wxcvanCQrWn"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2sLSNHCBCX0Uhjr3I2wt3v"},"href":"https://api.spotify.com/v1/albums/2sLSNHCBCX0Uhjr3I2wt3v","id":"2sLSNHCBCX0Uhjr3I2wt3v","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c16fe8562b7677a83d5ea908"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c16fe8562b7677a83d5ea908"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c16fe8562b7677a83d5ea908"}],"is_playable":true,"name":"US 90's Hits","release_date":"2023-06-26","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:2sLSNHCBCX0Uhjr3I2wt3v"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":451440,"explicit":false,"external_ids":{"isrc":"USAT20103455"},"external_urls":{"spotify":"https://open.spotify.com/track/3N5hRoTAqqueO0tXwFuRar"},"href":"https://api.spotify.com/v1/tracks/3N5hRoTAqqueO0tXwFuRar","id":"3N5hRoTAqqueO0tXwFuRar","is_local":false,"is_playable":true,"name":"C'mon n' Ride It (The Train)","track_number":33,"type":"track","uri":"spotify:track:3N5hRoTAqqueO0tXwFuRar"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5mSI9qmzJHay53bxbtZwr4"},"href":"https://api.spotify.com/v1/albums/5mSI9qmzJHay53bxbtZwr4","id":"5mSI9qmzJHay53bxbtZwr4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a715338d9cc008789f722b05"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a715338d9cc008789f722b05"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a715338d9cc008789f722b05"}],"is_playable":true,"name":"90s Hip-Hop","release_date":"2019-08-23","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:5mSI9qmzJHay53bxbtZwr4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":451440,"explicit":false,"external_ids":{"isrc":"USAT20103455"},"external_urls":{"spotify":"https://open.spotify.com/track/4eb1bBXJjppWMI5zFD48VY"},"href":"https://api.spotify.com/v1/tracks/4eb1bBXJjppWMI5zFD48VY","id":"4eb1bBXJjppWMI5zFD48VY","is_local":false,"is_playable":true,"name":"C'mon 'N' Ride It (The Train)","track_number":19,"type":"track","uri":"spotify:track:4eb1bBXJjppWMI5zFD48VY"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4CGGXDCjvY2ThUZXyv87Fz"},"href":"https://api.spotify.com/v1/albums/4CGGXDCjvY2ThUZXyv87Fz","id":"4CGGXDCjvY2ThUZXyv87Fz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d2abf8704540c2362afdb24a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d2abf8704540c2362afdb24a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d2abf8704540c2362afdb24a"}],"is_playable":true,"name":"90er & 2000er Party","release_date":"2025-01-24","release_date_precision":"day","total_tracks":75,"type":"album","uri":"spotify:album:4CGGXDCjvY2ThUZXyv87Fz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4mar1GMMEhvGyJdWagu6KS"},"href":"https://api.spotify.com/v1/artists/4mar1GMMEhvGyJdWagu6KS","id":"4mar1GMMEhvGyJdWagu6KS","name":"Quad City DJ's","type":"artist","uri":"spotify:artist:4mar1GMMEhvGyJdWagu6KS"}],"disc_number":1,"duration_ms":451440,"explicit":false,"external_ids":{"isrc":"USAT20103455"},"external_urls":{"spotify":"https://open.spotify.com/track/0Fl5Aaz9BdXW1h9c7AOhAf"},"href":"https://api.spotify.com/v1/tracks/0Fl5Aaz9BdXW1h9c7AOhAf","id":"0Fl5Aaz9BdXW1h9c7AOhAf","is_local":false,"is_playable":true,"name":"C'mon n' Ride It (The Train)","track_number":73,"type":"track","uri":"spotify:track:0Fl5Aaz9BdXW1h9c7AOhAf"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkMlMjdtb24lMjBOJTI3JTIwUmlkZSUyMEl0JTIwJTI4VGhlJTIwVHJhaW4lMjklMjIlMjBhcnRpc3QlM0ElMjJRdWFkJTIwQ2l0eSUyMERKJTI3cyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80bWFyMUdNTUVodkd5SmRXYWd1NktTIiwiaWQiOiI0bWFyMUdNTUVodkd5SmRXYWd1NktTIiwibmFtZSI6IlF1YWQgQ2l0eSBESidzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRtYXIxR01NRWh2R3lKZFdhZ3U2S1MifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xeGlwenU0ZU5BZHI4b0JucVAwZWFTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMXhpcHp1NGVOQWRyOG9CbnFQMGVhUyIsImlkIjoiMXhpcHp1NGVOQWRyOG9CbnFQMGVhUyIsImltYWdlcyI6W3siaGVp", + "Z2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxZjAxY2QwMTZjM2MxYmM4MzQ3NzhmYTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWYwMWNkMDE2YzNjMWJjODM0Nzc4ZmE3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExZjAxY2QwMTZjM2MxYmM4MzQ3NzhmYTcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR2V0IE9uIFVwIEFuZCBEYW5jZSIsInJlbGVhc2VfZGF0ZSI6IjE5OTYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXhpcHp1NGVOQWRyOG9CbnFQMGVhUyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRtYXIxR01NRWh2R3lKZFdhZ3U2S1MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyIsImlkIjoiNG1hcjFHTU1FaHZHeUpkV2FndTZLUyIsIm5hbWUiOiJRdWFkIENpdHkgREoncyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0bWFyMUdNTUVodkd5SmRXYWd1NktTIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQ1MTQ0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQVQyMDEwMzQ1NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMlFMRU4zUlZ1bk1hczdqMFBIamVBVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJRTEVOM1JWdW5NYXM3ajBQSGplQVQiLCJpZCI6IjJRTEVOM1JWdW5NYXM3ajBQSGplQVQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQydtb24gTicgUmlkZSBJdCAoVGhlIFRyYWluKSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyUUxFTjNSVnVuTWFzN2owUEhqZUFUIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80bWFyMUdNTUVodkd5SmRXYWd1NktTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRtYXIxR01NRWh2R3lKZFdhZ3U2S1MiLA==", + "ImlkIjoiNG1hcjFHTU1FaHZHeUpkV2FndTZLUyIsIm5hbWUiOiJRdWFkIENpdHkgREoncyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0bWFyMUdNTUVodkd5SmRXYWd1NktTIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMTZuRHNBRWRVRmJxMjFnNVJjV1lpSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzE2bkRzQUVkVUZicTIxZzVSY1dZaUoiLCJpZCI6IjE2bkRzQUVkVUZicTIxZzVSY1dZaUoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjRmZGU4NjdiNjE5NzAwMDc0OWQyYzY5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY0ZmRlODY3YjYxOTcwMDA3NDlkMmM2OSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjRmZGU4NjdiNjE5NzAwMDc0OWQyYzY5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkMnbW9uIE4nIFJpZGUgSXQgKFRoZSBUcmFpbikiLCJyZWxlYXNlX2RhdGUiOiIxOTk2LTA2LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxNm5Ec0FFZFVGYnEyMWc1UmNXWWlKIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80bWFyMUdNTUVodkd5SmRXYWd1NktTIiwiaWQiOiI0bWFyMUdNTUVodkd5SmRXYWd1NktTIiwibmFtZSI6IlF1YWQgQ2l0eSBESidzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRtYXIxR01NRWh2R3lKZFdhZ3U2S1MifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ4MzczLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBVDIwNjIzNzM1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83QVlyNXJZUUZYSnpMU0pLOXZ4Nm9tIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN0FZcjVyWVFGWEp6TFNKSzl2eDZvbSIsImlkIjoiN0FZcjVyWVFGWEp6TFNKSzl2eDZvbSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcA==", + "bGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkMnbW9uIE4nIFJpZGUgSXQgKFRoZSBUcmFpbikgLSBSYWRpbyBNaXgiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N0FZcjVyWVFGWEp6TFNKSzl2eDZvbSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80bWFyMUdNTUVodkd5SmRXYWd1NktTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRtYXIxR01NRWh2R3lKZFdhZ3U2S1MiLCJpZCI6IjRtYXIxR01NRWh2R3lKZFdhZ3U2S1MiLCJuYW1lIjoiUXVhZCBDaXR5IERKJ3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzF4aXB6dTRlTkFkcjhvQm5xUDBlYVMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xeGlwenU0ZU5BZHI4b0JucVAwZWFTIiwiaWQiOiIxeGlwenU0ZU5BZHI4b0JucVAwZWFTIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzFmMDFjZDAxNmMzYzFiYzgzNDc3OGZhNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxZjAxY2QwMTZjM2MxYmM4MzQ3NzhmYTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTFmMDFjZDAxNmMzYzFiYzgzNDc3OGZhNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHZXQgT24gVXAgQW5kIERhbmNlIiwicmVsZWFzZV9kYXRlIjoiMTk5NiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxeGlwenU0ZU5BZHI4b0JucVAwZWFTIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80bWFyMUdNTUVodkd5SmRXYWd1NktTIiwiaWQiOiI0bWFyMUdNTUVodkd5SmRXYWd1NktTIiwibmFtZSI6IlF1YWQgQ2l0eSBESidzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aQ==", + "c3Q6NG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0ODUwNDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FUMjAxMDM0NTYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFZRFE1ZERHYWRKdHJtcEVxRHo0SjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xWURRNWRER2FkSnRybXBFcUR6NEo0IiwiaWQiOiIxWURRNWRER2FkSnRybXBFcUR6NEo0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkMnbW9uIE4nIFJpZGUgSXQgKFRoZSBUcmFpbikgLSBEYW5jZSBSZW1peCIsInRyYWNrX251bWJlciI6MTMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MVlEUTVkREdhZEp0cm1wRXFEejRKNCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80bWFyMUdNTUVodkd5SmRXYWd1NktTIiwiaWQiOiI0bWFyMUdNTUVodkd5SmRXYWd1NktTIiwibmFtZSI6IlF1YWQgQ2l0eSBESidzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRtYXIxR01NRWh2R3lKZFdhZ3U2S1MifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xNm5Ec0FFZFVGYnEyMWc1UmNXWWlKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTZuRHNBRWRVRmJxMjFnNVJjV1lpSiIsImlkIjoiMTZuRHNBRWRVRmJxMjFnNVJjV1lpSiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmNGZkZTg2N2I2MTk3MDAwNzQ5ZDJjNjkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjRmZGU4NjdiNjE5NzAwMDc0OWQyYzY5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmNGZkZTg2N2I2MTk3MDAwNzQ5ZDJjNjkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQydtb24gTicgUmlkZSBJdCAoVGhlIFRyYWluKSIsInJlbGVhc2VfZGF0ZSI6IjE5OTYtMDYtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaQ==", + "b24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MTZuRHNBRWRVRmJxMjFnNVJjV1lpSiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRtYXIxR01NRWh2R3lKZFdhZ3U2S1MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyIsImlkIjoiNG1hcjFHTU1FaHZHeUpkV2FndTZLUyIsIm5hbWUiOiJRdWFkIENpdHkgREoncyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0bWFyMUdNTUVodkd5SmRXYWd1NktTIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQ1Mzg2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQVQyMDYyMzczOCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2hDM0dWeEpoNGw2UmF5R0dYNllESiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdoQzNHVnhKaDRsNlJheUdHWDZZREoiLCJpZCI6IjdoQzNHVnhKaDRsNlJheUdHWDZZREoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQydtb24gTicgUmlkZSBJdCAoVGhlIFRyYWluKSAtIENsdWIgTWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdoQzNHVnhKaDRsNlJheUdHWDZZREoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVJHbTFobGlHWjJVVFh5T3NBdW5yZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVSR20xaGxpR1oyVVRYeU9zQXVucmUiLCJpZCI6IjVSR20xaGxpR1oyVVRYeU9zQXVucmUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3Ng==", + "MTZkMDAwMGIyNzNmN2YzMTdhZjc4ZjcyNGNkYWEyODIxMTUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjdmMzE3YWY3OGY3MjRjZGFhMjgyMTE1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmN2YzMTdhZjc4ZjcyNGNkYWEyODIxMTUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiNzBzLCA4MHMsIDkwcyAmIDIwMDBzIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMy0xNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjYzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVSR20xaGxpR1oyVVRYeU9zQXVucmUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80bWFyMUdNTUVodkd5SmRXYWd1NktTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRtYXIxR01NRWh2R3lKZFdhZ3U2S1MiLCJpZCI6IjRtYXIxR01NRWh2R3lKZFdhZ3U2S1MiLCJuYW1lIjoiUXVhZCBDaXR5IERKJ3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0NTE0NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FUMjAxMDM0NTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVFeWxRdWVCWnNtNklrTWdiVWxxV0IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81RXlsUXVlQlpzbTZJa01nYlVscVdCIiwiaWQiOiI1RXlsUXVlQlpzbTZJa01nYlVscVdCIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkMnbW9uIG4nIFJpZGUgSXQgKFRoZSBUcmFpbikiLCJ0cmFja19udW1iZXIiOjM1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVFeWxRdWVCWnNtNklrTWdiVWxxV0IifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdQ==", + "cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yVWhkakZ0aG9hWEIwbkdwUXdzc2xQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMlVoZGpGdGhvYVhCMG5HcFF3c3NsUCIsImlkIjoiMlVoZGpGdGhvYVhCMG5HcFF3c3NsUCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzYjE3YjM0NmM2MDhiMjE5ZWQzYTE4NzQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyM2IxN2IzNDZjNjA4YjIxOWVkM2ExODc0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzYjE3YjM0NmM2MDhiMjE5ZWQzYTE4NzQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiOTAncyBEYW5jZSBDbGFzc2ljcyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDItMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyVWhkakZ0aG9hWEIwbkdwUXdzc2xQIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80bWFyMUdNTUVodkd5SmRXYWd1NktTIiwiaWQiOiI0bWFyMUdNTUVodkd5SmRXYWd1NktTIiwibmFtZSI6IlF1YWQgQ2l0eSBESidzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRtYXIxR01NRWh2R3lKZFdhZ3U2S1MifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDUxNDQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBVDIwMTAzNDU1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81aWx2V1NQbUF5VVV3WnNObVdmVk1kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNWlsdldTUG1BeVVVd1pzTm1XZlZNZCIsImlkIjoiNWlsdldTUG1BeVVVd1pzTm1XZlZNZCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDJ21vbiBOJyBSaWRlIEl0IChUaGUgVHJhaW4pIg==", + "LCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NWlsdldTUG1BeVVVd1pzTm1XZlZNZCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xaVNkZTJwbTJGRkFXTmw4WDZXWXJjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWlTZGUycG0yRkZBV05sOFg2V1lyYyIsImlkIjoiMWlTZGUycG0yRkZBV05sOFg2V1lyYyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiYzBkOGQwNTU1M2E4YmQ3NDBhNGIwM2IifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmMwZDhkMDU1NTNhOGJkNzQwYTRiMDNiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiYzBkOGQwNTU1M2E4YmQ3NDBhNGIwM2IifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiOTBzIFJhcCIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDQtMjAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxaVNkZTJwbTJGRkFXTmw4WDZXWXJjIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80bWFyMUdNTUVodkd5SmRXYWd1NktTIiwiaWQiOiI0bWFyMUdNTUVodkd5SmRXYWd1NktTIiwibmFtZSI6IlF1YWQgQ2l0eSBESidzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRtYXIxR01NRWh2R3lKZFdhZ3U2S1MifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDUxNA==", + "NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FUMjAxMDM0NTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJDQVBpcEJjZlM5d3hjdmFuQ1FyV24ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yQ0FQaXBCY2ZTOXd4Y3ZhbkNRclduIiwiaWQiOiIyQ0FQaXBCY2ZTOXd4Y3ZhbkNRclduIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkMnbW9uICdOJyBSaWRlIEl0IChUaGUgVHJhaW4pIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyQ0FQaXBCY2ZTOXd4Y3ZhbkNRclduIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJzTFNOSENCQ1gwVWhqcjNJMnd0M3YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yc0xTTkhDQkNYMFVoanIzSTJ3dDN2IiwiaWQiOiIyc0xTTkhDQkNYMFVoanIzSTJ3dDN2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2MxNmZlODU2MmI3Njc3YTgzZDVlYTkwOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjMTZmZTg1NjJiNzY3N2E4M2Q1ZWE5MDgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWMxNmZlODU2MmI3Njc3YTgzZDVlYTkwOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJVUyA5MCdzIEhpdHMiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA2LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MnNMU05IQ0JDWDBVaGpyM0kyd3Qzdg==", + "In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80bWFyMUdNTUVodkd5SmRXYWd1NktTIiwiaWQiOiI0bWFyMUdNTUVodkd5SmRXYWd1NktTIiwibmFtZSI6IlF1YWQgQ2l0eSBESidzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRtYXIxR01NRWh2R3lKZFdhZ3U2S1MifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDUxNDQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBVDIwMTAzNDU1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zTjVoUm9UQXFxdWVPMHRYd0Z1UmFyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM041aFJvVEFxcXVlTzB0WHdGdVJhciIsImlkIjoiM041aFJvVEFxcXVlTzB0WHdGdVJhciIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDJ21vbiBuJyBSaWRlIEl0IChUaGUgVHJhaW4pIiwidHJhY2tfbnVtYmVyIjozMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozTjVoUm9UQXFxdWVPMHRYd0Z1UmFyIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVtU0k5cW16SkhheTUzYnhidFp3cjQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81bVNJOXFtekpIYXk1M2J4YnRad3I0IiwiaWQiOiI1bVNJOXFtekpIYXk1M2J4YnRad3I0IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2E3MTUzMzhkOWNjMDA4Nzg5ZjcyMmIwNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlLw==", + "YWI2NzYxNmQwMDAwMWUwMmE3MTUzMzhkOWNjMDA4Nzg5ZjcyMmIwNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTcxNTMzOGQ5Y2MwMDg3ODlmNzIyYjA1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjkwcyBIaXAtSG9wIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wOC0yMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVtU0k5cW16SkhheTUzYnhidFp3cjQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80bWFyMUdNTUVodkd5SmRXYWd1NktTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRtYXIxR01NRWh2R3lKZFdhZ3U2S1MiLCJpZCI6IjRtYXIxR01NRWh2R3lKZFdhZ3U2S1MiLCJuYW1lIjoiUXVhZCBDaXR5IERKJ3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NG1hcjFHTU1FaHZHeUpkV2FndTZLUyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo0NTE0NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FUMjAxMDM0NTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRlYjFiQlhKanBwV01JNXpGRDQ4VlkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80ZWIxYkJYSmpwcFdNSTV6RkQ0OFZZIiwiaWQiOiI0ZWIxYkJYSmpwcFdNSTV6RkQ0OFZZIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkMnbW9uICdOJyBSaWRlIEl0IChUaGUgVHJhaW4pIiwidHJhY2tfbnVtYmVyIjoxOSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0ZWIxYkJYSmpwcFdNSTV6RkQ0OFZZIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaA==", + "dHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNENHR1hEQ2p2WTJUaFVaWHl2ODdGeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRDR0dYRENqdlkyVGhVWlh5djg3RnoiLCJpZCI6IjRDR0dYRENqdlkyVGhVWlh5djg3RnoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDJhYmY4NzA0NTQwYzIzNjJhZmRiMjRhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQyYWJmODcwNDU0MGMyMzYyYWZkYjI0YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDJhYmY4NzA0NTQwYzIzNjJhZmRiMjRhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjkwZXIgJiAyMDAwZXIgUGFydHkiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTAxLTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NzUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NENHR1hEQ2p2WTJUaFVaWHl2ODdGeiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRtYXIxR01NRWh2R3lKZFdhZ3U2S1MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNG1hcjFHTU1FaHZHeUpkV2FndTZLUyIsImlkIjoiNG1hcjFHTU1FaHZHeUpkV2FndTZLUyIsIm5hbWUiOiJRdWFkIENpdHkgREoncyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0bWFyMUdNTUVodkd5SmRXYWd1NktTIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjQ1MTQ0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQVQyMDEwMzQ1NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMEZsNUFhejlCZFhXMWg5YzdBT2hBZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBGbDVBYXo5QmRYVzFoOWM3QU9oQWYiLCJpZCI6IjBGbDVBYXo5QmRYVzFoOWM3QU9oQWYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQydtb24gbicgUmlkZSBJdCAoVGhlIFRyYWluKSIsInRyYWNrX251bWJlciI6NzMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MEZsNUFhejlCZFhXMWg5YzdBT2hBZiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22C%27mon+N%27+Ride+It+%28The+Train%29%22+artist%3A%22Quad+City+DJ%27s%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Gangsta%27s%20Paradise%22%20artist%3A%22Coolio%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":5,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"}],"external_urls":{"spotify":"https://open.spotify.com/album/0BJYNipGyMrw4ngKDJXzXZ"},"href":"https://api.spotify.com/v1/albums/0BJYNipGyMrw4ngKDJXzXZ","id":"0BJYNipGyMrw4ngKDJXzXZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737438996f6fe67c59d75d4e43"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027438996f6fe67c59d75d4e43"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517438996f6fe67c59d75d4e43"}],"is_playable":true,"name":"Gangsta's Paradise","release_date":"1995-11-07","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:0BJYNipGyMrw4ngKDJXzXZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2LhsePRtgCo4THVKULQBL7"},"href":"https://api.spotify.com/v1/artists/2LhsePRtgCo4THVKULQBL7","id":"2LhsePRtgCo4THVKULQBL7","name":"L.V.","type":"artist","uri":"spotify:artist:2LhsePRtgCo4THVKULQBL7"}],"disc_number":1,"duration_ms":240693,"explicit":false,"external_ids":{"isrc":"USTB10400128"},"external_urls":{"spotify":"https://open.spotify.com/track/1DIXPcTDzTj8ZMHt3PDt8p"},"href":"https://api.spotify.com/v1/tracks/1DIXPcTDzTj8ZMHt3PDt8p","id":"1DIXPcTDzTj8ZMHt3PDt8p","is_local":false,"is_playable":true,"name":"Gangsta's Paradise","track_number":2,"type":"track","uri":"spotify:track:1DIXPcTDzTj8ZMHt3PDt8p"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5UG2ipdnA4vk8Eevkf1s06"},"href":"https://api.spotify.com/v1/artists/5UG2ipdnA4vk8Eevkf1s06","id":"5UG2ipdnA4vk8Eevkf1s06","name":"HOLY PRIEST","type":"artist","uri":"spotify:artist:5UG2ipdnA4vk8Eevkf1s06"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1VwX54VxJ6Mghi5HTCZYLa"},"href":"https://api.spotify.com/v1/artists/1VwX54VxJ6Mghi5HTCZYLa","id":"1VwX54VxJ6Mghi5HTCZYLa","name":"1 World","type":"artist","uri":"spotify:artist:1VwX54VxJ6Mghi5HTCZYLa"}],"external_urls":{"spotify":"https://open.spotify.com/album/5X4PVhTdLwvxY51nHu2X6K"},"href":"https://api.spotify.com/v1/albums/5X4PVhTdLwvxY51nHu2X6K","id":"5X4PVhTdLwvxY51nHu2X6K","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738d26180df84f765ea7103eb1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028d26180df84f765ea7103eb1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518d26180df84f765ea7103eb1"}],"is_playable":true,"name":"Gangsta's Paradise","release_date":"2024-03-01","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:5X4PVhTdLwvxY51nHu2X6K"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5UG2ipdnA4vk8Eevkf1s06"},"href":"https://api.spotify.com/v1/artists/5UG2ipdnA4vk8Eevkf1s06","id":"5UG2ipdnA4vk8Eevkf1s06","name":"HOLY PRIEST","type":"artist","uri":"spotify:artist:5UG2ipdnA4vk8Eevkf1s06"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1VwX54VxJ6Mghi5HTCZYLa"},"href":"https://api.spotify.com/v1/artists/1VwX54VxJ6Mghi5HTCZYLa","id":"1VwX54VxJ6Mghi5HTCZYLa","name":"1 World","type":"artist","uri":"spotify:artist:1VwX54VxJ6Mghi5HTCZYLa"}],"disc_number":1,"duration_ms":168000,"explicit":false,"external_ids":{"isrc":"DEN062400033"},"external_urls":{"spotify":"https://open.spotify.com/track/7dYWuswcYTfETp2NxUqpRn"},"href":"https://api.spotify.com/v1/tracks/7dYWuswcYTfETp2NxUqpRn","id":"7dYWuswcYTfETp2NxUqpRn","is_local":false,"is_playable":true,"name":"Gangsta's Paradise","track_number":1,"type":"track","uri":"spotify:track:7dYWuswcYTfETp2NxUqpRn"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"}],"external_urls":{"spotify":"https://open.spotify.com/album/6J5bh0XtpMx4ClNfLqKv0H"},"href":"https://api.spotify.com/v1/albums/6J5bh0XtpMx4ClNfLqKv0H","id":"6J5bh0XtpMx4ClNfLqKv0H","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739d29bb8d9e2c9d707933b14f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029d29bb8d9e2c9d707933b14f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519d29bb8d9e2c9d707933b14f"}],"is_playable":true,"name":"Gangsta's Paradise","release_date":"1995-11-07","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:6J5bh0XtpMx4ClNfLqKv0H"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2LhsePRtgCo4THVKULQBL7"},"href":"https://api.spotify.com/v1/artists/2LhsePRtgCo4THVKULQBL7","id":"2LhsePRtgCo4THVKULQBL7","name":"L.V.","type":"artist","uri":"spotify:artist:2LhsePRtgCo4THVKULQBL7"}],"disc_number":1,"duration_ms":241933,"explicit":false,"external_ids":{"isrc":"USTB10250016"},"external_urls":{"spotify":"https://open.spotify.com/track/3iXI6ZaNBoL2dNv9K7LBh3"},"href":"https://api.spotify.com/v1/tracks/3iXI6ZaNBoL2dNv9K7LBh3","id":"3iXI6ZaNBoL2dNv9K7LBh3","is_local":false,"is_playable":true,"name":"Gangsta's Paradise","track_number":3,"type":"track","uri":"spotify:track:3iXI6ZaNBoL2dNv9K7LBh3"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7koJQAjVzXoUpH6pXrihXA"},"href":"https://api.spotify.com/v1/artists/7koJQAjVzXoUpH6pXrihXA","id":"7koJQAjVzXoUpH6pXrihXA","name":"Bodybangers","type":"artist","uri":"spotify:artist:7koJQAjVzXoUpH6pXrihXA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5NgQo5enpKJsf6ohQedD6b"},"href":"https://api.spotify.com/v1/artists/5NgQo5enpKJsf6ohQedD6b","id":"5NgQo5enpKJsf6ohQedD6b","name":"Lotus","type":"artist","uri":"spotify:artist:5NgQo5enpKJsf6ohQedD6b"}],"external_urls":{"spotify":"https://open.spotify.com/album/7aTKOexmV6lKljoyEGjm9b"},"href":"https://api.spotify.com/v1/albums/7aTKOexmV6lKljoyEGjm9b","id":"7aTKOexmV6lKljoyEGjm9b","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27330a253ce06927ff34e033aea"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0230a253ce06927ff34e033aea"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485130a253ce06927ff34e033aea"}],"is_playable":true,"name":"Gangsta's Paradise (Coopex Edit)","release_date":"2023-08-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7aTKOexmV6lKljoyEGjm9b"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7koJQAjVzXoUpH6pXrihXA"},"href":"https://api.spotify.com/v1/artists/7koJQAjVzXoUpH6pXrihXA","id":"7koJQAjVzXoUpH6pXrihXA","name":"Bodybangers","type":"artist","uri":"spotify:artist:7koJQAjVzXoUpH6pXrihXA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5NgQo5enpKJsf6ohQedD6b"},"href":"https://api.spotify.com/v1/artists/5NgQo5enpKJsf6ohQedD6b","id":"5NgQo5enpKJsf6ohQedD6b","name":"Lotus","type":"artist","uri":"spotify:artist:5NgQo5enpKJsf6ohQedD6b"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3UV0wVQkft6lKLDGioqnyO"},"href":"https://api.spotify.com/v1/artists/3UV0wVQkft6lKLDGioqnyO","id":"3UV0wVQkft6lKLDGioqnyO","name":"Coopex","type":"artist","uri":"spotify:artist:3UV0wVQkft6lKLDGioqnyO"}],"disc_number":1,"duration_ms":216320,"explicit":true,"external_ids":{"isrc":"DEE862301228"},"external_urls":{"spotify":"https://open.spotify.com/track/4v21IDELN86zH30UbqVRBn"},"href":"https://api.spotify.com/v1/tracks/4v21IDELN86zH30UbqVRBn","id":"4v21IDELN86zH30UbqVRBn","is_local":false,"is_playable":true,"name":"Gangsta's Paradise - Coopex Edit","track_number":1,"type":"track","uri":"spotify:track:4v21IDELN86zH30UbqVRBn"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7koJQAjVzXoUpH6pXrihXA"},"href":"https://api.spotify.com/v1/artists/7koJQAjVzXoUpH6pXrihXA","id":"7koJQAjVzXoUpH6pXrihXA","name":"Bodybangers","type":"artist","uri":"spotify:artist:7koJQAjVzXoUpH6pXrihXA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5NgQo5enpKJsf6ohQedD6b"},"href":"https://api.spotify.com/v1/artists/5NgQo5enpKJsf6ohQedD6b","id":"5NgQo5enpKJsf6ohQedD6b","name":"Lotus","type":"artist","uri":"spotify:artist:5NgQo5enpKJsf6ohQedD6b"}],"external_urls":{"spotify":"https://open.spotify.com/album/5miAnRqv7eWbmgY4nK7jU9"},"href":"https://api.spotify.com/v1/albums/5miAnRqv7eWbmgY4nK7jU9","id":"5miAnRqv7eWbmgY4nK7jU9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ccb3817966b0201335d5bb05"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ccb3817966b0201335d5bb05"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ccb3817966b0201335d5bb05"}],"is_playable":true,"name":"Gangsta's Paradise","release_date":"2022-12-09","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5miAnRqv7eWbmgY4nK7jU9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3y24n3XhZ96wgwRXjvS17T"},"href":"https://api.spotify.com/v1/artists/3y24n3XhZ96wgwRXjvS17T","id":"3y24n3XhZ96wgwRXjvS17T","name":"Coolio","type":"artist","uri":"spotify:artist:3y24n3XhZ96wgwRXjvS17T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7koJQAjVzXoUpH6pXrihXA"},"href":"https://api.spotify.com/v1/artists/7koJQAjVzXoUpH6pXrihXA","id":"7koJQAjVzXoUpH6pXrihXA","name":"Bodybangers","type":"artist","uri":"spotify:artist:7koJQAjVzXoUpH6pXrihXA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5NgQo5enpKJsf6ohQedD6b"},"href":"https://api.spotify.com/v1/artists/5NgQo5enpKJsf6ohQedD6b","id":"5NgQo5enpKJsf6ohQedD6b","name":"Lotus","type":"artist","uri":"spotify:artist:5NgQo5enpKJsf6ohQedD6b"}],"disc_number":1,"duration_ms":168300,"explicit":true,"external_ids":{"isrc":"DEE862202370"},"external_urls":{"spotify":"https://open.spotify.com/track/6Cm7r5U5igaAnwKOWjFhTq"},"href":"https://api.spotify.com/v1/tracks/6Cm7r5U5igaAnwKOWjFhTq","id":"6Cm7r5U5igaAnwKOWjFhTq","is_local":false,"is_playable":true,"name":"Gangsta's Paradise","track_number":1,"type":"track","uri":"spotify:track:6Cm7r5U5igaAnwKOWjFhTq"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkdhbmdzdGElMjdzJTIwUGFyYWRpc2UlMjIlMjBhcnRpc3QlM0ElMjJDb29saW8lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjUsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN5MjRuM1hoWjk2d2d3UlhqdlMxN1QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCIsImlkIjoiM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCIsIm5hbWUiOiJDb29saW8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBCSllOaXBHeU1ydzRuZ0tESlh6WFoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wQkpZTmlwR3lNcnc0bmdLREpYelhaIiwiaWQiOiIwQkpZTmlwR3lNcnc0bmdLREpYelhaIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28v", + "aW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzc0Mzg5OTZmNmZlNjdjNTlkNzVkNGU0MyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3NDM4OTk2ZjZmZTY3YzU5ZDc1ZDRlNDMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTc0Mzg5OTZmNmZlNjdjNTlkNzVkNGU0MyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHYW5nc3RhJ3MgUGFyYWRpc2UiLCJyZWxlYXNlX2RhdGUiOiIxOTk1LTExLTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MEJKWU5pcEd5TXJ3NG5nS0RKWHpYWiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN5MjRuM1hoWjk2d2d3UlhqdlMxN1QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCIsImlkIjoiM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCIsIm5hbWUiOiJDb29saW8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTGhzZVBSdGdDbzRUSFZLVUxRQkw3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJMaHNlUFJ0Z0NvNFRIVktVTFFCTDciLCJpZCI6IjJMaHNlUFJ0Z0NvNFRIVktVTFFCTDciLCJuYW1lIjoiTC5WLiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTGhzZVBSdGdDbzRUSFZLVUxRQkw3In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDY5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVEIxMDQwMDEyOCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMURJWFBjVER6VGo4Wk1IdDNQRHQ4cCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFESVhQY1REelRqOFpNSHQzUER0OHAiLCJpZCI6IjFESVhQY1REelRqOFpNSHQzUER0OHAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR2FuZ3N0YSdzIFBhcmFkaXNlIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFESVhQY1REelRqOFpNSHQzUER0OA==", + "cCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwiaWQiOiIzeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwibmFtZSI6IkNvb2xpbyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozeTI0bjNYaFo5Nndnd1JYanZTMTdUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVVRzJpcGRuQTR2azhFZXZrZjFzMDYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVVHMmlwZG5BNHZrOEVldmtmMXMwNiIsImlkIjoiNVVHMmlwZG5BNHZrOEVldmtmMXMwNiIsIm5hbWUiOiJIT0xZIFBSSUVTVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1VUcyaXBkbkE0dms4RWV2a2YxczA2In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWd1g1NFZ4SjZNZ2hpNUhUQ1pZTGEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVZ3WDU0VnhKNk1naGk1SFRDWllMYSIsImlkIjoiMVZ3WDU0VnhKNk1naGk1SFRDWllMYSIsIm5hbWUiOiIxIFdvcmxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFWd1g1NFZ4SjZNZ2hpNUhUQ1pZTGEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81WDRQVmhUZEx3dnhZNTFuSHUyWDZLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNVg0UFZoVGRMd3Z4WTUxbkh1Mlg2SyIsImlkIjoiNVg0UFZoVGRMd3Z4WTUxbkh1Mlg2SyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4ZDI2MTgwZGY4NGY3NjVlYTcxMDNlYjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOGQyNjE4MGRmODRmNzY1ZWE3MTAzZWIxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4ZDI2MTgwZGY4NGY3NjVlYTcxMDNlYjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR2FuZ3N0YSdzIFBhcmFkaXNlIiwicg==", + "ZWxlYXNlX2RhdGUiOiIyMDI0LTAzLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1WDRQVmhUZEx3dnhZNTFuSHUyWDZLIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwiaWQiOiIzeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwibmFtZSI6IkNvb2xpbyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozeTI0bjNYaFo5Nndnd1JYanZTMTdUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVVRzJpcGRuQTR2azhFZXZrZjFzMDYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVVHMmlwZG5BNHZrOEVldmtmMXMwNiIsImlkIjoiNVVHMmlwZG5BNHZrOEVldmtmMXMwNiIsIm5hbWUiOiJIT0xZIFBSSUVTVCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1VUcyaXBkbkE0dms4RWV2a2YxczA2In0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFWd1g1NFZ4SjZNZ2hpNUhUQ1pZTGEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVZ3WDU0VnhKNk1naGk1SFRDWllMYSIsImlkIjoiMVZ3WDU0VnhKNk1naGk1SFRDWllMYSIsIm5hbWUiOiIxIFdvcmxkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFWd1g1NFZ4SjZNZ2hpNUhUQ1pZTGEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTY4MDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiREVOMDYyNDAwMDMzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83ZFlXdXN3Y1lUZkVUcDJOeFVxcFJuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2RZV3Vzd2NZVGZFVHAyTnhVcXBSbiIsImlkIjoiN2RZV3Vzd2NZVGZFVHAyTnhVcXBSbiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHYW5nc3RhJ3MgUGFyYWRpc2UiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2RZV3Vzd2NZVGZFVHAyTnhVcXBSbiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6Ig==", + "YWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN5MjRuM1hoWjk2d2d3UlhqdlMxN1QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCIsImlkIjoiM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCIsIm5hbWUiOiJDb29saW8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZKNWJoMFh0cE14NENsTmZMcUt2MEgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82SjViaDBYdHBNeDRDbE5mTHFLdjBIIiwiaWQiOiI2SjViaDBYdHBNeDRDbE5mTHFLdjBIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzlkMjliYjhkOWUyYzlkNzA3OTMzYjE0ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5ZDI5YmI4ZDllMmM5ZDcwNzkzM2IxNGYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTlkMjliYjhkOWUyYzlkNzA3OTMzYjE0ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHYW5nc3RhJ3MgUGFyYWRpc2UiLCJyZWxlYXNlX2RhdGUiOiIxOTk1LTExLTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nko1YmgwWHRwTXg0Q2xOZkxxS3YwSCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN5MjRuM1hoWjk2d2d3UlhqdlMxN1QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCIsImlkIjoiM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCIsIm5hbWUiOiJDb29saW8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTGhzZVBSdGdDbzRUSFZLVUxRQkw3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJMaHNlUFJ0Z0NvNFRIVktVTFFCTA==", + "NyIsImlkIjoiMkxoc2VQUnRnQ280VEhWS1VMUUJMNyIsIm5hbWUiOiJMLlYuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJMaHNlUFJ0Z0NvNFRIVktVTFFCTDcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQxOTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNUQjEwMjUwMDE2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zaVhJNlphTkJvTDJkTnY5SzdMQmgzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM2lYSTZaYU5Cb0wyZE52OUs3TEJoMyIsImlkIjoiM2lYSTZaYU5Cb0wyZE52OUs3TEJoMyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHYW5nc3RhJ3MgUGFyYWRpc2UiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2lYSTZaYU5Cb0wyZE52OUs3TEJoMyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwiaWQiOiIzeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwibmFtZSI6IkNvb2xpbyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozeTI0bjNYaFo5Nndnd1JYanZTMTdUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzdrb0pRQWpWelhvVXBINnBYcmloWEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2tvSlFBalZ6WG9VcEg2cFhyaWhYQSIsImlkIjoiN2tvSlFBalZ6WG9VcEg2cFhyaWhYQSIsIm5hbWUiOiJCb2R5YmFuZ2VycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3a29KUUFqVnpYb1VwSDZwWHJpaFhBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVOZ1FvNWVucEtKc2Y2b2hRZWRENmIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNU5nUW81ZW5wS0pzZjZvaFFlZEQ2YiIsImlkIjoiNU5nUW81ZW5wS0pzZjZvaFFlZEQ2YiIsIm5hbWUiOiJMb3R1cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1TmdRbzVlbnBLSnNmNm9oUWVkRDZiIn1dLCJleHRlcm5hbF91cmxzIjp7Ig==", + "c3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83YVRLT2V4bVY2bEtsam95RUdqbTliIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN2FUS09leG1WNmxLbGpveUVHam05YiIsImlkIjoiN2FUS09leG1WNmxLbGpveUVHam05YiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzMGEyNTNjZTA2OTI3ZmYzNGUwMzNhZWEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzBhMjUzY2UwNjkyN2ZmMzRlMDMzYWVhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzMGEyNTNjZTA2OTI3ZmYzNGUwMzNhZWEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR2FuZ3N0YSdzIFBhcmFkaXNlIChDb29wZXggRWRpdCkiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA4LTE4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3YVRLT2V4bVY2bEtsam95RUdqbTliIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwiaWQiOiIzeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwibmFtZSI6IkNvb2xpbyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozeTI0bjNYaFo5Nndnd1JYanZTMTdUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzdrb0pRQWpWelhvVXBINnBYcmloWEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2tvSlFBalZ6WG9VcEg2cFhyaWhYQSIsImlkIjoiN2tvSlFBalZ6WG9VcEg2cFhyaWhYQSIsIm5hbWUiOiJCb2R5YmFuZ2VycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3a29KUUFqVnpYb1VwSDZwWHJpaFhBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVOZ1FvNWVucEtKc2Y2b2hRZWRENmIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNU5nUW81ZW5wS0pzZjZvaFFlZEQ2YiIsImlkIjoiNU5nUW81ZW5wSw==", + "SnNmNm9oUWVkRDZiIiwibmFtZSI6IkxvdHVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVOZ1FvNWVucEtKc2Y2b2hRZWRENmIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1VWMHdWUWtmdDZsS0xER2lvcW55TyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zVVYwd1ZRa2Z0NmxLTERHaW9xbnlPIiwiaWQiOiIzVVYwd1ZRa2Z0NmxLTERHaW9xbnlPIiwibmFtZSI6IkNvb3BleCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozVVYwd1ZRa2Z0NmxLTERHaW9xbnlPIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxNjMyMCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiREVFODYyMzAxMjI4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80djIxSURFTE44NnpIMzBVYnFWUkJuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNHYyMUlERUxOODZ6SDMwVWJxVlJCbiIsImlkIjoiNHYyMUlERUxOODZ6SDMwVWJxVlJCbiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHYW5nc3RhJ3MgUGFyYWRpc2UgLSBDb29wZXggRWRpdCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0djIxSURFTE44NnpIMzBVYnFWUkJuIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zeTI0bjNYaFo5Nndnd1JYanZTMTdUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN5MjRuM1hoWjk2d2d3UlhqdlMxN1QiLCJpZCI6IjN5MjRuM1hoWjk2d2d3UlhqdlMxN1QiLCJuYW1lIjoiQ29vbGlvIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN5MjRuM1hoWjk2d2d3UlhqdlMxN1QifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN2tvSlFBalZ6WG9VcEg2cFhyaWhYQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83a29KUUFqVnpYb1VwSDZwWHJpaFhBIiwiaWQiOiI3a29KUUFqVnpYb1VwSDZwWHJpaFhBIiwibmFtZSI6IkJvZHliYW5nZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojdrb0pRQWpWelhvVXBINnBYcmloWEEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdA==", + "aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81TmdRbzVlbnBLSnNmNm9oUWVkRDZiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVOZ1FvNWVucEtKc2Y2b2hRZWRENmIiLCJpZCI6IjVOZ1FvNWVucEtKc2Y2b2hRZWRENmIiLCJuYW1lIjoiTG90dXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NU5nUW81ZW5wS0pzZjZvaFFlZEQ2YiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVtaUFuUnF2N2VXYm1nWTRuSzdqVTkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81bWlBblJxdjdlV2JtZ1k0bks3alU5IiwiaWQiOiI1bWlBblJxdjdlV2JtZ1k0bks3alU5IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2NjYjM4MTc5NjZiMDIwMTMzNWQ1YmIwNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjY2IzODE3OTY2YjAyMDEzMzVkNWJiMDUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWNjYjM4MTc5NjZiMDIwMTMzNWQ1YmIwNSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHYW5nc3RhJ3MgUGFyYWRpc2UiLCJyZWxlYXNlX2RhdGUiOiIyMDIyLTEyLTA5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1bWlBblJxdjdlV2JtZ1k0bks3alU5In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3kyNG4zWGhaOTZ3Z3dSWGp2UzE3VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwiaWQiOiIzeTI0bjNYaFo5Nndnd1JYanZTMTdUIiwibmFtZSI6IkNvb2xpbyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozeTI0bjNYaFo5Nndnd1JYanZTMTdUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzdrb0pRQWpWelhvVXBINnBYcmloWEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2tvSlFBalZ6WG9VcEg2cFhyaWhYQSIsImlkIjoiN2tvSlFBalZ6WG9VcEg2cFhyaWhYQSIsIm5hbWUiOiJCbw==", + "ZHliYW5nZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojdrb0pRQWpWelhvVXBINnBYcmloWEEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNU5nUW81ZW5wS0pzZjZvaFFlZEQ2YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81TmdRbzVlbnBLSnNmNm9oUWVkRDZiIiwiaWQiOiI1TmdRbzVlbnBLSnNmNm9oUWVkRDZiIiwibmFtZSI6IkxvdHVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVOZ1FvNWVucEtKc2Y2b2hRZWRENmIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTY4MzAwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJERUU4NjIyMDIzNzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZDbTdyNVU1aWdhQW53S09XakZoVHEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82Q203cjVVNWlnYUFud0tPV2pGaFRxIiwiaWQiOiI2Q203cjVVNWlnYUFud0tPV2pGaFRxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkdhbmdzdGEncyBQYXJhZGlzZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2Q203cjVVNWlnYUFud0tPV2pGaFRxIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Gangsta%27s+Paradise%22+artist%3A%22Coolio%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Say%20My%20Name%22%20artist%3A%22Destiny%27s%20Child%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/283NWqNsCA9GwVHrJk59CG"},"href":"https://api.spotify.com/v1/albums/283NWqNsCA9GwVHrJk59CG","id":"283NWqNsCA9GwVHrJk59CG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733718df75b57340c1947747e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023718df75b57340c1947747e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513718df75b57340c1947747e8"}],"is_playable":true,"name":"The Writing's On The Wall","release_date":"1999-07-27","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:283NWqNsCA9GwVHrJk59CG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/7H6ev70Weq6DdpZyyTmUXk"},"href":"https://api.spotify.com/v1/tracks/7H6ev70Weq6DdpZyyTmUXk","id":"7H6ev70Weq6DdpZyyTmUXk","is_local":false,"is_playable":true,"name":"Say My Name","track_number":12,"type":"track","uri":"spotify:track:7H6ev70Weq6DdpZyyTmUXk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/78r5vrR1Wf60JPgFQ1drwr"},"href":"https://api.spotify.com/v1/albums/78r5vrR1Wf60JPgFQ1drwr","id":"78r5vrR1Wf60JPgFQ1drwr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c5b46ee859d728b295062346"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c5b46ee859d728b295062346"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c5b46ee859d728b295062346"}],"is_playable":true,"name":"The Writing's On The Wall","release_date":"1999-09-07","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:78r5vrR1Wf60JPgFQ1drwr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/2gSyc23Hua25fqSFpgAh6W"},"href":"https://api.spotify.com/v1/tracks/2gSyc23Hua25fqSFpgAh6W","id":"2gSyc23Hua25fqSFpgAh6W","is_local":false,"is_playable":true,"name":"Say My Name","track_number":12,"type":"track","uri":"spotify:track:2gSyc23Hua25fqSFpgAh6W"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/5YAznTfpQJx8RB9NQPjz7U"},"href":"https://api.spotify.com/v1/albums/5YAznTfpQJx8RB9NQPjz7U","id":"5YAznTfpQJx8RB9NQPjz7U","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a9a9c46edfae707aa9e884c0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a9a9c46edfae707aa9e884c0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a9a9c46edfae707aa9e884c0"}],"is_playable":true,"name":"Say My Name","release_date":"2000-02-21","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:5YAznTfpQJx8RB9NQPjz7U"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":268026,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/6WAhLCL1XchQzYjl15rnFp"},"href":"https://api.spotify.com/v1/tracks/6WAhLCL1XchQzYjl15rnFp","id":"6WAhLCL1XchQzYjl15rnFp","is_local":false,"is_playable":true,"name":"Say My Name","track_number":1,"type":"track","uri":"spotify:track:6WAhLCL1XchQzYjl15rnFp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/01gnLdVDtDGFd8nmLL1U18"},"href":"https://api.spotify.com/v1/albums/01gnLdVDtDGFd8nmLL1U18","id":"01gnLdVDtDGFd8nmLL1U18","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b5a1b7c7397205e6d5d57cb3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b5a1b7c7397205e6d5d57cb3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b5a1b7c7397205e6d5d57cb3"}],"is_playable":true,"name":"#1's","release_date":"2005","release_date_precision":"year","total_tracks":16,"type":"album","uri":"spotify:album:01gnLdVDtDGFd8nmLL1U18"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":240106,"explicit":false,"external_ids":{"isrc":"USSM10505679"},"external_urls":{"spotify":"https://open.spotify.com/track/47bRpR898N2fBRMb7HFZLJ"},"href":"https://api.spotify.com/v1/tracks/47bRpR898N2fBRMb7HFZLJ","id":"47bRpR898N2fBRMb7HFZLJ","is_local":false,"is_playable":true,"name":"Say My Name - #1's Edit","track_number":8,"type":"track","uri":"spotify:track:47bRpR898N2fBRMb7HFZLJ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/3cIOWmXUoNHTUjz6ljxXG6"},"href":"https://api.spotify.com/v1/albums/3cIOWmXUoNHTUjz6ljxXG6","id":"3cIOWmXUoNHTUjz6ljxXG6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27306a7168dbe1115f6ca0b7621"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0206a7168dbe1115f6ca0b7621"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485106a7168dbe1115f6ca0b7621"}],"is_playable":true,"name":"Say My Name","release_date":"2000-01-25","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:3cIOWmXUoNHTUjz6ljxXG6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1EwpUxkGyVYwO3PNnoF3Jj"},"href":"https://api.spotify.com/v1/artists/1EwpUxkGyVYwO3PNnoF3Jj","id":"1EwpUxkGyVYwO3PNnoF3Jj","name":"Kobe Bryant","type":"artist","uri":"spotify:artist:1EwpUxkGyVYwO3PNnoF3Jj"}],"disc_number":1,"duration_ms":267760,"explicit":false,"external_ids":{"isrc":"USSM10002487"},"external_urls":{"spotify":"https://open.spotify.com/track/6YNdZ1holUQd4PhHwMNoaS"},"href":"https://api.spotify.com/v1/tracks/6YNdZ1holUQd4PhHwMNoaS","id":"6YNdZ1holUQd4PhHwMNoaS","is_local":false,"is_playable":true,"name":"Say My Name (feat. Kobe Bryant)","track_number":3,"type":"track","uri":"spotify:track:6YNdZ1holUQd4PhHwMNoaS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ikTC4M0HHUnbViQn1NfEU"},"href":"https://api.spotify.com/v1/albums/4ikTC4M0HHUnbViQn1NfEU","id":"4ikTC4M0HHUnbViQn1NfEU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738735a21e566d36e2fcba1c75"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028735a21e566d36e2fcba1c75"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518735a21e566d36e2fcba1c75"}],"is_playable":true,"name":"#1's","release_date":"2005-10-25","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:4ikTC4M0HHUnbViQn1NfEU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":240106,"explicit":false,"external_ids":{"isrc":"USSM10505679"},"external_urls":{"spotify":"https://open.spotify.com/track/3mVqe0GZMawjxthrOXrFI0"},"href":"https://api.spotify.com/v1/tracks/3mVqe0GZMawjxthrOXrFI0","id":"3mVqe0GZMawjxthrOXrFI0","is_local":false,"is_playable":true,"name":"Say My Name - #1's Edit","track_number":8,"type":"track","uri":"spotify:track:3mVqe0GZMawjxthrOXrFI0"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0QhwxYDUougJiVDtyN4Lhm"},"href":"https://api.spotify.com/v1/albums/0QhwxYDUougJiVDtyN4Lhm","id":"0QhwxYDUougJiVDtyN4Lhm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c3fd856b637a87c675d2f29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c3fd856b637a87c675d2f29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c3fd856b637a87c675d2f29"}],"is_playable":true,"name":"R&B - 100 Hits - The Greatest R n B album - 100 R & B Classics featuring Usher, Pitbull and Synthetic Listener Timberlake","release_date":"2013-06-24","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0QhwxYDUougJiVDtyN4Lhm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/0Tm6EPYiVrQxRClsAHXh5t"},"href":"https://api.spotify.com/v1/tracks/0Tm6EPYiVrQxRClsAHXh5t","id":"0Tm6EPYiVrQxRClsAHXh5t","is_local":false,"is_playable":true,"name":"Say My Name","track_number":5,"type":"track","uri":"spotify:track:0Tm6EPYiVrQxRClsAHXh5t"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0mQElNz8o0cbAQxrcectyh"},"href":"https://api.spotify.com/v1/albums/0mQElNz8o0cbAQxrcectyh","id":"0mQElNz8o0cbAQxrcectyh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730022ab0cc6fb9cc9f66f489a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020022ab0cc6fb9cc9f66f489a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510022ab0cc6fb9cc9f66f489a"}],"is_playable":true,"name":"Beautiful","release_date":"2004-02-24","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:0mQElNz8o0cbAQxrcectyh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":267960,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/7L1GTbWaMrBb0mNSuEFrmh"},"href":"https://api.spotify.com/v1/tracks/7L1GTbWaMrBb0mNSuEFrmh","id":"7L1GTbWaMrBb0mNSuEFrmh","is_local":false,"is_playable":true,"name":"Say My Name","track_number":14,"type":"track","uri":"spotify:track:7L1GTbWaMrBb0mNSuEFrmh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/1cnm1yCVIMyHK9nYgNc5mJ"},"href":"https://api.spotify.com/v1/albums/1cnm1yCVIMyHK9nYgNc5mJ","id":"1cnm1yCVIMyHK9nYgNc5mJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c09702a8cacbcad162969d93"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c09702a8cacbcad162969d93"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c09702a8cacbcad162969d93"}],"is_playable":true,"name":"Destiny's Child/The Writing's On The Wall","release_date":"2002-08-29","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:1cnm1yCVIMyHK9nYgNc5mJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":2,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/3jumU8EQ9zUC7nvEiJLk3B"},"href":"https://api.spotify.com/v1/tracks/3jumU8EQ9zUC7nvEiJLk3B","id":"3jumU8EQ9zUC7nvEiJLk3B","is_local":false,"is_playable":true,"name":"Say My Name","track_number":12,"type":"track","uri":"spotify:track:3jumU8EQ9zUC7nvEiJLk3B"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"external_urls":{"spotify":"https://open.spotify.com/album/62VmigXrSD7guqE83MIl5e"},"href":"https://api.spotify.com/v1/albums/62VmigXrSD7guqE83MIl5e","id":"62VmigXrSD7guqE83MIl5e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731a79631c1fc135d7d4ee09a8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021a79631c1fc135d7d4ee09a8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511a79631c1fc135d7d4ee09a8"}],"is_playable":true,"name":"Check On It feat. Slim Thug","release_date":"1999","release_date_precision":"year","total_tracks":3,"type":"album","uri":"spotify:album:62VmigXrSD7guqE83MIl5e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":268933,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/6bqmItvswBZXz94uadglov"},"href":"https://api.spotify.com/v1/tracks/6bqmItvswBZXz94uadglov","id":"6bqmItvswBZXz94uadglov","is_local":false,"is_playable":true,"name":"Say My Name","track_number":2,"type":"track","uri":"spotify:track:6bqmItvswBZXz94uadglov"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Say%20My%20Name%22%20artist%3A%22Destiny%27s%20Child%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/283NWqNsCA9GwVHrJk59CG"},"href":"https://api.spotify.com/v1/albums/283NWqNsCA9GwVHrJk59CG","id":"283NWqNsCA9GwVHrJk59CG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733718df75b57340c1947747e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023718df75b57340c1947747e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513718df75b57340c1947747e8"}],"is_playable":true,"name":"The Writing's On The Wall","release_date":"1999-07-27","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:283NWqNsCA9GwVHrJk59CG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/7H6ev70Weq6DdpZyyTmUXk"},"href":"https://api.spotify.com/v1/tracks/7H6ev70Weq6DdpZyyTmUXk","id":"7H6ev70Weq6DdpZyyTmUXk","is_local":false,"is_playable":true,"name":"Say My Name","track_number":12,"type":"track","uri":"spotify:track:7H6ev70Weq6DdpZyyTmUXk"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/78r5vrR1Wf60JPgFQ1drwr"},"href":"https://api.spotify.com/v1/albums/78r5vrR1Wf60JPgFQ1drwr","id":"78r5vrR1Wf60JPgFQ1drwr","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c5b46ee859d728b295062346"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c5b46ee859d728b295062346"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c5b46ee859d728b295062346"}],"is_playable":true,"name":"The Writing's On The Wall","release_date":"1999-09-07","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:78r5vrR1Wf60JPgFQ1drwr"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/2gSyc23Hua25fqSFpgAh6W"},"href":"https://api.spotify.com/v1/tracks/2gSyc23Hua25fqSFpgAh6W","id":"2gSyc23Hua25fqSFpgAh6W","is_local":false,"is_playable":true,"name":"Say My Name","track_number":12,"type":"track","uri":"spotify:track:2gSyc23Hua25fqSFpgAh6W"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/5YAznTfpQJx8RB9NQPjz7U"},"href":"https://api.spotify.com/v1/albums/5YAznTfpQJx8RB9NQPjz7U","id":"5YAznTfpQJx8RB9NQPjz7U","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a9a9c46edfae707aa9e884c0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a9a9c46edfae707aa9e884c0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a9a9c46edfae707aa9e884c0"}],"is_playable":true,"name":"Say My Name","release_date":"2000-02-21","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:5YAznTfpQJx8RB9NQPjz7U"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":268026,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/6WAhLCL1XchQzYjl15rnFp"},"href":"https://api.spotify.com/v1/tracks/6WAhLCL1XchQzYjl15rnFp","id":"6WAhLCL1XchQzYjl15rnFp","is_local":false,"is_playable":true,"name":"Say My Name","track_number":1,"type":"track","uri":"spotify:track:6WAhLCL1XchQzYjl15rnFp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/01gnLdVDtDGFd8nmLL1U18"},"href":"https://api.spotify.com/v1/albums/01gnLdVDtDGFd8nmLL1U18","id":"01gnLdVDtDGFd8nmLL1U18","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b5a1b7c7397205e6d5d57cb3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b5a1b7c7397205e6d5d57cb3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b5a1b7c7397205e6d5d57cb3"}],"is_playable":true,"name":"#1's","release_date":"2005","release_date_precision":"year","total_tracks":16,"type":"album","uri":"spotify:album:01gnLdVDtDGFd8nmLL1U18"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":240106,"explicit":false,"external_ids":{"isrc":"USSM10505679"},"external_urls":{"spotify":"https://open.spotify.com/track/47bRpR898N2fBRMb7HFZLJ"},"href":"https://api.spotify.com/v1/tracks/47bRpR898N2fBRMb7HFZLJ","id":"47bRpR898N2fBRMb7HFZLJ","is_local":false,"is_playable":true,"name":"Say My Name - #1's Edit","track_number":8,"type":"track","uri":"spotify:track:47bRpR898N2fBRMb7HFZLJ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/3cIOWmXUoNHTUjz6ljxXG6"},"href":"https://api.spotify.com/v1/albums/3cIOWmXUoNHTUjz6ljxXG6","id":"3cIOWmXUoNHTUjz6ljxXG6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27306a7168dbe1115f6ca0b7621"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0206a7168dbe1115f6ca0b7621"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485106a7168dbe1115f6ca0b7621"}],"is_playable":true,"name":"Say My Name","release_date":"2000-01-25","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:3cIOWmXUoNHTUjz6ljxXG6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1EwpUxkGyVYwO3PNnoF3Jj"},"href":"https://api.spotify.com/v1/artists/1EwpUxkGyVYwO3PNnoF3Jj","id":"1EwpUxkGyVYwO3PNnoF3Jj","name":"Kobe Bryant","type":"artist","uri":"spotify:artist:1EwpUxkGyVYwO3PNnoF3Jj"}],"disc_number":1,"duration_ms":267760,"explicit":false,"external_ids":{"isrc":"USSM10002487"},"external_urls":{"spotify":"https://open.spotify.com/track/6YNdZ1holUQd4PhHwMNoaS"},"href":"https://api.spotify.com/v1/tracks/6YNdZ1holUQd4PhHwMNoaS","id":"6YNdZ1holUQd4PhHwMNoaS","is_local":false,"is_playable":true,"name":"Say My Name (feat. Kobe Bryant)","track_number":3,"type":"track","uri":"spotify:track:6YNdZ1holUQd4PhHwMNoaS"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/4ikTC4M0HHUnbViQn1NfEU"},"href":"https://api.spotify.com/v1/albums/4ikTC4M0HHUnbViQn1NfEU","id":"4ikTC4M0HHUnbViQn1NfEU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738735a21e566d36e2fcba1c75"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028735a21e566d36e2fcba1c75"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518735a21e566d36e2fcba1c75"}],"is_playable":true,"name":"#1's","release_date":"2005-10-25","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:4ikTC4M0HHUnbViQn1NfEU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":240106,"explicit":false,"external_ids":{"isrc":"USSM10505679"},"external_urls":{"spotify":"https://open.spotify.com/track/3mVqe0GZMawjxthrOXrFI0"},"href":"https://api.spotify.com/v1/tracks/3mVqe0GZMawjxthrOXrFI0","id":"3mVqe0GZMawjxthrOXrFI0","is_local":false,"is_playable":true,"name":"Say My Name - #1's Edit","track_number":8,"type":"track","uri":"spotify:track:3mVqe0GZMawjxthrOXrFI0"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0QhwxYDUougJiVDtyN4Lhm"},"href":"https://api.spotify.com/v1/albums/0QhwxYDUougJiVDtyN4Lhm","id":"0QhwxYDUougJiVDtyN4Lhm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c3fd856b637a87c675d2f29"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c3fd856b637a87c675d2f29"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c3fd856b637a87c675d2f29"}],"is_playable":true,"name":"R&B - 100 Hits - The Greatest R n B album - 100 R & B Classics featuring Usher, Pitbull and Synthetic Listener Timberlake","release_date":"2013-06-24","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0QhwxYDUougJiVDtyN4Lhm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/0Tm6EPYiVrQxRClsAHXh5t"},"href":"https://api.spotify.com/v1/tracks/0Tm6EPYiVrQxRClsAHXh5t","id":"0Tm6EPYiVrQxRClsAHXh5t","is_local":false,"is_playable":true,"name":"Say My Name","track_number":5,"type":"track","uri":"spotify:track:0Tm6EPYiVrQxRClsAHXh5t"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0mQElNz8o0cbAQxrcectyh"},"href":"https://api.spotify.com/v1/albums/0mQElNz8o0cbAQxrcectyh","id":"0mQElNz8o0cbAQxrcectyh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730022ab0cc6fb9cc9f66f489a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020022ab0cc6fb9cc9f66f489a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510022ab0cc6fb9cc9f66f489a"}],"is_playable":true,"name":"Beautiful","release_date":"2004-02-24","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:0mQElNz8o0cbAQxrcectyh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":267960,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/7L1GTbWaMrBb0mNSuEFrmh"},"href":"https://api.spotify.com/v1/tracks/7L1GTbWaMrBb0mNSuEFrmh","id":"7L1GTbWaMrBb0mNSuEFrmh","is_local":false,"is_playable":true,"name":"Say My Name","track_number":14,"type":"track","uri":"spotify:track:7L1GTbWaMrBb0mNSuEFrmh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"external_urls":{"spotify":"https://open.spotify.com/album/1cnm1yCVIMyHK9nYgNc5mJ"},"href":"https://api.spotify.com/v1/albums/1cnm1yCVIMyHK9nYgNc5mJ","id":"1cnm1yCVIMyHK9nYgNc5mJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c09702a8cacbcad162969d93"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c09702a8cacbcad162969d93"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c09702a8cacbcad162969d93"}],"is_playable":true,"name":"Destiny's Child/The Writing's On The Wall","release_date":"2002-08-29","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:1cnm1yCVIMyHK9nYgNc5mJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":2,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/3jumU8EQ9zUC7nvEiJLk3B"},"href":"https://api.spotify.com/v1/tracks/3jumU8EQ9zUC7nvEiJLk3B","id":"3jumU8EQ9zUC7nvEiJLk3B","is_local":false,"is_playable":true,"name":"Say My Name","track_number":12,"type":"track","uri":"spotify:track:3jumU8EQ9zUC7nvEiJLk3B"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6vWDO969PvNqNYHIOW5v0m"},"href":"https://api.spotify.com/v1/artists/6vWDO969PvNqNYHIOW5v0m","id":"6vWDO969PvNqNYHIOW5v0m","name":"Beyonc\u00e9","type":"artist","uri":"spotify:artist:6vWDO969PvNqNYHIOW5v0m"}],"external_urls":{"spotify":"https://open.spotify.com/album/62VmigXrSD7guqE83MIl5e"},"href":"https://api.spotify.com/v1/albums/62VmigXrSD7guqE83MIl5e","id":"62VmigXrSD7guqE83MIl5e","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731a79631c1fc135d7d4ee09a8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021a79631c1fc135d7d4ee09a8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511a79631c1fc135d7d4ee09a8"}],"is_playable":true,"name":"Check On It feat. Slim Thug","release_date":"1999","release_date_precision":"year","total_tracks":3,"type":"album","uri":"spotify:album:62VmigXrSD7guqE83MIl5e"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1Y8cdNmUJH7yBTd9yOvr5i"},"href":"https://api.spotify.com/v1/artists/1Y8cdNmUJH7yBTd9yOvr5i","id":"1Y8cdNmUJH7yBTd9yOvr5i","name":"Destiny's Child","type":"artist","uri":"spotify:artist:1Y8cdNmUJH7yBTd9yOvr5i"}],"disc_number":1,"duration_ms":268933,"explicit":false,"external_ids":{"isrc":"USSM19901056"},"external_urls":{"spotify":"https://open.spotify.com/track/6bqmItvswBZXz94uadglov"},"href":"https://api.spotify.com/v1/tracks/6bqmItvswBZXz94uadglov","id":"6bqmItvswBZXz94uadglov","is_local":false,"is_playable":true,"name":"Say My Name","track_number":2,"type":"track","uri":"spotify:track:6bqmItvswBZXz94uadglov"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Say+My+Name%22+artist%3A%22Destiny%27s+Child%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22California%20Love%22%20artist%3A%222Pac%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"}],"external_urls":{"spotify":"https://open.spotify.com/album/1WBZyULtlANBKed7Zf9cDP"},"href":"https://api.spotify.com/v1/albums/1WBZyULtlANBKed7Zf9cDP","id":"1WBZyULtlANBKed7Zf9cDP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d81a092eb373ded457d94eec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d81a092eb373ded457d94eec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d81a092eb373ded457d94eec"}],"is_playable":true,"name":"Greatest Hits","release_date":"1998-01-01","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:1WBZyULtlANBKed7Zf9cDP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3GMoVpWJy4smKuxFuFTwXC"},"href":"https://api.spotify.com/v1/artists/3GMoVpWJy4smKuxFuFTwXC","id":"3GMoVpWJy4smKuxFuFTwXC","name":"Roger","type":"artist","uri":"spotify:artist:3GMoVpWJy4smKuxFuFTwXC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"}],"disc_number":2,"duration_ms":284906,"explicit":true,"external_ids":{"isrc":"USUG10702628"},"external_urls":{"spotify":"https://open.spotify.com/track/3ia3dJETSOllPsv3LJkE35"},"href":"https://api.spotify.com/v1/tracks/3ia3dJETSOllPsv3LJkE35","id":"3ia3dJETSOllPsv3LJkE35","is_local":false,"is_playable":true,"name":"California Love - Original Version","track_number":6,"type":"track","uri":"spotify:track:3ia3dJETSOllPsv3LJkE35"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2BSJXSAUcltZVI2mJOu4uf"},"href":"https://api.spotify.com/v1/albums/2BSJXSAUcltZVI2mJOu4uf","id":"2BSJXSAUcltZVI2mJOu4uf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273910760a8285f232f9382bd58"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02910760a8285f232f9382bd58"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851910760a8285f232f9382bd58"}],"is_playable":true,"name":"Hip-Hop - West Coast All Stars","release_date":"2011-08-30","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:2BSJXSAUcltZVI2mJOu4uf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"}],"disc_number":1,"duration_ms":348000,"explicit":false,"external_ids":{"isrc":"SEWDL6001459"},"external_urls":{"spotify":"https://open.spotify.com/track/0LyLz6XsVs6wz85dK0S6EG"},"href":"https://api.spotify.com/v1/tracks/0LyLz6XsVs6wz85dK0S6EG","id":"0LyLz6XsVs6wz85dK0S6EG","is_local":false,"is_playable":true,"name":"California Love","track_number":2,"type":"track","uri":"spotify:track:0LyLz6XsVs6wz85dK0S6EG"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"}],"external_urls":{"spotify":"https://open.spotify.com/album/78iX7tMceN0FsnmabAtlOC"},"href":"https://api.spotify.com/v1/albums/78iX7tMceN0FsnmabAtlOC","id":"78iX7tMceN0FsnmabAtlOC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273073aebff28f79959d2543596"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02073aebff28f79959d2543596"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851073aebff28f79959d2543596"}],"is_playable":true,"name":"All Eyez On Me","release_date":"1996-02-13","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:78iX7tMceN0FsnmabAtlOC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3GMoVpWJy4smKuxFuFTwXC"},"href":"https://api.spotify.com/v1/artists/3GMoVpWJy4smKuxFuFTwXC","id":"3GMoVpWJy4smKuxFuFTwXC","name":"Roger","type":"artist","uri":"spotify:artist:3GMoVpWJy4smKuxFuFTwXC"}],"disc_number":1,"duration_ms":385880,"explicit":false,"external_ids":{"isrc":"USKO10403702"},"external_urls":{"spotify":"https://open.spotify.com/track/4DLVB91nzswc4wD7EchmXs"},"href":"https://api.spotify.com/v1/tracks/4DLVB91nzswc4wD7EchmXs","id":"4DLVB91nzswc4wD7EchmXs","is_local":false,"is_playable":true,"name":"California Love (remix) (ft. Dr. Dre, Roger Troutman) - Remix","track_number":12,"type":"track","uri":"spotify:track:4DLVB91nzswc4wD7EchmXs"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"}],"external_urls":{"spotify":"https://open.spotify.com/album/3PO9OtQdvCDJN8zDLtZiYd"},"href":"https://api.spotify.com/v1/albums/3PO9OtQdvCDJN8zDLtZiYd","id":"3PO9OtQdvCDJN8zDLtZiYd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eaea3c8408d2d21c05263d56"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eaea3c8408d2d21c05263d56"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eaea3c8408d2d21c05263d56"}],"is_playable":true,"name":"Greatest Hits","release_date":"1998-01-01","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:3PO9OtQdvCDJN8zDLtZiYd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3GMoVpWJy4smKuxFuFTwXC"},"href":"https://api.spotify.com/v1/artists/3GMoVpWJy4smKuxFuFTwXC","id":"3GMoVpWJy4smKuxFuFTwXC","name":"Roger","type":"artist","uri":"spotify:artist:3GMoVpWJy4smKuxFuFTwXC"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"}],"disc_number":2,"duration_ms":285026,"explicit":false,"external_ids":{"isrc":"USUG10702629"},"external_urls":{"spotify":"https://open.spotify.com/track/1JClFT74TYSXlzpagbmj0S"},"href":"https://api.spotify.com/v1/tracks/1JClFT74TYSXlzpagbmj0S","id":"1JClFT74TYSXlzpagbmj0S","is_local":false,"is_playable":true,"name":"California Love - Original Version","track_number":6,"type":"track","uri":"spotify:track:1JClFT74TYSXlzpagbmj0S"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0WiZXL23JX3Ej7kN3DzrZu"},"href":"https://api.spotify.com/v1/albums/0WiZXL23JX3Ej7kN3DzrZu","id":"0WiZXL23JX3Ej7kN3DzrZu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cdc9d491c224257f3799930e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cdc9d491c224257f3799930e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cdc9d491c224257f3799930e"}],"is_playable":true,"name":"The Very Best of Death Row","release_date":"2005-02-22","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:0WiZXL23JX3Ej7kN3DzrZu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"},{"external_urls":{"spotify":"https://open.spotify.com/artist/196ioJKSOxXwm5Tki2JYuA"},"href":"https://api.spotify.com/v1/artists/196ioJKSOxXwm5Tki2JYuA","id":"196ioJKSOxXwm5Tki2JYuA","name":"Roger Troutman","type":"artist","uri":"spotify:artist:196ioJKSOxXwm5Tki2JYuA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"}],"disc_number":1,"duration_ms":385893,"explicit":true,"external_ids":{"isrc":"USKO10403702"},"external_urls":{"spotify":"https://open.spotify.com/track/350yd4wKvmBYCRq0iakmP1"},"href":"https://api.spotify.com/v1/tracks/350yd4wKvmBYCRq0iakmP1","id":"350yd4wKvmBYCRq0iakmP1","is_local":false,"is_playable":true,"name":"California Love - Remix","track_number":2,"type":"track","uri":"spotify:track:350yd4wKvmBYCRq0iakmP1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"}],"external_urls":{"spotify":"https://open.spotify.com/album/5S9imdovfsl1OuJYjGSIXK"},"href":"https://api.spotify.com/v1/albums/5S9imdovfsl1OuJYjGSIXK","id":"5S9imdovfsl1OuJYjGSIXK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ca230028bd36a282d969e287"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ca230028bd36a282d969e287"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ca230028bd36a282d969e287"}],"is_playable":true,"name":"California Love","release_date":"2011-03-11","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:5S9imdovfsl1OuJYjGSIXK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"}],"disc_number":1,"duration_ms":348000,"explicit":true,"external_ids":{"isrc":"USV291347098"},"external_urls":{"spotify":"https://open.spotify.com/track/6sWJr1iryG4A1Luv0p4y15"},"href":"https://api.spotify.com/v1/tracks/6sWJr1iryG4A1Luv0p4y15","id":"6sWJr1iryG4A1Luv0p4y15","is_local":false,"is_playable":true,"name":"California Love","track_number":1,"type":"track","uri":"spotify:track:6sWJr1iryG4A1Luv0p4y15"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"}],"external_urls":{"spotify":"https://open.spotify.com/album/7HhH3qWRRvTEBt1xRhF2Va"},"href":"https://api.spotify.com/v1/albums/7HhH3qWRRvTEBt1xRhF2Va","id":"7HhH3qWRRvTEBt1xRhF2Va","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27367ed19ad1559ea591fab000d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0267ed19ad1559ea591fab000d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485167ed19ad1559ea591fab000d"}],"is_playable":true,"name":"All Eyez On Me","release_date":"1996-02-13","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:7HhH3qWRRvTEBt1xRhF2Va"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3GMoVpWJy4smKuxFuFTwXC"},"href":"https://api.spotify.com/v1/artists/3GMoVpWJy4smKuxFuFTwXC","id":"3GMoVpWJy4smKuxFuFTwXC","name":"Roger","type":"artist","uri":"spotify:artist:3GMoVpWJy4smKuxFuFTwXC"}],"disc_number":1,"duration_ms":383573,"explicit":false,"external_ids":{"isrc":"USKO10403685"},"external_urls":{"spotify":"https://open.spotify.com/track/7Ct71Pi6a5G4RjyT0zvIU9"},"href":"https://api.spotify.com/v1/tracks/7Ct71Pi6a5G4RjyT0zvIU9","id":"7Ct71Pi6a5G4RjyT0zvIU9","is_local":false,"is_playable":true,"name":"California Love (remix) (ft. Dr. Dre, Roger Troutman) - Remix","track_number":12,"type":"track","uri":"spotify:track:7Ct71Pi6a5G4RjyT0zvIU9"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0DoiNgLgpi1v7AL4XxvJaC"},"href":"https://api.spotify.com/v1/albums/0DoiNgLgpi1v7AL4XxvJaC","id":"0DoiNgLgpi1v7AL4XxvJaC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27339657eb65988cb6abaf7c6dc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0239657eb65988cb6abaf7c6dc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485139657eb65988cb6abaf7c6dc"}],"is_playable":true,"name":"Hip Hop Hits","release_date":"2022-08-26","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:0DoiNgLgpi1v7AL4XxvJaC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"}],"disc_number":1,"duration_ms":348000,"explicit":false,"external_ids":{"isrc":"SEWDL6001459"},"external_urls":{"spotify":"https://open.spotify.com/track/0SxyBj4y6avgFKvX2i7HMh"},"href":"https://api.spotify.com/v1/tracks/0SxyBj4y6avgFKvX2i7HMh","id":"0SxyBj4y6avgFKvX2i7HMh","is_local":false,"is_playable":true,"name":"California Love","track_number":1,"type":"track","uri":"spotify:track:0SxyBj4y6avgFKvX2i7HMh"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1lqD5GnInmcLPiRMfRVS22"},"href":"https://api.spotify.com/v1/albums/1lqD5GnInmcLPiRMfRVS22","id":"1lqD5GnInmcLPiRMfRVS22","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273752e1e1fb00887b01118b478"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02752e1e1fb00887b01118b478"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851752e1e1fb00887b01118b478"}],"is_playable":true,"name":"The Very Best of Death Row","release_date":"2005-02-22","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1lqD5GnInmcLPiRMfRVS22"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ZwdS5xdxEREPySFridCfh"},"href":"https://api.spotify.com/v1/artists/1ZwdS5xdxEREPySFridCfh","id":"1ZwdS5xdxEREPySFridCfh","name":"2Pac","type":"artist","uri":"spotify:artist:1ZwdS5xdxEREPySFridCfh"},{"external_urls":{"spotify":"https://open.spotify.com/artist/196ioJKSOxXwm5Tki2JYuA"},"href":"https://api.spotify.com/v1/artists/196ioJKSOxXwm5Tki2JYuA","id":"196ioJKSOxXwm5Tki2JYuA","name":"Roger Troutman","type":"artist","uri":"spotify:artist:196ioJKSOxXwm5Tki2JYuA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6DPYiyq5kWVQS4RGwxzPC7"},"href":"https://api.spotify.com/v1/artists/6DPYiyq5kWVQS4RGwxzPC7","id":"6DPYiyq5kWVQS4RGwxzPC7","name":"Dr. Dre","type":"artist","uri":"spotify:artist:6DPYiyq5kWVQS4RGwxzPC7"}],"disc_number":1,"duration_ms":385333,"explicit":false,"external_ids":{"isrc":"QZQAY2354032"},"external_urls":{"spotify":"https://open.spotify.com/track/3dafxjdnyFRRQ9xZfeBAAl"},"href":"https://api.spotify.com/v1/tracks/3dafxjdnyFRRQ9xZfeBAAl","id":"3dafxjdnyFRRQ9xZfeBAAl","is_local":false,"is_playable":true,"name":"California Love (Remix)","track_number":2,"type":"track","uri":"spotify:track:3dafxjdnyFRRQ9xZfeBAAl"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNhbGlmb3JuaWElMjBMb3ZlJTIyJTIwYXJ0aXN0JTNBJTIyMlBhYyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwiaWQiOiIxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwibmFtZSI6IjJQYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFXQlp5VUx0bEFOQktlZDdaZjljRFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xV0JaeVVMdGxBTkJLZWQ3WmY5Y0RQIiwiaWQiOiIxV0JaeVVMdGxBTkJLZWQ3WmY5Y0RQIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2Q4MWEwOTJlYjM3M2RlZDQ1N2Q5NGVlYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJkODFhMDkyZWIzNzNkZWQ0NTdkOTRlZWMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWQ4MWEwOTJlYjM3M2RlZDQ1N2Q5NGVlYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHcmVhdGVzdCBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMTk5OC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFXQlp5VUx0bEFOQktlZDdaZjljRFAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFad2RTNXhkeEVSRVB5U0ZyaWRDZmgiLCJpZCI6IjFad2RTNXhkeEVSRVB5U0ZyaQ==", + "ZENmaCIsIm5hbWUiOiIyUGFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFad2RTNXhkeEVSRVB5U0ZyaWRDZmgifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0dNb1ZwV0p5NHNtS3V4RnVGVHdYQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zR01vVnBXSnk0c21LdXhGdUZUd1hDIiwiaWQiOiIzR01vVnBXSnk0c21LdXhGdUZUd1hDIiwibmFtZSI6IlJvZ2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNHTW9WcFdKeTRzbUt1eEZ1RlR3WEMifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82RFBZaXlxNWtXVlFTNFJHd3h6UEM3IiwiaWQiOiI2RFBZaXlxNWtXVlFTNFJHd3h6UEM3IiwibmFtZSI6IkRyLiBEcmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NkRQWWl5cTVrV1ZRUzRSR3d4elBDNyJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjoyODQ5MDYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVUcxMDcwMjYyOCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2lhM2RKRVRTT2xsUHN2M0xKa0UzNSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNpYTNkSkVUU09sbFBzdjNMSmtFMzUiLCJpZCI6IjNpYTNkSkVUU09sbFBzdjNMSmtFMzUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2FsaWZvcm5pYSBMb3ZlIC0gT3JpZ2luYWwgVmVyc2lvbiIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozaWEzZEpFVFNPbGxQc3YzTEprRTM1In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcA==", + "b3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMkJTSlhTQVVjbHRaVkkybUpPdTR1ZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJCU0pYU0FVY2x0WlZJMm1KT3U0dWYiLCJpZCI6IjJCU0pYU0FVY2x0WlZJMm1KT3U0dWYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTEwNzYwYTgyODVmMjMyZjkzODJiZDU4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjkxMDc2MGE4Mjg1ZjIzMmY5MzgyYmQ1OCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOTEwNzYwYTgyODVmMjMyZjkzODJiZDU4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhpcC1Ib3AgLSBXZXN0IENvYXN0IEFsbCBTdGFycyIsInJlbGVhc2VfZGF0ZSI6IjIwMTEtMDgtMzAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyQlNKWFNBVWNsdFpWSTJtSk91NHVmIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwiaWQiOiIxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwibmFtZSI6IjJQYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozNDgwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJTRVdETDYwMDE0NTkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBMeUx6NlhzVnM2d3o4NWRLMFM2RUcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wTHlMejZYc1ZzNnd6ODVkSzBTNkVHIiwiaWQiOiIwTHlMejZYc1ZzNnd6ODVkSzBTNkVHIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNhbGlmb3JuaWEgTG92ZSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowTHlMejZYc1ZzNnd6ODVkSzBTNkVHIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidQ==", + "bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwiaWQiOiIxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwibmFtZSI6IjJQYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc4aVg3dE1jZU4wRnNubWFiQXRsT0MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83OGlYN3RNY2VOMEZzbm1hYkF0bE9DIiwiaWQiOiI3OGlYN3RNY2VOMEZzbm1hYkF0bE9DIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzA3M2FlYmZmMjhmNzk5NTlkMjU0MzU5NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwNzNhZWJmZjI4Zjc5OTU5ZDI1NDM1OTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTA3M2FlYmZmMjhmNzk5NTlkMjU0MzU5NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbGwgRXlleiBPbiBNZSIsInJlbGVhc2VfZGF0ZSI6IjE5OTYtMDItMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3OGlYN3RNY2VOMEZzbm1hYkF0bE9DIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwiaWQiOiIxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwibmFtZSI6IjJQYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RFBZaXlxNWtXVlFTNFJHd3h6UEM3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZEUFlpeXE1a1dWUVM0Ukd3eHpQQzciLCJpZCI6IjZEUA==", + "WWl5cTVrV1ZRUzRSR3d4elBDNyIsIm5hbWUiOiJEci4gRHJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZEUFlpeXE1a1dWUVM0Ukd3eHpQQzcifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0dNb1ZwV0p5NHNtS3V4RnVGVHdYQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zR01vVnBXSnk0c21LdXhGdUZUd1hDIiwiaWQiOiIzR01vVnBXSnk0c21LdXhGdUZUd1hDIiwibmFtZSI6IlJvZ2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNHTW9WcFdKeTRzbUt1eEZ1RlR3WEMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mzg1ODgwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNLTzEwNDAzNzAyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80RExWQjkxbnpzd2M0d0Q3RWNobVhzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNERMVkI5MW56c3djNHdEN0VjaG1YcyIsImlkIjoiNERMVkI5MW56c3djNHdEN0VjaG1YcyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYWxpZm9ybmlhIExvdmUgKHJlbWl4KSAoZnQuIERyLiBEcmUsIFJvZ2VyIFRyb3V0bWFuKSAtIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0RExWQjkxbnpzd2M0d0Q3RWNobVhzIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFad2RTNXhkeEVSRVB5U0ZyaWRDZmgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCIsImlkIjoiMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCIsIm5hbWUiOiIyUGFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFad2RTNXhkeEVSRVB5U0ZyaWRDZmgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zUE85T3RRZHZDREpOOHpETHRaaVlkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM1BPOU90UWR2Q0RKTjh6REx0WmlZZCIsImlkIjoiM1BPOU90UWR2Q0RKTjh6REx0WmlZZCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlLw==", + "YWI2NzYxNmQwMDAwYjI3M2VhZWEzYzg0MDhkMmQyMWMwNTI2M2Q1NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlYWVhM2M4NDA4ZDJkMjFjMDUyNjNkNTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWVhZWEzYzg0MDhkMmQyMWMwNTI2M2Q1NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHcmVhdGVzdCBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMTk5OC0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNQTzlPdFFkdkNESk44ekRMdFppWWQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFad2RTNXhkeEVSRVB5U0ZyaWRDZmgiLCJpZCI6IjFad2RTNXhkeEVSRVB5U0ZyaWRDZmgiLCJuYW1lIjoiMlBhYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNHTW9WcFdKeTRzbUt1eEZ1RlR3WEMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0dNb1ZwV0p5NHNtS3V4RnVGVHdYQyIsImlkIjoiM0dNb1ZwV0p5NHNtS3V4RnVGVHdYQyIsIm5hbWUiOiJSb2dlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozR01vVnBXSnk0c21LdXhGdUZUd1hDIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZEUFlpeXE1a1dWUVM0Ukd3eHpQQzcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyIsImlkIjoiNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyIsIm5hbWUiOiJEci4gRHJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZEUFlpeXE1a1dWUVM0Ukd3eHpQQzcifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6Mjg1MDI2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVRzEwNzAyNjI5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xSkNsRlQ3NA==", + "VFlTWGx6cGFnYm1qMFMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xSkNsRlQ3NFRZU1hsenBhZ2JtajBTIiwiaWQiOiIxSkNsRlQ3NFRZU1hsenBhZ2JtajBTIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNhbGlmb3JuaWEgTG92ZSAtIE9yaWdpbmFsIFZlcnNpb24iLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MUpDbEZUNzRUWVNYbHpwYWdibWowUyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wV2laWEwyM0pYM0VqN2tOM0R6clp1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMFdpWlhMMjNKWDNFajdrTjNEenJadSIsImlkIjoiMFdpWlhMMjNKWDNFajdrTjNEenJadSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjZGM5ZDQ5MWMyMjQyNTdmMzc5OTkzMGUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyY2RjOWQ0OTFjMjI0MjU3ZjM3OTk5MzBlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjZGM5ZDQ5MWMyMjQyNTdmMzc5OTkzMGUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIFZlcnkgQmVzdCBvZiBEZWF0aCBSb3ciLCJyZWxlYXNlX2RhdGUiOiIyMDA1LTAyLTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MFdpWlhMMjNKWDNFajdrTjNEenJadSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFad2RTNXhkeEVSRVB5U0ZyaWRDZmgifSwiaHJlZiI6Ig==", + "aHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwiaWQiOiIxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwibmFtZSI6IjJQYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xOTZpb0pLU094WHdtNVRraTJKWXVBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzE5NmlvSktTT3hYd201VGtpMkpZdUEiLCJpZCI6IjE5NmlvSktTT3hYd201VGtpMkpZdUEiLCJuYW1lIjoiUm9nZXIgVHJvdXRtYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTk2aW9KS1NPeFh3bTVUa2kySll1QSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RFBZaXlxNWtXVlFTNFJHd3h6UEM3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZEUFlpeXE1a1dWUVM0Ukd3eHpQQzciLCJpZCI6IjZEUFlpeXE1a1dWUVM0Ukd3eHpQQzciLCJuYW1lIjoiRHIuIERyZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2RFBZaXlxNWtXVlFTNFJHd3h6UEM3In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjM4NTg5MywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNLTzEwNDAzNzAyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zNTB5ZDR3S3ZtQllDUnEwaWFrbVAxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzUweWQ0d0t2bUJZQ1JxMGlha21QMSIsImlkIjoiMzUweWQ0d0t2bUJZQ1JxMGlha21QMSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYWxpZm9ybmlhIExvdmUgLSBSZW1peCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozNTB5ZDR3S3ZtQllDUnEwaWFrbVAxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFad2RTNXhkeEVSRVB5U0ZyaWRDZmgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCIsImlkIjoiMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCIsIm5hbWUiOiIyUGFjIiwidHlwZSI6ImFydGlzdA==", + "IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVTOWltZG92ZnNsMU91SllqR1NJWEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81UzlpbWRvdmZzbDFPdUpZakdTSVhLIiwiaWQiOiI1UzlpbWRvdmZzbDFPdUpZakdTSVhLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2NhMjMwMDI4YmQzNmEyODJkOTY5ZTI4NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjYTIzMDAyOGJkMzZhMjgyZDk2OWUyODcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWNhMjMwMDI4YmQzNmEyODJkOTY5ZTI4NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYWxpZm9ybmlhIExvdmUiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTAzLTExIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVM5aW1kb3Zmc2wxT3VKWWpHU0lYSyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFad2RTNXhkeEVSRVB5U0ZyaWRDZmgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCIsImlkIjoiMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCIsIm5hbWUiOiIyUGFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFad2RTNXhkeEVSRVB5U0ZyaWRDZmgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzQ4MDAwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1YyOTEzNDcwOTgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZzV0pyMWlyeUc0QTFMdXYwcDR5MTUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82c1dKcjFpcnlHNEExTHV2MHA0eTE1IiwiaWQiOiI2c1dKcjFpcnlHNEExTHV2MHA0eTE1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNhbGlmb3JuaWEgTG92ZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjaw==", + "OjZzV0pyMWlyeUc0QTFMdXYwcDR5MTUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwiaWQiOiIxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwibmFtZSI6IjJQYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdIaEgzcVdSUnZURUJ0MXhSaEYyVmEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83SGhIM3FXUlJ2VEVCdDF4UmhGMlZhIiwiaWQiOiI3SGhIM3FXUlJ2VEVCdDF4UmhGMlZhIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzY3ZWQxOWFkMTU1OWVhNTkxZmFiMDAwZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2N2VkMTlhZDE1NTllYTU5MWZhYjAwMGQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTY3ZWQxOWFkMTU1OWVhNTkxZmFiMDAwZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBbGwgRXlleiBPbiBNZSIsInJlbGVhc2VfZGF0ZSI6IjE5OTYtMDItMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3SGhIM3FXUlJ2VEVCdDF4UmhGMlZhIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwiaWQiOiIxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwibmFtZSI6IjJQYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82RFBZaXlxNWtXVlFTNFJHd3h6UEM3In0sImhyZWYiOiJodHRwczovL2FwaS5zcA==", + "b3RpZnkuY29tL3YxL2FydGlzdHMvNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyIsImlkIjoiNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyIsIm5hbWUiOiJEci4gRHJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZEUFlpeXE1a1dWUVM0Ukd3eHpQQzcifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM0dNb1ZwV0p5NHNtS3V4RnVGVHdYQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zR01vVnBXSnk0c21LdXhGdUZUd1hDIiwiaWQiOiIzR01vVnBXSnk0c21LdXhGdUZUd1hDIiwibmFtZSI6IlJvZ2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNHTW9WcFdKeTRzbUt1eEZ1RlR3WEMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzgzNTczLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNLTzEwNDAzNjg1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83Q3Q3MVBpNmE1RzRSanlUMHp2SVU5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN0N0NzFQaTZhNUc0Ump5VDB6dklVOSIsImlkIjoiN0N0NzFQaTZhNUc0Ump5VDB6dklVOSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYWxpZm9ybmlhIExvdmUgKHJlbWl4KSAoZnQuIERyLiBEcmUsIFJvZ2VyIFRyb3V0bWFuKSAtIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3Q3Q3MVBpNmE1RzRSanlUMHp2SVU5In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBEb2lOZ0xncGkxdjdBTDRYeHZKYUMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wRG9pTmdMZ3BpMXY3QUw0WHh2SmFDIiwiaWQiOiIwRG9pTmdMZ3BpMXY3QUw0WHh2SmFDIiwiaQ==", + "bWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzk2NTdlYjY1OTg4Y2I2YWJhZjdjNmRjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjM5NjU3ZWI2NTk4OGNiNmFiYWY3YzZkYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzk2NTdlYjY1OTg4Y2I2YWJhZjdjNmRjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhpcCBIb3AgSGl0cyIsInJlbGVhc2VfZGF0ZSI6IjIwMjItMDgtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowRG9pTmdMZ3BpMXY3QUw0WHh2SmFDIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwiaWQiOiIxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwibmFtZSI6IjJQYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozNDgwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJTRVdETDYwMDE0NTkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBTeHlCajR5NmF2Z0ZLdlgyaTdITWgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wU3h5Qmo0eTZhdmdGS3ZYMmk3SE1oIiwiaWQiOiIwU3h5Qmo0eTZhdmdGS3ZYMmk3SE1oIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNhbGlmb3JuaWEgTG92ZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowU3h5Qmo0eTZhdmdGS3ZYMmk3SE1oIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29t", + "cGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFscUQ1R25Jbm1jTFBpUk1mUlZTMjIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xbHFENUduSW5tY0xQaVJNZlJWUzIyIiwiaWQiOiIxbHFENUduSW5tY0xQaVJNZlJWUzIyIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzc1MmUxZTFmYjAwODg3YjAxMTE4YjQ3OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3NTJlMWUxZmIwMDg4N2IwMTExOGI0NzgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTc1MmUxZTFmYjAwODg3YjAxMTE4YjQ3OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgVmVyeSBCZXN0IG9mIERlYXRoIFJvdyIsInJlbGVhc2VfZGF0ZSI6IjIwMDUtMDItMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxbHFENUduSW5tY0xQaVJNZlJWUzIyIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwiaWQiOiIxWndkUzV4ZHhFUkVQeVNGcmlkQ2ZoIiwibmFtZSI6IjJQYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVp3ZFM1eGR4RVJFUHlTRnJpZENmaCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xOTZpb0pLU094WHdtNVRraTJKWXVBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzE5Ng==", + "aW9KS1NPeFh3bTVUa2kySll1QSIsImlkIjoiMTk2aW9KS1NPeFh3bTVUa2kySll1QSIsIm5hbWUiOiJSb2dlciBUcm91dG1hbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxOTZpb0pLU094WHdtNVRraTJKWXVBIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZEUFlpeXE1a1dWUVM0Ukd3eHpQQzcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyIsImlkIjoiNkRQWWl5cTVrV1ZRUzRSR3d4elBDNyIsIm5hbWUiOiJEci4gRHJlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZEUFlpeXE1a1dWUVM0Ukd3eHpQQzcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mzg1MzMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUVpRQVkyMzU0MDMyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zZGFmeGpkbnlGUlJROXhaZmVCQUFsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM2RhZnhqZG55RlJSUTl4WmZlQkFBbCIsImlkIjoiM2RhZnhqZG55RlJSUTl4WmZlQkFBbCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYWxpZm9ybmlhIExvdmUgKFJlbWl4KSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozZGFmeGpkbnlGUlJROXhaZmVCQUFsIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22California+Love%22+artist%3A%222Pac%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Regulate%22%20artist%3A%22Warren%20G%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"}],"external_urls":{"spotify":"https://open.spotify.com/album/2VMGv3inRLPM4GOMXf37qu"},"href":"https://api.spotify.com/v1/albums/2VMGv3inRLPM4GOMXf37qu","id":"2VMGv3inRLPM4GOMXf37qu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f6b9b62ea130943d371b69ef"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f6b9b62ea130943d371b69ef"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f6b9b62ea130943d371b69ef"}],"is_playable":true,"name":"Regulate\u2026 G Funk Era","release_date":"1994-06-07","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2VMGv3inRLPM4GOMXf37qu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":248866,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/7nYvUtkQMx1v80S2FH2s9J"},"href":"https://api.spotify.com/v1/tracks/7nYvUtkQMx1v80S2FH2s9J","id":"7nYvUtkQMx1v80S2FH2s9J","is_local":false,"is_playable":true,"name":"Regulate","track_number":1,"type":"track","uri":"spotify:track:7nYvUtkQMx1v80S2FH2s9J"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"}],"external_urls":{"spotify":"https://open.spotify.com/album/6SaKWgfQSk31X0OMLkt1hU"},"href":"https://api.spotify.com/v1/albums/6SaKWgfQSk31X0OMLkt1hU","id":"6SaKWgfQSk31X0OMLkt1hU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb009ec94ffc5a282a06f03b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb009ec94ffc5a282a06f03b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb009ec94ffc5a282a06f03b"}],"is_playable":true,"name":"Regulate...G Funk Era (20th Anniversary)","release_date":"1994-06-07","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6SaKWgfQSk31X0OMLkt1hU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":248866,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/4uIKHABS2ixy0AW0Y31rj4"},"href":"https://api.spotify.com/v1/tracks/4uIKHABS2ixy0AW0Y31rj4","id":"4uIKHABS2ixy0AW0Y31rj4","is_local":false,"is_playable":true,"name":"Regulate","track_number":1,"type":"track","uri":"spotify:track:4uIKHABS2ixy0AW0Y31rj4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Gs0hhZRYlR3kouHqFsrkV"},"href":"https://api.spotify.com/v1/albums/5Gs0hhZRYlR3kouHqFsrkV","id":"5Gs0hhZRYlR3kouHqFsrkV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27360f2187ff07137536274bace"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0260f2187ff07137536274bace"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485160f2187ff07137536274bace"}],"is_playable":true,"name":"Regulate G Funk (Enhanced Reissue)","release_date":"1994-06-07","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5Gs0hhZRYlR3kouHqFsrkV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":250868,"explicit":false,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/5EEOjaJyWvfMglmEwf9bG3"},"href":"https://api.spotify.com/v1/tracks/5EEOjaJyWvfMglmEwf9bG3","id":"5EEOjaJyWvfMglmEwf9bG3","is_local":false,"is_playable":true,"name":"Regulate","track_number":1,"type":"track","uri":"spotify:track:5EEOjaJyWvfMglmEwf9bG3"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/21pOJNrfJHEcLHrNL7MeV5"},"href":"https://api.spotify.com/v1/albums/21pOJNrfJHEcLHrNL7MeV5","id":"21pOJNrfJHEcLHrNL7MeV5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b8fc506244122fc428fba38f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b8fc506244122fc428fba38f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b8fc506244122fc428fba38f"}],"is_playable":true,"name":"Absolute R&B","release_date":"2013-01-01","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:21pOJNrfJHEcLHrNL7MeV5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":248320,"explicit":false,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/7aADXrF9ukepMnwNPfdCBn"},"href":"https://api.spotify.com/v1/tracks/7aADXrF9ukepMnwNPfdCBn","id":"7aADXrF9ukepMnwNPfdCBn","is_local":false,"is_playable":true,"name":"Regulate","track_number":11,"type":"track","uri":"spotify:track:7aADXrF9ukepMnwNPfdCBn"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2mk5XOGtfuxx7ZqqjkwYVD"},"href":"https://api.spotify.com/v1/albums/2mk5XOGtfuxx7ZqqjkwYVD","id":"2mk5XOGtfuxx7ZqqjkwYVD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c9342f76efbcb22022f58a6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c9342f76efbcb22022f58a6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c9342f76efbcb22022f58a6"}],"is_playable":true,"name":"Above The Rim (Original Motion Picture Soundtrack) [Deluxe Edition]","release_date":"1994-03-22","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:2mk5XOGtfuxx7ZqqjkwYVD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":250013,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/1mFxMJ2UZGFow4sx75vJ6Z"},"href":"https://api.spotify.com/v1/tracks/1mFxMJ2UZGFow4sx75vJ6Z","id":"1mFxMJ2UZGFow4sx75vJ6Z","is_local":false,"is_playable":true,"name":"Regulate","track_number":7,"type":"track","uri":"spotify:track:1mFxMJ2UZGFow4sx75vJ6Z"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1lqD5GnInmcLPiRMfRVS22"},"href":"https://api.spotify.com/v1/albums/1lqD5GnInmcLPiRMfRVS22","id":"1lqD5GnInmcLPiRMfRVS22","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273752e1e1fb00887b01118b478"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02752e1e1fb00887b01118b478"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851752e1e1fb00887b01118b478"}],"is_playable":true,"name":"The Very Best of Death Row","release_date":"2005-02-22","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1lqD5GnInmcLPiRMfRVS22"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":250373,"explicit":false,"external_ids":{"isrc":"QZQAY2360301"},"external_urls":{"spotify":"https://open.spotify.com/track/2Vvk3ZvV5XZGvTA6svq8mV"},"href":"https://api.spotify.com/v1/tracks/2Vvk3ZvV5XZGvTA6svq8mV","id":"2Vvk3ZvV5XZGvTA6svq8mV","is_local":false,"is_playable":true,"name":"Regulate","track_number":8,"type":"track","uri":"spotify:track:2Vvk3ZvV5XZGvTA6svq8mV"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/08FDTQSWH0Hz7NkrPhkCrB"},"href":"https://api.spotify.com/v1/albums/08FDTQSWH0Hz7NkrPhkCrB","id":"08FDTQSWH0Hz7NkrPhkCrB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f17542d933b7a8b72efd6477"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f17542d933b7a8b72efd6477"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f17542d933b7a8b72efd6477"}],"is_playable":true,"name":"HipHop & Trap","release_date":"2023-06-02","release_date_precision":"day","total_tracks":31,"type":"album","uri":"spotify:album:08FDTQSWH0Hz7NkrPhkCrB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":250186,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/01ATfuZiOWePhRXeeUhcms"},"href":"https://api.spotify.com/v1/tracks/01ATfuZiOWePhRXeeUhcms","id":"01ATfuZiOWePhRXeeUhcms","is_local":false,"is_playable":true,"name":"Regulate","track_number":29,"type":"track","uri":"spotify:track:01ATfuZiOWePhRXeeUhcms"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4SUhkToXKcLYWmPPfVgNpl"},"href":"https://api.spotify.com/v1/albums/4SUhkToXKcLYWmPPfVgNpl","id":"4SUhkToXKcLYWmPPfVgNpl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6d939d1f1d1284f960f7a87"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6d939d1f1d1284f960f7a87"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6d939d1f1d1284f960f7a87"}],"is_playable":true,"name":"Def Jam 25: Volume 3 - It Takes Two PT 1 (Explicit Version)","release_date":"2009-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4SUhkToXKcLYWmPPfVgNpl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":248613,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/6ociORZcjJbDpJpXecJHMx"},"href":"https://api.spotify.com/v1/tracks/6ociORZcjJbDpJpXecJHMx","id":"6ociORZcjJbDpJpXecJHMx","is_local":false,"is_playable":true,"name":"Regulate","track_number":10,"type":"track","uri":"spotify:track:6ociORZcjJbDpJpXecJHMx"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4lcxqAzYowuyCQF8LAGSpo"},"href":"https://api.spotify.com/v1/albums/4lcxqAzYowuyCQF8LAGSpo","id":"4lcxqAzYowuyCQF8LAGSpo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e727a3c3a1d81cc6b25433c8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e727a3c3a1d81cc6b25433c8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e727a3c3a1d81cc6b25433c8"}],"is_playable":true,"name":"Def Jam Classics (Volume 1)","release_date":"2018-08-03","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:4lcxqAzYowuyCQF8LAGSpo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":249866,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/2wBaI5KNwwqVETjG3kAf9C"},"href":"https://api.spotify.com/v1/tracks/2wBaI5KNwwqVETjG3kAf9C","id":"2wBaI5KNwwqVETjG3kAf9C","is_local":false,"is_playable":true,"name":"Regulate","track_number":24,"type":"track","uri":"spotify:track:2wBaI5KNwwqVETjG3kAf9C"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Regulate%22%20artist%3A%22Warren%20G%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"}],"external_urls":{"spotify":"https://open.spotify.com/album/2VMGv3inRLPM4GOMXf37qu"},"href":"https://api.spotify.com/v1/albums/2VMGv3inRLPM4GOMXf37qu","id":"2VMGv3inRLPM4GOMXf37qu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f6b9b62ea130943d371b69ef"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f6b9b62ea130943d371b69ef"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f6b9b62ea130943d371b69ef"}],"is_playable":true,"name":"Regulate\u2026 G Funk Era","release_date":"1994-06-07","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2VMGv3inRLPM4GOMXf37qu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":248866,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/7nYvUtkQMx1v80S2FH2s9J"},"href":"https://api.spotify.com/v1/tracks/7nYvUtkQMx1v80S2FH2s9J","id":"7nYvUtkQMx1v80S2FH2s9J","is_local":false,"is_playable":true,"name":"Regulate","track_number":1,"type":"track","uri":"spotify:track:7nYvUtkQMx1v80S2FH2s9J"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"}],"external_urls":{"spotify":"https://open.spotify.com/album/6SaKWgfQSk31X0OMLkt1hU"},"href":"https://api.spotify.com/v1/albums/6SaKWgfQSk31X0OMLkt1hU","id":"6SaKWgfQSk31X0OMLkt1hU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb009ec94ffc5a282a06f03b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb009ec94ffc5a282a06f03b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb009ec94ffc5a282a06f03b"}],"is_playable":true,"name":"Regulate...G Funk Era (20th Anniversary)","release_date":"1994-06-07","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6SaKWgfQSk31X0OMLkt1hU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":248866,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/4uIKHABS2ixy0AW0Y31rj4"},"href":"https://api.spotify.com/v1/tracks/4uIKHABS2ixy0AW0Y31rj4","id":"4uIKHABS2ixy0AW0Y31rj4","is_local":false,"is_playable":true,"name":"Regulate","track_number":1,"type":"track","uri":"spotify:track:4uIKHABS2ixy0AW0Y31rj4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Gs0hhZRYlR3kouHqFsrkV"},"href":"https://api.spotify.com/v1/albums/5Gs0hhZRYlR3kouHqFsrkV","id":"5Gs0hhZRYlR3kouHqFsrkV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27360f2187ff07137536274bace"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0260f2187ff07137536274bace"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485160f2187ff07137536274bace"}],"is_playable":true,"name":"Regulate G Funk (Enhanced Reissue)","release_date":"1994-06-07","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5Gs0hhZRYlR3kouHqFsrkV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":250868,"explicit":false,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/5EEOjaJyWvfMglmEwf9bG3"},"href":"https://api.spotify.com/v1/tracks/5EEOjaJyWvfMglmEwf9bG3","id":"5EEOjaJyWvfMglmEwf9bG3","is_local":false,"is_playable":true,"name":"Regulate","track_number":1,"type":"track","uri":"spotify:track:5EEOjaJyWvfMglmEwf9bG3"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/21pOJNrfJHEcLHrNL7MeV5"},"href":"https://api.spotify.com/v1/albums/21pOJNrfJHEcLHrNL7MeV5","id":"21pOJNrfJHEcLHrNL7MeV5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b8fc506244122fc428fba38f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b8fc506244122fc428fba38f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b8fc506244122fc428fba38f"}],"is_playable":true,"name":"Absolute R&B","release_date":"2013-01-01","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:21pOJNrfJHEcLHrNL7MeV5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":248320,"explicit":false,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/7aADXrF9ukepMnwNPfdCBn"},"href":"https://api.spotify.com/v1/tracks/7aADXrF9ukepMnwNPfdCBn","id":"7aADXrF9ukepMnwNPfdCBn","is_local":false,"is_playable":true,"name":"Regulate","track_number":11,"type":"track","uri":"spotify:track:7aADXrF9ukepMnwNPfdCBn"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2mk5XOGtfuxx7ZqqjkwYVD"},"href":"https://api.spotify.com/v1/albums/2mk5XOGtfuxx7ZqqjkwYVD","id":"2mk5XOGtfuxx7ZqqjkwYVD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c9342f76efbcb22022f58a6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c9342f76efbcb22022f58a6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c9342f76efbcb22022f58a6"}],"is_playable":true,"name":"Above The Rim (Original Motion Picture Soundtrack) [Deluxe Edition]","release_date":"1994-03-22","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:2mk5XOGtfuxx7ZqqjkwYVD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":250013,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/1mFxMJ2UZGFow4sx75vJ6Z"},"href":"https://api.spotify.com/v1/tracks/1mFxMJ2UZGFow4sx75vJ6Z","id":"1mFxMJ2UZGFow4sx75vJ6Z","is_local":false,"is_playable":true,"name":"Regulate","track_number":7,"type":"track","uri":"spotify:track:1mFxMJ2UZGFow4sx75vJ6Z"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1lqD5GnInmcLPiRMfRVS22"},"href":"https://api.spotify.com/v1/albums/1lqD5GnInmcLPiRMfRVS22","id":"1lqD5GnInmcLPiRMfRVS22","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273752e1e1fb00887b01118b478"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02752e1e1fb00887b01118b478"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851752e1e1fb00887b01118b478"}],"is_playable":true,"name":"The Very Best of Death Row","release_date":"2005-02-22","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:1lqD5GnInmcLPiRMfRVS22"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":250373,"explicit":false,"external_ids":{"isrc":"QZQAY2360301"},"external_urls":{"spotify":"https://open.spotify.com/track/2Vvk3ZvV5XZGvTA6svq8mV"},"href":"https://api.spotify.com/v1/tracks/2Vvk3ZvV5XZGvTA6svq8mV","id":"2Vvk3ZvV5XZGvTA6svq8mV","is_local":false,"is_playable":true,"name":"Regulate","track_number":8,"type":"track","uri":"spotify:track:2Vvk3ZvV5XZGvTA6svq8mV"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/08FDTQSWH0Hz7NkrPhkCrB"},"href":"https://api.spotify.com/v1/albums/08FDTQSWH0Hz7NkrPhkCrB","id":"08FDTQSWH0Hz7NkrPhkCrB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f17542d933b7a8b72efd6477"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f17542d933b7a8b72efd6477"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f17542d933b7a8b72efd6477"}],"is_playable":true,"name":"HipHop & Trap","release_date":"2023-06-02","release_date_precision":"day","total_tracks":31,"type":"album","uri":"spotify:album:08FDTQSWH0Hz7NkrPhkCrB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":250186,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/01ATfuZiOWePhRXeeUhcms"},"href":"https://api.spotify.com/v1/tracks/01ATfuZiOWePhRXeeUhcms","id":"01ATfuZiOWePhRXeeUhcms","is_local":false,"is_playable":true,"name":"Regulate","track_number":29,"type":"track","uri":"spotify:track:01ATfuZiOWePhRXeeUhcms"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4SUhkToXKcLYWmPPfVgNpl"},"href":"https://api.spotify.com/v1/albums/4SUhkToXKcLYWmPPfVgNpl","id":"4SUhkToXKcLYWmPPfVgNpl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b6d939d1f1d1284f960f7a87"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b6d939d1f1d1284f960f7a87"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b6d939d1f1d1284f960f7a87"}],"is_playable":true,"name":"Def Jam 25: Volume 3 - It Takes Two PT 1 (Explicit Version)","release_date":"2009-01-01","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4SUhkToXKcLYWmPPfVgNpl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":248613,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/6ociORZcjJbDpJpXecJHMx"},"href":"https://api.spotify.com/v1/tracks/6ociORZcjJbDpJpXecJHMx","id":"6ociORZcjJbDpJpXecJHMx","is_local":false,"is_playable":true,"name":"Regulate","track_number":10,"type":"track","uri":"spotify:track:6ociORZcjJbDpJpXecJHMx"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4lcxqAzYowuyCQF8LAGSpo"},"href":"https://api.spotify.com/v1/albums/4lcxqAzYowuyCQF8LAGSpo","id":"4lcxqAzYowuyCQF8LAGSpo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e727a3c3a1d81cc6b25433c8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e727a3c3a1d81cc6b25433c8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e727a3c3a1d81cc6b25433c8"}],"is_playable":true,"name":"Def Jam Classics (Volume 1)","release_date":"2018-08-03","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:4lcxqAzYowuyCQF8LAGSpo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2B4ZHz4QDWJTXPFPgO5peE"},"href":"https://api.spotify.com/v1/artists/2B4ZHz4QDWJTXPFPgO5peE","id":"2B4ZHz4QDWJTXPFPgO5peE","name":"Warren G","type":"artist","uri":"spotify:artist:2B4ZHz4QDWJTXPFPgO5peE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Oa0bMld0A3u5OTYfMzp5h"},"href":"https://api.spotify.com/v1/artists/1Oa0bMld0A3u5OTYfMzp5h","id":"1Oa0bMld0A3u5OTYfMzp5h","name":"Nate Dogg","type":"artist","uri":"spotify:artist:1Oa0bMld0A3u5OTYfMzp5h"}],"disc_number":1,"duration_ms":249866,"explicit":true,"external_ids":{"isrc":"USPR39401366"},"external_urls":{"spotify":"https://open.spotify.com/track/2wBaI5KNwwqVETjG3kAf9C"},"href":"https://api.spotify.com/v1/tracks/2wBaI5KNwwqVETjG3kAf9C","id":"2wBaI5KNwwqVETjG3kAf9C","is_local":false,"is_playable":true,"name":"Regulate","track_number":24,"type":"track","uri":"spotify:track:2wBaI5KNwwqVETjG3kAf9C"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Regulate%22+artist%3A%22Warren+G%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22This%20Is%20How%20We%20Do%20It%22%20artist%3A%22Montell%20Jordan%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6J9fX2iXc9W7ILQUWvEhAx"},"href":"https://api.spotify.com/v1/albums/6J9fX2iXc9W7ILQUWvEhAx","id":"6J9fX2iXc9W7ILQUWvEhAx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273430debb283066ac6725483cf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02430debb283066ac6725483cf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851430debb283066ac6725483cf"}],"is_playable":true,"name":"Best Of Montell Jordan","release_date":"2015-09-25","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:6J9fX2iXc9W7ILQUWvEhAx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"}],"disc_number":1,"duration_ms":237546,"explicit":false,"external_ids":{"isrc":"USUM70728132"},"external_urls":{"spotify":"https://open.spotify.com/track/6aJ90LBl96bly9zuEH1U2X"},"href":"https://api.spotify.com/v1/tracks/6aJ90LBl96bly9zuEH1U2X","id":"6aJ90LBl96bly9zuEH1U2X","is_local":false,"is_playable":true,"name":"This Is How We Do It","track_number":1,"type":"track","uri":"spotify:track:6aJ90LBl96bly9zuEH1U2X"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4kwEd1P9j15ZqUVP5zK7Pv"},"href":"https://api.spotify.com/v1/artists/4kwEd1P9j15ZqUVP5zK7Pv","id":"4kwEd1P9j15ZqUVP5zK7Pv","name":"Joe Stone","type":"artist","uri":"spotify:artist:4kwEd1P9j15ZqUVP5zK7Pv"}],"external_urls":{"spotify":"https://open.spotify.com/album/4QyTWqz6svtpu7Xr3C6QHU"},"href":"https://api.spotify.com/v1/albums/4QyTWqz6svtpu7Xr3C6QHU","id":"4QyTWqz6svtpu7Xr3C6QHU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273020faff9f94328dda1dcc41d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02020faff9f94328dda1dcc41d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851020faff9f94328dda1dcc41d"}],"is_playable":true,"name":"The Party (This Is How We Do It) [feat. Montell Jordan] [Radio Edit]","release_date":"2015-05-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4QyTWqz6svtpu7Xr3C6QHU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4kwEd1P9j15ZqUVP5zK7Pv"},"href":"https://api.spotify.com/v1/artists/4kwEd1P9j15ZqUVP5zK7Pv","id":"4kwEd1P9j15ZqUVP5zK7Pv","name":"Joe Stone","type":"artist","uri":"spotify:artist:4kwEd1P9j15ZqUVP5zK7Pv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"}],"disc_number":1,"duration_ms":185807,"explicit":false,"external_ids":{"isrc":"NLZ541500166"},"external_urls":{"spotify":"https://open.spotify.com/track/7btFRLmYVWgCdXy6fx8c3H"},"href":"https://api.spotify.com/v1/tracks/7btFRLmYVWgCdXy6fx8c3H","id":"7btFRLmYVWgCdXy6fx8c3H","is_local":false,"is_playable":true,"name":"The Party (This Is How We Do It) [feat. Montell Jordan] - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:7btFRLmYVWgCdXy6fx8c3H"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"}],"external_urls":{"spotify":"https://open.spotify.com/album/6VTrm81s50qmidaYI6EjiQ"},"href":"https://api.spotify.com/v1/albums/6VTrm81s50qmidaYI6EjiQ","id":"6VTrm81s50qmidaYI6EjiQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27332ceb9ba36c33fcb5ceec5f6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0232ceb9ba36c33fcb5ceec5f6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485132ceb9ba36c33fcb5ceec5f6"}],"is_playable":true,"name":"This Is How We Do It","release_date":"1995-01-01","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6VTrm81s50qmidaYI6EjiQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UEm3mXEPGyxeWQJYc8WSx"},"href":"https://api.spotify.com/v1/artists/2UEm3mXEPGyxeWQJYc8WSx","id":"2UEm3mXEPGyxeWQJYc8WSx","name":"Wino","type":"artist","uri":"spotify:artist:2UEm3mXEPGyxeWQJYc8WSx"}],"disc_number":1,"duration_ms":277293,"explicit":true,"external_ids":{"isrc":"USRL19500006"},"external_urls":{"spotify":"https://open.spotify.com/track/1poBO3pO6fkqPYG6n8J5cX"},"href":"https://api.spotify.com/v1/tracks/1poBO3pO6fkqPYG6n8J5cX","id":"1poBO3pO6fkqPYG6n8J5cX","is_local":false,"is_playable":true,"name":"This Is How We Do It","track_number":3,"type":"track","uri":"spotify:track:1poBO3pO6fkqPYG6n8J5cX"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3um3nlao5NXo5HgnhAroun"},"href":"https://api.spotify.com/v1/albums/3um3nlao5NXo5HgnhAroun","id":"3um3nlao5NXo5HgnhAroun","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730d4710c881c896ab9b87831b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020d4710c881c896ab9b87831b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510d4710c881c896ab9b87831b"}],"is_playable":true,"name":"90s R&B","release_date":"2017-07-14","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:3um3nlao5NXo5HgnhAroun"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"}],"disc_number":1,"duration_ms":237182,"explicit":false,"external_ids":{"isrc":"USUM70728132"},"external_urls":{"spotify":"https://open.spotify.com/track/1zZQqAVzY4FS8jSOXt8RTm"},"href":"https://api.spotify.com/v1/tracks/1zZQqAVzY4FS8jSOXt8RTm","id":"1zZQqAVzY4FS8jSOXt8RTm","is_local":false,"is_playable":true,"name":"This Is How We Do It","track_number":3,"type":"track","uri":"spotify:track:1zZQqAVzY4FS8jSOXt8RTm"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/49f5jzJR07KVbRzz5wunDw"},"href":"https://api.spotify.com/v1/albums/49f5jzJR07KVbRzz5wunDw","id":"49f5jzJR07KVbRzz5wunDw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732cb6cdca8bd42d9c26552a79"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022cb6cdca8bd42d9c26552a79"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512cb6cdca8bd42d9c26552a79"}],"is_playable":true,"name":"Hip Hop Summer","release_date":"2020-03-20","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:49f5jzJR07KVbRzz5wunDw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UEm3mXEPGyxeWQJYc8WSx"},"href":"https://api.spotify.com/v1/artists/2UEm3mXEPGyxeWQJYc8WSx","id":"2UEm3mXEPGyxeWQJYc8WSx","name":"Wino","type":"artist","uri":"spotify:artist:2UEm3mXEPGyxeWQJYc8WSx"}],"disc_number":1,"duration_ms":277293,"explicit":false,"external_ids":{"isrc":"USRL19500006"},"external_urls":{"spotify":"https://open.spotify.com/track/0J9b5PmYVxTbr3pa2jnPrV"},"href":"https://api.spotify.com/v1/tracks/0J9b5PmYVxTbr3pa2jnPrV","id":"0J9b5PmYVxTbr3pa2jnPrV","is_local":false,"is_playable":true,"name":"This Is How We Do It","track_number":15,"type":"track","uri":"spotify:track:0J9b5PmYVxTbr3pa2jnPrV"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4JaQWWyzWG2n3gFcLm8DKR"},"href":"https://api.spotify.com/v1/albums/4JaQWWyzWG2n3gFcLm8DKR","id":"4JaQWWyzWG2n3gFcLm8DKR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736aea74f401afea0131351d98"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026aea74f401afea0131351d98"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516aea74f401afea0131351d98"}],"is_playable":true,"name":"Hiphop","release_date":"2006-01-01","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:4JaQWWyzWG2n3gFcLm8DKR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UEm3mXEPGyxeWQJYc8WSx"},"href":"https://api.spotify.com/v1/artists/2UEm3mXEPGyxeWQJYc8WSx","id":"2UEm3mXEPGyxeWQJYc8WSx","name":"Wino","type":"artist","uri":"spotify:artist:2UEm3mXEPGyxeWQJYc8WSx"}],"disc_number":1,"duration_ms":232400,"explicit":true,"external_ids":{"isrc":"USRL19500006"},"external_urls":{"spotify":"https://open.spotify.com/track/300wQeaE8nqusXeNSP987e"},"href":"https://api.spotify.com/v1/tracks/300wQeaE8nqusXeNSP987e","id":"300wQeaE8nqusXeNSP987e","is_local":false,"is_playable":true,"name":"This Is How We Do It","track_number":2,"type":"track","uri":"spotify:track:300wQeaE8nqusXeNSP987e"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3f05ClocN5mdXlXBkepNtW"},"href":"https://api.spotify.com/v1/albums/3f05ClocN5mdXlXBkepNtW","id":"3f05ClocN5mdXlXBkepNtW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730ba3200528142e15416306c3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020ba3200528142e15416306c3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510ba3200528142e15416306c3"}],"is_playable":true,"name":"R&B Club","release_date":"2007-01-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3f05ClocN5mdXlXBkepNtW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UEm3mXEPGyxeWQJYc8WSx"},"href":"https://api.spotify.com/v1/artists/2UEm3mXEPGyxeWQJYc8WSx","id":"2UEm3mXEPGyxeWQJYc8WSx","name":"Wino","type":"artist","uri":"spotify:artist:2UEm3mXEPGyxeWQJYc8WSx"}],"disc_number":1,"duration_ms":207106,"explicit":false,"external_ids":{"isrc":"USRL19500006"},"external_urls":{"spotify":"https://open.spotify.com/track/4I11udnIfIDxRNYLB6yAxo"},"href":"https://api.spotify.com/v1/tracks/4I11udnIfIDxRNYLB6yAxo","id":"4I11udnIfIDxRNYLB6yAxo","is_local":false,"is_playable":true,"name":"This Is How We Do It","track_number":5,"type":"track","uri":"spotify:track:4I11udnIfIDxRNYLB6yAxo"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/21pOJNrfJHEcLHrNL7MeV5"},"href":"https://api.spotify.com/v1/albums/21pOJNrfJHEcLHrNL7MeV5","id":"21pOJNrfJHEcLHrNL7MeV5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b8fc506244122fc428fba38f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b8fc506244122fc428fba38f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b8fc506244122fc428fba38f"}],"is_playable":true,"name":"Absolute R&B","release_date":"2013-01-01","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:21pOJNrfJHEcLHrNL7MeV5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2UEm3mXEPGyxeWQJYc8WSx"},"href":"https://api.spotify.com/v1/artists/2UEm3mXEPGyxeWQJYc8WSx","id":"2UEm3mXEPGyxeWQJYc8WSx","name":"Wino","type":"artist","uri":"spotify:artist:2UEm3mXEPGyxeWQJYc8WSx"}],"disc_number":1,"duration_ms":207106,"explicit":true,"external_ids":{"isrc":"USRL19500006"},"external_urls":{"spotify":"https://open.spotify.com/track/2WynmBLYpa069RBg7XUQdM"},"href":"https://api.spotify.com/v1/tracks/2WynmBLYpa069RBg7XUQdM","id":"2WynmBLYpa069RBg7XUQdM","is_local":false,"is_playable":true,"name":"This Is How We Do It","track_number":15,"type":"track","uri":"spotify:track:2WynmBLYpa069RBg7XUQdM"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4LbbUj2bytdZ1PWEs69QCn"},"href":"https://api.spotify.com/v1/albums/4LbbUj2bytdZ1PWEs69QCn","id":"4LbbUj2bytdZ1PWEs69QCn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a9b18710e8f15c9c6ed078ec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a9b18710e8f15c9c6ed078ec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a9b18710e8f15c9c6ed078ec"}],"is_playable":true,"name":"'90s Soul Number 1's","release_date":"2007-01-01","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:4LbbUj2bytdZ1PWEs69QCn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iVrCROxeyon7MZUW3MfzT"},"href":"https://api.spotify.com/v1/artists/0iVrCROxeyon7MZUW3MfzT","id":"0iVrCROxeyon7MZUW3MfzT","name":"Montell Jordan","type":"artist","uri":"spotify:artist:0iVrCROxeyon7MZUW3MfzT"}],"disc_number":1,"duration_ms":236906,"explicit":false,"external_ids":{"isrc":"USUM70728132"},"external_urls":{"spotify":"https://open.spotify.com/track/6Kj0IpbXBHDgO5UBKpoEn2"},"href":"https://api.spotify.com/v1/tracks/6Kj0IpbXBHDgO5UBKpoEn2","id":"6Kj0IpbXBHDgO5UBKpoEn2","is_local":false,"is_playable":true,"name":"This Is How We Do It","track_number":4,"type":"track","uri":"spotify:track:6Kj0IpbXBHDgO5UBKpoEn2"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRoaXMlMjBJcyUyMEhvdyUyMFdlJTIwRG8lMjBJdCUyMiUyMGFydGlzdCUzQSUyMk1vbnRlbGwlMjBKb3JkYW4lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjksIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBpVnJDUk94ZXlvbjdNWlVXM01melQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGlWckNST3hleW9uN01aVVczTWZ6VCIsImlkIjoiMGlWckNST3hleW9uN01aVVczTWZ6VCIsIm5hbWUiOiJNb250ZWxsIEpvcmRhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowaVZyQ1JPeGV5b243TVpVVzNNZnpUIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNko5ZlgyaVhjOVc3SUxRVVd2RWhBeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZKOWZYMmlYYzlXN0lMUVVXdkVoQXgiLCJpZCI6IjZKOWZYMmlYYzlXN0lMUVVXdkVoQXgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDMwZGViYjI4MzA2NmFjNjcyNTQ4M2NmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQzMGRlYmIyODMwNjZhYzY3MjU0ODNjZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDMwZGViYjI4MzA2NmFjNjcyNTQ4M2NmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlc3QgT2YgTW9udGVsbCBKb3JkYW4iLCJyZWxlYXNlX2RhdGUiOiIyMDE1LTA5LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nko5ZlgyaVhjOVc3SUxRVVd2RWhBeCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBpVnJDUk94ZXlvbjdNWlVXM01melQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGlWcg==", + "Q1JPeGV5b243TVpVVzNNZnpUIiwiaWQiOiIwaVZyQ1JPeGV5b243TVpVVzNNZnpUIiwibmFtZSI6Ik1vbnRlbGwgSm9yZGFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBpVnJDUk94ZXlvbjdNWlVXM01melQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjM3NTQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcwNzI4MTMyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82YUo5MExCbDk2Ymx5OXp1RUgxVTJYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmFKOTBMQmw5NmJseTl6dUVIMVUyWCIsImlkIjoiNmFKOTBMQmw5NmJseTl6dUVIMVUyWCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGlzIElzIEhvdyBXZSBEbyBJdCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2YUo5MExCbDk2Ymx5OXp1RUgxVTJYIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80a3dFZDFQOWoxNVpxVVZQNXpLN1B2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRrd0VkMVA5ajE1WnFVVlA1eks3UHYiLCJpZCI6IjRrd0VkMVA5ajE1WnFVVlA1eks3UHYiLCJuYW1lIjoiSm9lIFN0b25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRrd0VkMVA5ajE1WnFVVlA1eks3UHYifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80UXlUV3F6NnN2dHB1N1hyM0M2UUhVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNFF5VFdxejZzdnRwdTdYcjNDNlFIVSIsImlkIjoiNFF5VFdxejZzdnRwdTdYcjNDNlFIVSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwMjBmYWZmOWY5NDMyOGRkYTFkY2M0MWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDIwZmFmZjlmOTQzMjhkZGExZGNjNDFkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwMjBmYWZmOWY5NDMyOGRkYTFkY2M0MWQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIg==", + "OiJUaGUgUGFydHkgKFRoaXMgSXMgSG93IFdlIERvIEl0KSBbZmVhdC4gTW9udGVsbCBKb3JkYW5dIFtSYWRpbyBFZGl0XSIsInJlbGVhc2VfZGF0ZSI6IjIwMTUtMDUtMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRReVRXcXo2c3Z0cHU3WHIzQzZRSFUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80a3dFZDFQOWoxNVpxVVZQNXpLN1B2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRrd0VkMVA5ajE1WnFVVlA1eks3UHYiLCJpZCI6IjRrd0VkMVA5ajE1WnFVVlA1eks3UHYiLCJuYW1lIjoiSm9lIFN0b25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRrd0VkMVA5ajE1WnFVVlA1eks3UHYifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGlWckNST3hleW9uN01aVVczTWZ6VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8waVZyQ1JPeGV5b243TVpVVzNNZnpUIiwiaWQiOiIwaVZyQ1JPeGV5b243TVpVVzNNZnpUIiwibmFtZSI6Ik1vbnRlbGwgSm9yZGFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBpVnJDUk94ZXlvbjdNWlVXM01melQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg1ODA3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkxaNTQxNTAwMTY2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83YnRGUkxtWVZXZ0NkWHk2Zng4YzNIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2J0RlJMbVlWV2dDZFh5NmZ4OGMzSCIsImlkIjoiN2J0RlJMbVlWV2dDZFh5NmZ4OGMzSCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgUGFydHkgKFRoaXMgSXMgSG93IFdlIERvIEl0KSBbZmVhdC4gTW9udGVsbCBKb3JkYW5dIC0gUmFkaW8gRWRpdCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3YnRGUkxtWVZXZ0NkWHk2Zng4YzNIIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBpVnJDUk94ZXlvbjdNWlVXM01melQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuYw==", + "b20vdjEvYXJ0aXN0cy8waVZyQ1JPeGV5b243TVpVVzNNZnpUIiwiaWQiOiIwaVZyQ1JPeGV5b243TVpVVzNNZnpUIiwibmFtZSI6Ik1vbnRlbGwgSm9yZGFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBpVnJDUk94ZXlvbjdNWlVXM01melQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82VlRybTgxczUwcW1pZGFZSTZFamlRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNlZUcm04MXM1MHFtaWRhWUk2RWppUSIsImlkIjoiNlZUcm04MXM1MHFtaWRhWUk2RWppUSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzMmNlYjliYTM2YzMzZmNiNWNlZWM1ZjYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzJjZWI5YmEzNmMzM2ZjYjVjZWVjNWY2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzMmNlYjliYTM2YzMzZmNiNWNlZWM1ZjYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhpcyBJcyBIb3cgV2UgRG8gSXQiLCJyZWxlYXNlX2RhdGUiOiIxOTk1LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlZUcm04MXM1MHFtaWRhWUk2RWppUSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBpVnJDUk94ZXlvbjdNWlVXM01melQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGlWckNST3hleW9uN01aVVczTWZ6VCIsImlkIjoiMGlWckNST3hleW9uN01aVVczTWZ6VCIsIm5hbWUiOiJNb250ZWxsIEpvcmRhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowaVZyQ1JPeGV5b243TVpVVzNNZnpUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVRW0zbVhFUEd5eGVXUUpZYzhXU3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVFbTNtWEVQR3l4ZVdRSlljOFdTeCIsImlkIjoiMlVFbTNtWEVQR3l4ZVdRSlljOFdTeCIsIm5hbWUiOiJXaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVRW0zbVhFUEd5eGVXUUpZYzhXU3gifV0sImRpcw==", + "Y19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNzcyOTMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkwxOTUwMDAwNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXBvQk8zcE82ZmtxUFlHNm44SjVjWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFwb0JPM3BPNmZrcVBZRzZuOEo1Y1giLCJpZCI6IjFwb0JPM3BPNmZrcVBZRzZuOEo1Y1giLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhpcyBJcyBIb3cgV2UgRG8gSXQiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXBvQk8zcE82ZmtxUFlHNm44SjVjWCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zdW0zbmxhbzVOWG81SGduaEFyb3VuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM3VtM25sYW81TlhvNUhnbmhBcm91biIsImlkIjoiM3VtM25sYW81TlhvNUhnbmhBcm91biIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwZDQ3MTBjODgxYzg5NmFiOWI4NzgzMWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGQ0NzEwYzg4MWM4OTZhYjliODc4MzFiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwZDQ3MTBjODgxYzg5NmFiOWI4NzgzMWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiOTBzIFImQiIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDctMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozdW0zbmxhbw==", + "NU5YbzVIZ25oQXJvdW4ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8waVZyQ1JPeGV5b243TVpVVzNNZnpUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBpVnJDUk94ZXlvbjdNWlVXM01melQiLCJpZCI6IjBpVnJDUk94ZXlvbjdNWlVXM01melQiLCJuYW1lIjoiTW9udGVsbCBKb3JkYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGlWckNST3hleW9uN01aVVczTWZ6VCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzcxODIsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzA3MjgxMzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzF6WlFxQVZ6WTRGUzhqU09YdDhSVG0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xelpRcUFWelk0RlM4alNPWHQ4UlRtIiwiaWQiOiIxelpRcUFWelk0RlM4alNPWHQ4UlRtIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoaXMgSXMgSG93IFdlIERvIEl0IiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjF6WlFxQVZ6WTRGUzhqU09YdDhSVG0ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNDlmNWp6SlIwN0tWYlJ6ejV3dW5EdyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzQ5ZjVqekpSMDdLVmJSeno1d3VuRHciLCJpZCI6IjQ5ZjVqekpSMDdLVmJSeno1d3VuRHciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMmNiNmNkY2E4YmQ0MmQ5YzI2NTUyYTc5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaQ==", + "bWFnZS9hYjY3NjE2ZDAwMDAxZTAyMmNiNmNkY2E4YmQ0MmQ5YzI2NTUyYTc5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEyY2I2Y2RjYThiZDQyZDljMjY1NTJhNzkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGlwIEhvcCBTdW1tZXIiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTAzLTIwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NDlmNWp6SlIwN0tWYlJ6ejV3dW5EdyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBpVnJDUk94ZXlvbjdNWlVXM01melQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGlWckNST3hleW9uN01aVVczTWZ6VCIsImlkIjoiMGlWckNST3hleW9uN01aVVczTWZ6VCIsIm5hbWUiOiJNb250ZWxsIEpvcmRhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowaVZyQ1JPeGV5b243TVpVVzNNZnpUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVRW0zbVhFUEd5eGVXUUpZYzhXU3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVFbTNtWEVQR3l4ZVdRSlljOFdTeCIsImlkIjoiMlVFbTNtWEVQR3l4ZVdRSlljOFdTeCIsIm5hbWUiOiJXaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVRW0zbVhFUEd5eGVXUUpZYzhXU3gifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjc3MjkzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSTDE5NTAwMDA2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wSjliNVBtWVZ4VGJyM3BhMmpuUHJWIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMEo5YjVQbVlWeFRicjNwYTJqblByViIsImlkIjoiMEo5YjVQbVlWeFRicjNwYTJqblByViIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGlzIElzIEhvdyBXZSBEbyBJdCIsInRyYWNrX251bWJlciI6MTUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MEo5YjVQbVlWeFRicjNwYTJqblByViJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLg==", + "c3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRKYVFXV3l6V0cybjNnRmNMbThES1IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80SmFRV1d5eldHMm4zZ0ZjTG04REtSIiwiaWQiOiI0SmFRV1d5eldHMm4zZ0ZjTG04REtSIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZhZWE3NGY0MDFhZmVhMDEzMTM1MWQ5OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2YWVhNzRmNDAxYWZlYTAxMzEzNTFkOTgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZhZWE3NGY0MDFhZmVhMDEzMTM1MWQ5OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIaXBob3AiLCJyZWxlYXNlX2RhdGUiOiIyMDA2LTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0SmFRV1d5eldHMm4zZ0ZjTG04REtSIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGlWckNST3hleW9uN01aVVczTWZ6VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8waVZyQ1JPeGV5b243TVpVVzNNZnpUIiwiaWQiOiIwaVZyQ1JPeGV5b243TVpVVzNNZnpUIiwibmFtZSI6Ik1vbnRlbGwgSm9yZGFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBpVnJDUk94ZXlvbjdNWlVXM01melQifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlVFbTNtWEVQR3l4ZVdRSlljOFdTeCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVUVtM21YRVBHeXhlV1FKWWM4V1N4IiwiaWQiOiIyVUVtM21YRVBHeXhlV1FKWWM4V1N4IiwibmFtZSI6Ildpbm8iLCJ0eXBlIjoiYQ==", + "cnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVUVtM21YRVBHeXhlV1FKWWM4V1N4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzMjQwMCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSTDE5NTAwMDA2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zMDB3UWVhRThucXVzWGVOU1A5ODdlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzAwd1FlYUU4bnF1c1hlTlNQOTg3ZSIsImlkIjoiMzAwd1FlYUU4bnF1c1hlTlNQOTg3ZSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGlzIElzIEhvdyBXZSBEbyBJdCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozMDB3UWVhRThucXVzWGVOU1A5ODdlIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNmMDVDbG9jTjVtZFhsWEJrZXBOdFcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zZjA1Q2xvY041bWRYbFhCa2VwTnRXIiwiaWQiOiIzZjA1Q2xvY041bWRYbFhCa2VwTnRXIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzBiYTMyMDA1MjgxNDJlMTU0MTYzMDZjMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwYmEzMjAwNTI4MTQyZTE1NDE2MzA2YzMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTBiYTMyMDA1MjgxNDJlMTU0MTYzMDZjMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSJkIgQ2x1YiIsInJlbGVhc2VfZGF0ZSI6IjIwMDctMDEtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidA==", + "b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNmMDVDbG9jTjVtZFhsWEJrZXBOdFcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8waVZyQ1JPeGV5b243TVpVVzNNZnpUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBpVnJDUk94ZXlvbjdNWlVXM01melQiLCJpZCI6IjBpVnJDUk94ZXlvbjdNWlVXM01melQiLCJuYW1lIjoiTW9udGVsbCBKb3JkYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGlWckNST3hleW9uN01aVVczTWZ6VCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yVUVtM21YRVBHeXhlV1FKWWM4V1N4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJVRW0zbVhFUEd5eGVXUUpZYzhXU3giLCJpZCI6IjJVRW0zbVhFUEd5eGVXUUpZYzhXU3giLCJuYW1lIjoiV2lubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyVUVtM21YRVBHeXhlV1FKWWM4V1N4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNzEwNiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkwxOTUwMDAwNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNEkxMXVkbklmSUR4Uk5ZTEI2eUF4byJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRJMTF1ZG5JZklEeFJOWUxCNnlBeG8iLCJpZCI6IjRJMTF1ZG5JZklEeFJOWUxCNnlBeG8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhpcyBJcyBIb3cgV2UgRG8gSXQiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NEkxMXVkbklmSUR4Uk5ZTEI2eUF4byJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdA==", + "aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzIxcE9KTnJmSkhFY0xIck5MN01lVjUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yMXBPSk5yZkpIRWNMSHJOTDdNZVY1IiwiaWQiOiIyMXBPSk5yZkpIRWNMSHJOTDdNZVY1IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I4ZmM1MDYyNDQxMjJmYzQyOGZiYTM4ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiOGZjNTA2MjQ0MTIyZmM0MjhmYmEzOGYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI4ZmM1MDYyNDQxMjJmYzQyOGZiYTM4ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBYnNvbHV0ZSBSJkIiLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTAxLTAxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MjFwT0pOcmZKSEVjTEhyTkw3TWVWNSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBpVnJDUk94ZXlvbjdNWlVXM01melQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGlWckNST3hleW9uN01aVVczTWZ6VCIsImlkIjoiMGlWckNST3hleW9uN01aVVczTWZ6VCIsIm5hbWUiOiJNb250ZWxsIEpvcmRhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowaVZyQ1JPeGV5b243TVpVVzNNZnpUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJVRW0zbVhFUEd5eGVXUUpZYzhXU3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMlVFbTNtWEVQR3l4ZVdRSlljOFdTeCIsImlkIjoiMlVFbTNtWEVQR3l4ZVdRSlljOFdTeCIsIm5hbWUiOiJXaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJVRW0zbVhFUEd5eGVXUUpZYzhXU3gifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA3MTA2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JMMTk1MDAwMDYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJXeW5tQkxZcGEwNjlSQmc3WFVRZE0ifSwiaHJlZiI6Imh0dHBzOg==", + "Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJXeW5tQkxZcGEwNjlSQmc3WFVRZE0iLCJpZCI6IjJXeW5tQkxZcGEwNjlSQmc3WFVRZE0iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhpcyBJcyBIb3cgV2UgRG8gSXQiLCJ0cmFja19udW1iZXIiOjE1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJXeW5tQkxZcGEwNjlSQmc3WFVRZE0ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNExiYlVqMmJ5dGRaMVBXRXM2OVFDbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRMYmJVajJieXRkWjFQV0VzNjlRQ24iLCJpZCI6IjRMYmJVajJieXRkWjFQV0VzNjlRQ24iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTliMTg3MTBlOGYxNWM5YzZlZDA3OGVjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmE5YjE4NzEwZThmMTVjOWM2ZWQwNzhlYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTliMTg3MTBlOGYxNWM5YzZlZDA3OGVjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Iic5MHMgU291bCBOdW1iZXIgMSdzIiwicmVsZWFzZV9kYXRlIjoiMjAwNy0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVt", + "OjRMYmJVajJieXRkWjFQV0VzNjlRQ24ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8waVZyQ1JPeGV5b243TVpVVzNNZnpUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBpVnJDUk94ZXlvbjdNWlVXM01melQiLCJpZCI6IjBpVnJDUk94ZXlvbjdNWlVXM01melQiLCJuYW1lIjoiTW9udGVsbCBKb3JkYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGlWckNST3hleW9uN01aVVczTWZ6VCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzY5MDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzA3MjgxMzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZLajBJcGJYQkhEZ081VUJLcG9FbjIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82S2owSXBiWEJIRGdPNVVCS3BvRW4yIiwiaWQiOiI2S2owSXBiWEJIRGdPNVVCS3BvRW4yIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoaXMgSXMgSG93IFdlIERvIEl0IiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZLajBJcGJYQkhEZ081VUJLcG9FbjIifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22This+Is+How+We+Do+It%22+artist%3A%22Montell+Jordan%22&type=track&limit=10" + } +] diff --git a/eval/fixtures/rainy-sunday/anthropic.json b/eval/fixtures/rainy-sunday/anthropic.json new file mode 100644 index 0000000..0aa73e9 --- /dev/null +++ b/eval/fixtures/rainy-sunday/anthropic.json @@ -0,0 +1,66 @@ +[ + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"query\":\"melancholic but warm, for a rainy Sunday morning\",\"history\":[],\"prior_recommendations\":[],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"required_candidate_count\":35}"}],"model":"claude-sonnet-5","output_config":{"effort":"low","format":{"schema":{"$defs":{"CandidateOutput":{"type":"object","description":"One bounded candidate in the intent response.","title":"CandidateOutput","properties":{"title":{"type":"string","title":"Title","description":"{maxLength: 200, minLength: 1}"},"artist":{"type":"string","title":"Artist","description":"{maxLength: 200, minLength: 1}"}},"additionalProperties":false,"required":["title","artist"]},"Familiarity":{"type":"string","enum":["familiar","mix","new"],"description":"How strongly a request should favor known or unknown music.","title":"Familiarity"}},"type":"object","description":"Bounded structured output for the intent call.","title":"IntentOutput","properties":{"mood":{"type":"array","title":"Mood","items":{"type":"string"},"description":"{maxItems: 6}"},"activity":{"anyOf":[{"type":"string","description":"{maxLength: 100}"},{"type":"null"}],"title":"Activity","description":"{default: None}"},"era":{"type":"array","title":"Era","items":{"type":"string"},"description":"{maxItems: 5}"},"languages":{"type":"array","title":"Languages","items":{"type":"string"},"description":"{maxItems: 8}"},"genres":{"type":"array","title":"Genres","items":{"type":"string"},"description":"{maxItems: 8}"},"familiarity":{"$ref":"#/$defs/Familiarity"},"is_refinement":{"type":"boolean","title":"Is Refinement"},"intent_summary":{"type":"string","title":"Intent Summary","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"},"candidates":{"type":"array","title":"Candidates","items":{"$ref":"#/$defs/CandidateOutput"},"description":"{maxItems: 50, minItems: 10}"}},"additionalProperties":false,"required":["familiarity","is_refinement","intent_summary","candidates"]},"type":"json_schema"}},"system":[{"type":"text","text":"You are the intent interpreter and candidate generator for a music discovery system. Your job is to understand one listener request, use the supplied taste evidence carefully, and propose real recordings that another service can resolve against Spotify. Return only data that conforms to the provided output schema. Do not add prose before or after the structured response.\n\nInterpret the request in context. The variable input can contain a current query, a bounded conversation history, recommendations from an earlier response, and a compact taste profile. Treat the current query as authoritative. Use history only to resolve references, continuity, or explicit changes such as \"more like the third one\" or \"less energetic.\" Prior recommendations are evidence about what the listener has just seen, not proof that the listener likes every item. The Spotify taste profile is evidence of listening behavior, not a complete identity and not permission to stereotype the listener.\n\nPopulate every schema field honestly. Mood is a short bounded list of useful musical or emotional qualities. Activity is a concise listening context when one is stated or strongly implied, otherwise null. Era contains only time periods that matter to the request. Languages contains requested or strongly implied vocal languages; use an empty list when language is irrelevant or the music can be instrumental. Genres should be specific enough to guide selection without inventing a false precision. Familiarity must be familiar, mix, or new. Use familiar when the listener asks for comfort, favorites, known songs, or reliable crowd recognition. Use new when the listener asks for discovery, obscurity, unfamiliar music, or a departure from their habits. Use mix for a balanced bridge or when the request does not justify either extreme.\n\nSet is_refinement to true only when the listener is revising, narrowing, extending, or referring to an earlier recommendation result in the supplied conversation. A standalone request is not a refinement merely because history exists. The intent summary must be one plain-English sentence that tells the listener how the request was understood. It must not mention internal models, candidate generation, schemas, retrieval, or Spotify search behavior.\n\nGenerate the exact candidate count requested in the variable input. Each candidate contains only a track title and the credited artist name most likely to identify the recording. Choose recordings that plausibly exist in Spotify's catalog. Use canonical spellings. Do not fabricate tracks, mash up titles and artists, translate titles, or use descriptive placeholders. Avoid remixes, live versions, remasters, edits, sped-up versions, slowed versions, karaoke versions, covers, and tribute recordings unless the user explicitly asks for them. When several recordings share a title, choose the artist credit that makes the intended recording unambiguous.\n\nCandidate quality matters more than superficial variety. Every candidate should fit the interpreted mood, activity, era, language, genre, and familiarity. Still, spread the set across artists. Do not let one artist dominate the candidate list, even when that artist appears prominently in the taste profile. Avoid duplicate titles by the same artist and avoid multiple editions of the same recording. Use a range of strong fits so a later ranking step has meaningful choices rather than thirty near-identical songs.\n\nWhen familiarity leans new, propose music the listener plausibly does not know. Move beyond the named top artists and tracks while retaining understandable bridges through genre, scene, production style, instrumentation, energy, era, or songwriting. Do not simply select deep cuts from every familiar artist. Prefer adjacent artists, overlooked catalogs, regional scenes, and credible cross-genre connections. The profile is not exhaustive, so never claim that a candidate is definitely unknown. When familiarity is familiar, candidates may include supplied top or saved tracks, but remain responsive to the current request. When familiarity is mix, combine recognizable anchors with adjacent discoveries rather than splitting into unrelated halves.\n\nUse musical knowledge conservatively. Base selection on durable, commonly knowable attributes of recordings. Do not invent listening statistics, personal memories, release stories, chart facts, cultural identities, lyrical meanings, or audio features. Do not infer sensitive traits from taste. Explicit safety or content constraints in the request are binding. If a request is broad, create a coherent interpretation instead of asking a question. If constraints conflict, prioritize explicit exclusions, then the current query, then history, then taste evidence.\n\nThe downstream resolver first tries an exact field-filtered search and then a fuzzy bare-text search. Help it succeed with correct title and artist spelling. It will reject weak title or artist matches, so substituting a vaguely related track wastes a candidate. Prefer a confidently identifiable recording over an obscure item whose title or credit you cannot state accurately. Do not include Spotify identifiers, album names, explanations, scores, or justifications in candidate objects.\n\nBefore returning, silently check that the response matches the schema, the candidate list has exactly the requested size, familiarity uses the allowed value, is_refinement reflects conversation continuity, the intent summary is one line, spellings are credible, artist distribution is broad, and no candidate violates an explicit exclusion. Return strictly the structured response and nothing else.\n","cache_control":{"type":"ephemeral"}}]}", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJtb2RlbCI6ImNsYXVkZS1zb25uZXQtNSIsImlkIjoibXNnXzAxMUNkdHVXNUxCYWpRb2Exakt5", + "V1ZUNSIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsImNvbnRlbnQiOlt7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IntcIm1vb2RcIjpbXCJtZWxhbmNob2xpY1wiLFwid2FybVwiLFwicmVmbGVjdGl2ZVwiLFwiY296eVwiLFwibWVsbG93XCJdLFwiYWN0aXZpdHlcIjpcInJlbGF4aW5nIG9uIGEgcmFpbnkgbW9ybmluZ1wiLFwiZXJhXCI6W10sXCJsYW5ndWFnZXNcIjpbXSxcImdlbnJlc1wiOltcImluZGllIGZvbGtcIixcInNvZnQgc291bFwiLFwiZHJlYW0gcG9wXCIsXCJzaW5nZXItc29uZ3dyaXRlclwiLFwiY2hpbGx3YXZlXCJdLFwiZmFtaWxpYXJpdHlcIjpcIm1peFwiLFwiaXNfcmVmaW5lbWVudFwiOmZhbHNlLFwiaW50ZW50X3N1bW1hcnlcIjpcIkEgc29mdCwgYml0dGVyc3dlZXQgbWl4IG9mIHdhcm0sIHJlZmxlY3RpdmUgc29uZ3Mgc3VpdGVkIHRvIGEgcXVpZXQsIHJhaW55IFN1bmRheSBtb3JuaW5nLlwiLFwiY2FuZGlkYXRlc1wiOlt7XCJ0aXRsZVwiOlwiTW9vbiBTb25nXCIsXCJhcnRpc3RcIjpcIlBob2ViZSBCcmlkZ2Vyc1wifSx7XCJ0aXRsZVwiOlwiS2lsYnkgR2lybFwiLFwiYXJ0aXN0XCI6XCJUaGUgQmFja3NlYXQgTG92ZXJzXCJ9LHtcInRpdGxlXCI6XCJSaGlhbm5vblwiLFwiYXJ0aXN0XCI6XCJGbGVldHdvb2QgTWFjXCJ9LHtcInRpdGxlXCI6XCJSZWRib25lXCIsXCJhcnRpc3RcIjpcIkNoaWxkaXNoIEdhbWJpbm9cIn0se1widGl0bGVcIjpcIkNhc2lvXCIsXCJhcnRpc3RcIjpcIkp1bmdsZVwifSx7XCJ0aXRsZVwiOlwiU2tpbm55IExvdmVcIixcImFydGlzdFwiOlwiQm9uIEl2ZXJcIn0se1widGl0bGVcIjpcIkhvbG9jZW5lXCIsXCJhcnRpc3RcIjpcIkJvbiBJdmVyXCJ9LHtcInRpdGxlXCI6XCJNb3Rpb24gU2lja25lc3NcIixcImFydGlzdFwiOlwiUGhvZWJlIEJyaWRnZXJzXCJ9LHtcInRpdGxlXCI6XCJMaWFiaWxpdHlcIixcImFydGlzdFwiOlwiTG9yZGVcIn0se1widGl0bGVcIjpcIkNoZXJyeSBXaW5lXCIsXCJhcnRpc3RcIjpcIkhvemllclwifSx7XCJ0aXRsZVwiOlwiU3VuZGF5IE1vcm5pbmdcIixcImFydGlzdFwiOlwiTWFyb29uIDVcIn0se1widGl0bGVcIjpcIlJhaW55IERheXNcIixcImFydGlzdFwiOlwiTWF5ZXIgSGF3dGhvcm5lXCJ9LHtcInRpdGxlXCI6XCJJIEZhbGwgQXBhcnRcIixcImFydGlzdFwiOlwiUG9zdCBNYWxvbmVcIn0se1widGl0bGVcIjpcIlNsb3cgU2hvd1wiLFwiYXJ0aXN0XCI6XCJUaGUgTmF0aW9uYWxcIn0se1widGl0bGVcIjpcIkZha2UgRW1waXJlXCIsXCJhcnRpc3RcIjpcIlRoZSBOYXRpb25hbFwifSx7XCJ0aXRsZVwiOlwiQ29mZmVlXCIsXCJhcnRpc3RcIjpcImJlYWJhZG9vYmVlXCJ9LHtcInRpdGxlXCI6XCJTdw==", + "ZWF0ZXIgV2VhdGhlclwiLFwiYXJ0aXN0XCI6XCJUaGUgTmVpZ2hib3VyaG9vZFwifSx7XCJ0aXRsZVwiOlwiU3BhY2UgU29uZ1wiLFwiYXJ0aXN0XCI6XCJCZWFjaCBIb3VzZVwifSx7XCJ0aXRsZVwiOlwiTXl0aFwiLFwiYXJ0aXN0XCI6XCJCZWFjaCBIb3VzZVwifSx7XCJ0aXRsZVwiOlwiTGFuZHNsaWRlXCIsXCJhcnRpc3RcIjpcIkZsZWV0d29vZCBNYWNcIn0se1widGl0bGVcIjpcIkZlZWwgSXQgQWxsIEFyb3VuZFwiLFwiYXJ0aXN0XCI6XCJXYXNoZWQgT3V0XCJ9LHtcInRpdGxlXCI6XCJJdnlcIixcImFydGlzdFwiOlwiRnJhbmsgT2NlYW5cIn0se1widGl0bGVcIjpcIkdvZHNwZWVkXCIsXCJhcnRpc3RcIjpcIkZyYW5rIE9jZWFuXCJ9LHtcInRpdGxlXCI6XCJIZWF0aGVyXCIsXCJhcnRpc3RcIjpcIkNvbmFuIEdyYXlcIn0se1widGl0bGVcIjpcIkRvIFlvdSBSZWFsaXplPz9cIixcImFydGlzdFwiOlwiVGhlIEZsYW1pbmcgTGlwc1wifSx7XCJ0aXRsZVwiOlwiVG8gQnVpbGQgYSBIb21lXCIsXCJhcnRpc3RcIjpcIlRoZSBDaW5lbWF0aWMgT3JjaGVzdHJhXCJ9LHtcInRpdGxlXCI6XCJDb2xvZ25lIFdhbHR6XCIsXCJhcnRpc3RcIjpcIkJvbiBJdmVyXCJ9LHtcInRpdGxlXCI6XCJTdHViYm9ybiBMb3ZlXCIsXCJhcnRpc3RcIjpcIlRoZSBMdW1pbmVlcnNcIn0se1widGl0bGVcIjpcIkhvIEhleVwiLFwiYXJ0aXN0XCI6XCJUaGUgTHVtaW5lZXJzXCJ9LHtcInRpdGxlXCI6XCJCbHVlXCIsXCJhcnRpc3RcIjpcIll1bmcgS2FpXCJ9LHtcInRpdGxlXCI6XCJTZWRvbmFcIixcImFydGlzdFwiOlwiSG91bmRtb3V0aFwifSx7XCJ0aXRsZVwiOlwiU3VuIE1vZGVsc1wiLFwiYXJ0aXN0XCI6XCJPREVTWkFcIn0se1widGl0bGVcIjpcIlBpYW5vIEZpcmVcIixcImFydGlzdFwiOlwiU29uZHJlIExlcmNoZVwifSx7XCJ0aXRsZVwiOlwiU2xvdyBEYW5jaW5nIGluIGEgQnVybmluZyBSb29tXCIsXCJhcnRpc3RcIjpcIkpvaG4gTWF5ZXJcIn0se1widGl0bGVcIjpcIkZhbGxpbmcgU2xvd2x5XCIsXCJhcnRpc3RcIjpcIkdsZW4gSGFuc2FyZFwifV19In1dLCJzdG9wX3JlYXNvbiI6ImVuZF90dXJuIiwic3RvcF9zZXF1ZW5jZSI6bnVsbCwic3RvcF9kZXRhaWxzIjpudWxsLCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjQ5OTQsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjI3ODMsImNhY2hlX2NyZWF0aW9uIjp7ImVwaGVtZXJhbF81bV9pbnB1dF90b2tlbnMiOjAsImVwaGVtZXJhbF8xaF9pbnB1dF90b2tlbnMiOjB9LCJvdXRwdXRfdG9rZW5zIjoxMDAzLCJvdXRwdXRfdG9rZW5zX2RldGFpbHMiOnsidGhpbmtpbmdfdG9rZW5zIjowfSwic2VydmljZV90aQ==", + "ZXIiOiJzdGFuZGFyZCIsImluZmVyZW5jZV9nZW8iOiJnbG9iYWwifX0=" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"intent\":{\"mood\":[\"melancholic\",\"warm\",\"reflective\",\"cozy\",\"mellow\"],\"activity\":\"relaxing on a rainy morning\",\"era\":[],\"languages\":[],\"genres\":[\"indie folk\",\"soft soul\",\"dream pop\",\"singer-songwriter\",\"chillwave\"],\"familiarity\":\"mix\",\"intent_summary\":\"A soft, bittersweet mix of warm, reflective songs suited to a quiet, rainy Sunday morning.\"},\"grounded_pool\":[{\"track_id\":\"46RNrAkGsqWTDrv2ZPOAbx\",\"title\":\"Moon Song\",\"artists\":[\"Phoebe Bridgers\"]},{\"track_id\":\"1170VohRSx6GwE6QDCHPPH\",\"title\":\"Kilby Girl\",\"artists\":[\"The Backseat Lovers\"]},{\"track_id\":\"05oETzWbd4SI33qK2gbJfR\",\"title\":\"Rhiannon\",\"artists\":[\"Fleetwood Mac\"]},{\"track_id\":\"3vQ4T78TTMOjQXGfXVKQJo\",\"title\":\"Redbone\",\"artists\":[\"Childish Gambino\"]},{\"track_id\":\"44ZKnfWEkp7wPs035j4Tua\",\"title\":\"Casio\",\"artists\":[\"Jungle\"]},{\"track_id\":\"3B3eOgLJSqPEA0RfboIQVM\",\"title\":\"Skinny Love\",\"artists\":[\"Bon Iver\"]},{\"track_id\":\"35KiiILklye1JRRctaLUb4\",\"title\":\"Holocene\",\"artists\":[\"Bon Iver\"]},{\"track_id\":\"25Syi9wnfn6ZGAmiOBypPq\",\"title\":\"Motion Sickness\",\"artists\":[\"Phoebe Bridgers\"]},{\"track_id\":\"6Kkt27YmFyIFrcX3QXFi2o\",\"title\":\"Liability\",\"artists\":[\"Lorde\"]},{\"track_id\":\"4Q66chx9WzqWcLItXoZ5r4\",\"title\":\"Cherry Wine - Live\",\"artists\":[\"Hozier\"]},{\"track_id\":\"5qII2n90lVdPDcgXEEVHNy\",\"title\":\"Sunday Morning\",\"artists\":[\"Maroon 5\"]},{\"track_id\":\"75ZvA4QfFiZvzhj2xkaWAh\",\"title\":\"I Fall Apart\",\"artists\":[\"Post Malone\"]},{\"track_id\":\"3roye2IJK1EWshYzqtbFHs\",\"title\":\"Slow Show\",\"artists\":[\"The National\"]},{\"track_id\":\"65aZDJQwNllPxuLPixJ4YO\",\"title\":\"Fake Empire\",\"artists\":[\"The National\"]},{\"track_id\":\"429NtPmr12aypzFH3FkN9l\",\"title\":\"Coffee\",\"artists\":[\"beabadoobee\"]},{\"track_id\":\"2QjOHCTQ1Jl3zawyYOpxh6\",\"title\":\"Sweater Weather\",\"artists\":[\"The Neighbourhood\"]},{\"track_id\":\"1ZgMsA55GIY7ICkQh5MILA\",\"title\":\"Space Song\",\"artists\":[\"Beach House\"]},{\"track_id\":\"2Zw3HNjaNV42LnQ2uY5JQs\",\"title\":\"Myth\",\"artists\":[\"Beach House\"]},{\"track_id\":\"5ihS6UUlyQAfmp48eSkxuQ\",\"title\":\"Landslide\",\"artists\":[\"Fleetwood Mac\"]},{\"track_id\":\"4V0x90QcMh4ZxwHzEWOdtK\",\"title\":\"Feel It All Around\",\"artists\":[\"Washed Out\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"history\":[],\"requested_selection_count\":15,\"correction\":null}"}],"model":"claude-sonnet-5","output_config":{"effort":"medium","format":{"type":"json_schema","schema":{"$defs":{"RerankSelectionOutput":{"type":"object","description":"One validated object extracted from the rerank stream.","title":"RerankSelectionOutput","properties":{"track_id":{"type":"string","title":"Track Id","description":"{maxLength: 200, minLength: 1}"},"justification":{"type":"string","title":"Justification","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"}},"additionalProperties":false,"required":["track_id","justification"]}},"type":"object","description":"Complete bounded rerank output used for final validation.","title":"RerankOutput","properties":{"recommendations":{"type":"array","title":"Recommendations","items":{"$ref":"#/$defs/RerankSelectionOutput"},"minItems":1,"description":"{maxItems: 50}"}},"additionalProperties":false,"required":["recommendations"]}}},"system":[{"type":"text","text":"You are the final ranking component of a music discovery system. Select and order tracks only from the grounded Spotify pool supplied in the variable input. Return only data that conforms to the provided JSON schema. Output strictly the JSON object required by that schema, with no markdown, no code fence, no introductory sentence, and no trailing commentary.\n\nThe variable input contains the interpreted intent, a compact listener taste summary, bounded conversation history, and a grounded pool. Every pool entry includes a Spotify track id, title, and artist names. The pool is the complete set of allowed choices. Copy track_id values exactly. Never create, alter, guess, shorten, or normalize an id. Never select a title that is absent from the pool, even if it would be a better recommendation. Never return the same track id twice.\n\nChoose up to the requested selection count, ordered from strongest to weakest recommendation. Prefer a shorter set of honest strong fits over padding with clearly unsuitable material, but normally fill the requested count when the pool contains enough relevant choices. Ranking should respond to the current intent first. Use the taste summary to personalize among plausible fits, not to override an explicit request. Use history to understand refinements and references. Treat prior assistant statements as conversation context rather than verified facts about a recording.\n\nRespect the interpreted mood, activity, era, languages, genres, and familiarity together. A track need not satisfy every soft descriptor equally, but the ordering should form a coherent listening path. Put the clearest overall matches early. Consider transitions in energy, texture, and familiarity when that creates a more useful sequence, while avoiding a mechanical pattern. Spread selections across artists where the grounded pool permits it. Do not rank several editions of the same recording merely to fill space.\n\nFamiliarity affects ordering, but it does not grant access to information outside the input. For familiar requests, favor grounded tracks that visibly connect to the supplied taste evidence or prior recommendations. For new requests, favor credible adjacent discoveries and avoid leaning entirely on artists named in the taste summary. For mix requests, use recognizable anchors and exploratory choices in a coherent balance. The application may already have filtered known tracks, so do not claim that any selection is definitely new or previously unheard.\n\nWrite one concise, plain-English justification for each selection. It should connect the track to the stated intent and, only when supported, to an explicit item or pattern in the supplied taste summary. Keep it to one line. Make the reason useful to the listener rather than describing internal ranking operations. Good reasons identify a grounded connection such as pacing for the activity, a genre bridge, a requested era, a compatible vocal language, a mood transition, or continuity with a named preference.\n\nBe exact and modest. Do not invent audio measurements, tempo values, key signatures, instrumentation, lyrical subjects, release dates, artist biographies, chart history, cultural significance, collaborations, popularity, or claims about what the listener has heard. A title and artist name alone do not prove detailed sonic or lyrical facts. You may use stable general musical knowledge when confident, but phrase the justification around the supplied intent and visible evidence. If the inputs do not support a specific fact, use a restrained reason such as \"A focused fit for the requested late-night electronic mood\" rather than manufacturing detail.\n\nDo not mention Spotify search, grounding, the candidate generator, language models, schemas, hidden scores, safety filters, cache state, or missing data in a justification. Do not tell the listener that a track was selected because it was available in the pool. Do not compare a selection with tracks that are not in the pool. Do not repeat the same generic sentence for every item. Avoid promotional language and absolute claims such as \"perfect,\" \"guaranteed,\" or \"the best.\"\n\nWhen the variable input says this is a correction attempt, treat the stated validation failure as a strict constraint. Return a fresh complete JSON object, not a patch or explanation. Correct invalid ids, duplicates, malformed fields, count problems, and formatting errors using only the supplied pool. The correction instruction never allows an out-of-pool id.\n\nThe response must be one JSON object with the exact top-level field required by the schema. Each array item must contain exactly a track_id and justification in the required types. Preserve the requested ranking order in the array. Use valid JSON quoting and escaping. Do not emit comments, dangling commas, alternate keys, null justifications, numeric ids, or additional properties.\n\nBefore returning, silently verify every track_id against the supplied pool, ensure all ids are unique, ensure the number of items does not exceed the requested count, confirm each justification is honest and one line, confirm the ranking follows the current intent, and confirm the entire response is valid against the provided JSON schema. Return only the JSON object.\n","cache_control":{"type":"ephemeral"}}],"stream":true}", + "response_body_base64": "event: message_start
data: {"type":"message_start","message":{"model":"claude-sonnet-5","id":"msg_011CdtuXAtqF1oaPdvXFpNXx","type":"message","role":"assistant","content":[],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":6147,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"global"}}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}     }

event: ping
data: {"type": "ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"{"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"rec"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ommendations\":[{\"track_id\":\"46RNrAkGsqWT"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Drv2ZPOAbx\",\"justification\":\"A h"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ushed, reflective track that suits a slow rainy morning and echoes a song already in your saved library.\"},{\"track_id\":\"1ZgMs"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"A55GIY7ICkQh5M"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ILA\",\"justification\":\"Hazy dream pop textures make for gentle, unhurried listening on a quiet gray morning.\"},{\"track"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"_id\":\"3roye2IJK1EWshYz"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"qtbFHs\",\"justification\":\"Its slow-building warmth fits the cozy, bittersweet mood of a reflective ind"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"oor morning.\"},{\"track_id\":\"5ihS6UUlyQAf"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"mp48eSkxuQ\",\"justification\":\"A wistful folk-rock classic that conn"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ects to your visible Fleetwood Mac listening while matching the melancholic tone.\"},{\"track_id\":\"3B3eOgL"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"JSqPEA0RfboIQVM"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"Sparse acoustic singer-songwriter texture that feels intimate and fitting for a slow, contemplative start to the day.\"},{\"track_id\":\"2Zw"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"3HNjaNV42LnQ2"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"uY5JQs\",\"justification\":\"Soft, atmospheric dream pop that keeps the mellow rainy-day"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" thread going without raising the energy too much.\"},{\"track_id\":\"44ZKnfW"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Ekp7wPs035j4Tua\",\"justification\":\"A smoo"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"th, soulful groove that ties to your recent listening while staying gentle enough for a slow morning.\"},{\"track_id\":\"65a"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ZDJQwNllPxuLP"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ixJ4YO\",\"justification\":\"A brooding, low-key indie track that deepens the reflective mood without"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" disrupting the calm pacing.\"},{\"track_id\":\"25Syi9wnfn"}               }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"6ZGAmiOBypPq\",\"justification\":\"A quietly a"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ching singer-songwriter piece that continues the introspective, rainy-morning arc.\"},{\"track_id\":\"05oETzW"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"bd4SI33qK2gbJf"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"R\",\"justification\":\"A warm, familiar classic that bridges your Fleetwood Mac affinity with the requested reflective mood.\"},{\"track_id"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\":\"429NtPmr12aypzFH3F"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"kN9l\",\"justification\":\"A soft, understated bedroom-pop moment that fits the cozy, low-energ"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"y morning setting.\"},{\"track_id\":\"4V0x90QcMh4Zx"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"wHzEWOdtK\",\"justification\":\"A hazy chillwave track that mirrors the dr"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"owsy, rain-soaked atmosphere of the request.\"},{\"track_id\":\"6Kkt27YmF"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"yIFrcX3QXFi2o"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"A tender, minimal ballad that keeps the emotional tone gentle and unresolved, fitting the mellow morning.\"},{\"track_id\":\"1"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"170VohRSx6GwE6QDCH"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"PPH\",\"justification\":\"An indie-folk leaning track with warmth and nostalgia that suits a slow"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" Sunday listening session.\"},{\"track_id\":\"3vQ4T78TTMOj"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"QXGfXVKQJo\",\"justification\":\"A familiar, so"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ulful favorite from your top artists that adds warmth while easing the mix toward a gentle"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" close.\"}]}"}     }

event: content_block_stop
data: {"type":"content_block_stop","index":0              }

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null,"stop_details":null},"usage":{"input_tokens":6147,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"output_tokens":1047,"output_tokens_details":{"thinking_tokens":0}}}

event: message_stop
data: {"type":"message_stop"               }

", + "response_chunks_base64": [ + "ZXZlbnQ6IG1lc3NhZ2Vfc3RhcnQKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9zdGFydCIsIm1lc3NhZ2U=", + "Ijp7Im1vZGVsIjoiY2xhdWRlLXNvbm5ldC01IiwiaWQiOiJtc2dfMDExQ2R0dVhBdHFGMW9hUGR2WEZwTlh4IiwidHlwZSI6Im1lc3NhZ2UiLCJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6W10sInN0b3BfcmVhc29uIjpudWxsLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NjE0NywiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MjExMywiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MCwiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjEsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Imdsb2JhbCJ9fX0KCmV2ZW50OiBjb250ZW50X2Jsb2NrX3N0YXJ0CmRhdGE6IHsidHlwZSI6ImNvbnRlbnRfYmxvY2tfc3RhcnQiLCJpbmRleCI6MCwiY29udGVudF9ibG9jayI6eyJ0eXBlIjoidGV4dCIsInRleHQiOiIifSAgICAgfQoKZXZlbnQ6IHBpbmcKZGF0YTogeyJ0eXBlIjogInBpbmcifQoKZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ7In0gICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInJlYyJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvbW1lbmRhdGlvbnNcIjpbe1widHJhY2tfaWRcIjpcIjQ2Uk5yQWtHc3FXVCJ9fQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJEcnYyWlBPQWJ4XCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIGgifSAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ1c2hlZCwgcmVmbGVjdGl2ZSB0cmFjayB0aGF0IHN1aXRzIGEgc2xvdyByYWlueSBtb3JuaW5nIGFuZCBlY2hvZXMgYSBzb25nIGFscmVhZHkgaW4geW91ciBzYXZlZCBsaWJyYXJ5LlwifSx7XCJ0cmFja19pZFwiOlwiMVpnTXMifSAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJBNTVHSVk3SUNrUWg1TSJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJJTEFcIixcImp1c3RpZmljYXRpb25cIjpcIkhhenkgZHJlYW0gcG9wIHRleHR1cmVzIG1ha2UgZm9yIGdlbnRsZSwgdW5odXJyaWVkIGxpc3RlbmluZyBvbiBhIHF1aWV0IGdyYXkgbW9ybmluZy5cIn0se1widHJhY2sifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJfaWRcIjpcIjNyb3llMklKSzFFV3NoWXoifSAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJxdGJGSHNcIixcImp1c3RpZmljYXRpb25cIjpcIkl0cyBzbG93LWJ1aWxkaW5nIHdhcm10aCBmaXRzIHRoZSBjb3p5LCBiaXR0ZXJzd2VldCBtb29kIG9mIGEgcmVmbGVjdGl2ZSBpbmQifSAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvb3IgbW9ybmluZy5cIn0se1widHJhY2tfaWRcIjpcIjVpaFM2VVVseVFBZiJ9ICAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJtcDQ4ZVNreHVRXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIHdpc3RmdWwgZm9say1yb2NrIGNsYXNzaWMgdGhhdCBjb25uIn0gICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJlY3RzIHRvIHlvdXIgdmlzaWJsZSBGbGVldHdvb2QgTWFjIGxpc3RlbmluZyB3aGlsZSBtYXRjaGluZyB0aGUgbWVsYW5jaG9saWMgdG9uZS5cIn0se1widHJhY2tfaWRcIjpcIjNCM2VPZ0wifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJKU3FQRUEwUmZib0lRVk0ifSAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIlNwYXJzZSBhY291c3RpYyBzaW5nZXItc29uZ3dyaXRlciB0ZXh0dXJlIHRoYXQgZmVlbHMgaW50aW1hdGUgYW5kIGZpdHRpbmcgZm9yIGEgc2xvdywgY29udGVtcGxhdGl2ZSBzdGFydCB0byB0aGUgZGF5LlwifSx7XCJ0cmFja19pZFwiOlwiMlp3In0gIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIzSE5qYU5WNDJMblEyIn0gIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ1WTVKUXNcIixcImp1c3RpZmljYXRpb25cIjpcIlNvZnQsIGF0bW9zcGhlcmljIGRyZWFtIHBvcCB0aGF0IGtlZXBzIHRoZSBtZWxsb3cgcmFpbnktZGF5In0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgdGhyZWFkIGdvaW5nIHdpdGhvdXQgcmFpc2luZyB0aGUgZW5lcmd5IHRvbyBtdWNoLlwifSx7XCJ0cmFja19pZFwiOlwiNDRaS25mVyJ9fQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJFa3A3d1BzMDM1ajRUdWFcIixcImp1c3RpZmljYXRpb25cIjpcIkEgc21vbyJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ0aCwgc291bGZ1bCBncm9vdmUgdGhhdCB0aWVzIHRvIHlvdXIgcmVjZW50IGxpc3RlbmluZyB3aGlsZSBzdGF5aW5nIGdlbnRsZSBlbm91Z2ggZm9yIGEgc2xvdyBtb3JuaW5nLlwifSx7XCJ0cmFja19pZFwiOlwiNjVhIn0gICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJaREpRd05sbFB4dUxQIn0gICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpeEo0WU9cIixcImp1c3RpZmljYXRpb25cIjpcIkEgYnJvb2RpbmcsIGxvdy1rZXkgaW5kaWUgdHJhY2sgdGhhdCBkZWVwZW5zIHRoZSByZWZsZWN0aXZlIG1vb2Qgd2l0aG91dCJ9ICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgZGlzcnVwdGluZyB0aGUgY2FsbSBwYWNpbmcuXCJ9LHtcInRyYWNrX2lkXCI6XCIyNVN5aTl3bmZuIn0gICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI2WkdBbWlPQnlwUHFcIixcImp1c3RpZmljYXRpb25cIjpcIkEgcXVpZXRseSBhIn0gfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJjaGluZyBzaW5nZXItc29uZ3dyaXRlciBwaWVjZSB0aGF0IGNvbnRpbnVlcyB0aGUgaW50cm9zcGVjdGl2ZSwgcmFpbnktbW9ybmluZyBhcmMuXCJ9LHtcInRyYWNrX2lkXCI6XCIwNW9FVHpXIn19Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJiZDRTSTMzcUsyZ2JKZiJ9ICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJSXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIHdhcm0sIGZhbWlsaWFyIGNsYXNzaWMgdGhhdCBicmlkZ2VzIHlvdXIgRmxlZXR3b29kIE1hYyBhZmZpbml0eSB3aXRoIHRoZSByZXF1ZXN0ZWQgcmVmbGVjdGl2ZSBtb29kLlwifSx7XCJ0cmFja19pZCJ9ICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIjpcIjQyOU50UG1yMTJheXB6RkgzRiJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJrTjlsXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIHNvZnQsIHVuZGVyc3RhdGVkIGJlZHJvb20tcG9wIG1vbWVudCB0aGF0IGZpdHMgdGhlIGNvenksIGxvdy1lbmVyZyJ9fQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ5IG1vcm5pbmcgc2V0dGluZy5cIn0se1widHJhY2tfaWRcIjpcIjRWMHg5MFFjTWg0WngifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ3SHpFV09kdEtcIixcImp1c3RpZmljYXRpb25cIjpcIkEgaGF6eSBjaGlsbHdhdmUgdHJhY2sgdGhhdCBtaXJyb3JzIHRoZSBkciJ9fQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvd3N5LCByYWluLXNvYWtlZCBhdG1vc3BoZXJlIG9mIHRoZSByZXF1ZXN0LlwifSx7XCJ0cmFja19pZFwiOlwiNktrdDI3WW1GIn0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ5SUZyY1gzUVhGaTJvIn0gICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIkEgdGVuZGVyLCBtaW5pbWFsIGJhbGxhZCB0aGF0IGtlZXBzIHRoZSBlbW90aW9uYWwgdG9uZSBnZW50bGUgYW5kIHVucmVzb2x2ZWQsIGZpdHRpbmcgdGhlIG1lbGxvdyBtb3JuaW5nLlwifSx7XCJ0cmFja19pZFwiOlwiMSJ9ICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIxNzBWb2hSU3g2R3dFNlFEQ0gifSAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJQUEhcIixcImp1c3RpZmljYXRpb25cIjpcIkFuIGluZGllLWZvbGsgbGVhbmluZyB0cmFjayB3aXRoIHdhcm10aCBhbmQgbm9zdGFsZ2lhIHRoYXQgc3VpdHMgYSBzbG93In19Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgU3VuZGF5IGxpc3RlbmluZyBzZXNzaW9uLlwifSx7XCJ0cmFja19pZFwiOlwiM3ZRNFQ3OFRUTU9qIn0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJRWEdmWFZLUUpvXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJBIGZhbWlsaWFyLCBzbyJ9ICAgICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ1bGZ1bCBmYXZvcml0ZSBmcm9tIHlvdXIgdG9wIGFydGlzdHMgdGhhdCBhZGRzIHdhcm10aCB3aGlsZSBlYXNpbmcgdGhlIG1peCB0b3dhcmQgYSBnZW50bGUifSB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgY2xvc2UuXCJ9XX0ifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RvcApkYXRhOiB7InR5cGUiOiJjb250ZW50X2Jsb2NrX3N0b3AiLCJpbmRleCI6MCAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IG1lc3NhZ2VfZGVsdGEKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9kZWx0YSIsImRlbHRhIjp7InN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGx9LCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjYxNDcsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjIxMTMsIm91dHB1dF90b2tlbnMiOjEwNDcsIm91dHB1dF90b2tlbnNfZGV0YWlscyI6eyJ0aGlua2luZ190b2tlbnMiOjB9fX0KCmV2ZW50OiBtZXNzYWdlX3N0b3AKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9zdG9wIiAgICAgICAgICAgICAgIH0KCg==" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + } +] diff --git a/eval/fixtures/rainy-sunday/spotify.json b/eval/fixtures/rainy-sunday/spotify.json new file mode 100644 index 0000000..f16835d --- /dev/null +++ b/eval/fixtures/rainy-sunday/spotify.json @@ -0,0 +1,408 @@ +[ + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=", + "response_chunks_base64": [ + "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=0" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1vb24lMjBTb25nJTIyJTIwYXJ0aXN0JTNBJTIyUGhvZWJlJTIwQnJpZGdlcnMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsImlkIjoiMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsIm5hbWUiOiJQaG9lYmUgQnJpZGdlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZQcDZxR0V5d0Rkb2ZnRkMxb0ZiU0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82UHA2cUdFeXdEZG9mZ0ZDMW9GYlNIIiwiaWQiOiI2UHA2cUdFeXdEZG9mZ0ZDMW9GYlNIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLg==", + "c2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTkxYjc1YzllZjY1ZWQ4ZDc2MGZmNjAwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmE5MWI3NWM5ZWY2NWVkOGQ3NjBmZjYwMCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTkxYjc1YzllZjY1ZWQ4ZDc2MGZmNjAwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlB1bmlzaGVyIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wNi0xOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZQcDZxR0V5d0Rkb2ZnRkMxb0ZiU0gifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xcjF1eG95MTlmek14dW50M09OQWtHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJpZCI6IjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJuYW1lIjoiUGhvZWJlIEJyaWRnZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjc3Njc2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNKNUcyMDIwMDA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80NlJOckFrR3NxV1REcnYyWlBPQWJ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNDZSTnJBa0dzcVdURHJ2MlpQT0FieCIsImlkIjoiNDZSTnJBa0dzcVdURHJ2MlpQT0FieCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb29uIFNvbmciLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NDZSTnJBa0dzcVdURHJ2MlpQT0FieCJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Moon+Song%22+artist%3A%22Phoebe+Bridgers%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMktpbGJ5JTIwR2lybCUyMiUyMGFydGlzdCUzQSUyMlRoZSUyMEJhY2tzZWF0JTIwTG92ZXJzJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82cDJIbmZNOTU1VEkxYlgzNGRrTG5JIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZwMkhuZk05NTVUSTFiWDM0ZGtMbkkiLCJpZCI6IjZwMkhuZk05NTVUSTFiWDM0ZGtMbkkiLCJuYW1lIjoiVGhlIEJhY2tzZWF0IExvdmVycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2cDJIbmZNOTU1VEkxYlgzNGRrTG5JIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM1RTTVNoNWRhaTdXRW5FR09vTVhCWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNUU01TaDVkYWk3V0VuRUdPb01YQloiLCJpZCI6IjNUU01TaDVkYWk3V0VuRUdPb01YQloiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOg==", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4Mzg2Nzk1YTYzNmQ3MmU3NGM5NTg1OTAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODM4Njc5NWE2MzZkNzJlNzRjOTU4NTkwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4Mzg2Nzk1YTYzNmQ3MmU3NGM5NTg1OTAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2hlbiBXZSBXZXJlIEZyaWVuZHMiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTAxLTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozVFNNU2g1ZGFpN1dFbkVHT29NWEJaIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNnAySG5mTTk1NVRJMWJYMzRka0xuSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82cDJIbmZNOTU1VEkxYlgzNGRrTG5JIiwiaWQiOiI2cDJIbmZNOTU1VEkxYlgzNGRrTG5JIiwibmFtZSI6IlRoZSBCYWNrc2VhdCBMb3ZlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NnAySG5mTTk1NVRJMWJYMzRka0xuSSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyODIyMDUsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0NHSDE5MzYzODcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzExNzBWb2hSU3g2R3dFNlFEQ0hQUEgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xMTcwVm9oUlN4Nkd3RTZRRENIUFBIIiwiaWQiOiIxMTcwVm9oUlN4Nkd3RTZRRENIUFBIIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IktpbGJ5IEdpcmwiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MTE3MFZvaFJTeDZHd0U2UURDSFBQSCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82cDJIbmZNOTU1VEkxYlgzNGRrTG5JIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZwMkhuZk05NTVUSTFiWDM0ZGtMbkkiLCJpZCI6IjZwMkhuZk05NTVUSTFiWDM0ZGtMbkkiLCJuYW1lIg==", + "OiJUaGUgQmFja3NlYXQgTG92ZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZwMkhuZk05NTVUSTFiWDM0ZGtMbkkifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80eXk5cWswSU1nTkN6d2w1ejBBR2dSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHl5OXFrMElNZ05DendsNXowQUdnUiIsImlkIjoiNHl5OXFrMElNZ05DendsNXowQUdnUiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiZWZiYTIyNTc0NGFhZjA1ODFmZTA0NjQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmVmYmEyMjU3NDRhYWYwNTgxZmUwNDY0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiZWZiYTIyNTc0NGFhZjA1ODFmZTA0NjQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGl2ZSBmcm9tIHRoZSBUcm91YmFkb3VyIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0xMS0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjR5eTlxazBJTWdOQ3p3bDV6MEFHZ1IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82cDJIbmZNOTU1VEkxYlgzNGRrTG5JIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZwMkhuZk05NTVUSTFiWDM0ZGtMbkkiLCJpZCI6IjZwMkhuZk05NTVUSTFiWDM0ZGtMbkkiLCJuYW1lIjoiVGhlIEJhY2tzZWF0IExvdmVycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2cDJIbmZNOTU1VEkxYlgzNGRrTG5JIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2MjM2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFNM0RGMjE3MDIyNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM3RINzQ4QlhRalVQdXlxNTdKc243QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzN0SDc0OEJYUWpVUHV5cTU3SnNuN0IiLCJpZCI6IjN0SDc0OEJYUWpVUHV5cTU3SnNuN0IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS2lsYnkgRw==", + "aXJsIChMaXZlKSIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozdEg3NDhCWFFqVVB1eXE1N0pzbjdCIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Kilby+Girl%22+artist%3A%22The+Backseat+Lovers%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Rhiannon%22%20artist%3A%22Fleetwood%20Mac%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/5VIQ3VaAoRKOEpJ0fewdvo"},"href":"https://api.spotify.com/v1/albums/5VIQ3VaAoRKOEpJ0fewdvo","id":"5VIQ3VaAoRKOEpJ0fewdvo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734fb043195e8d07e72edc7226"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024fb043195e8d07e72edc7226"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514fb043195e8d07e72edc7226"}],"is_playable":true,"name":"Fleetwood Mac","release_date":"1975-07-11","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5VIQ3VaAoRKOEpJ0fewdvo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":252773,"explicit":false,"external_ids":{"isrc":"USWB19900188"},"external_urls":{"spotify":"https://open.spotify.com/track/05oETzWbd4SI33qK2gbJfR"},"href":"https://api.spotify.com/v1/tracks/05oETzWbd4SI33qK2gbJfR","id":"05oETzWbd4SI33qK2gbJfR","is_local":false,"is_playable":true,"name":"Rhiannon","track_number":4,"type":"track","uri":"spotify:track:05oETzWbd4SI33qK2gbJfR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/0LfM3PGkXE6KvJEE1HkOnz"},"href":"https://api.spotify.com/v1/albums/0LfM3PGkXE6KvJEE1HkOnz","id":"0LfM3PGkXE6KvJEE1HkOnz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273eb832efe061888ee7ef10456"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02eb832efe061888ee7ef10456"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851eb832efe061888ee7ef10456"}],"is_playable":true,"name":"Greatest Hits","release_date":"1988-11-22","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:0LfM3PGkXE6KvJEE1HkOnz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":252773,"explicit":false,"external_ids":{"isrc":"USWB19900188"},"external_urls":{"spotify":"https://open.spotify.com/track/5TWPfkeN07aERO0Yn2D2t2"},"href":"https://api.spotify.com/v1/tracks/5TWPfkeN07aERO0Yn2D2t2","id":"5TWPfkeN07aERO0Yn2D2t2","is_local":false,"is_playable":true,"name":"Rhiannon","track_number":1,"type":"track","uri":"spotify:track:5TWPfkeN07aERO0Yn2D2t2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OQxaj2MqTb9nEtoTPfN4P"},"href":"https://api.spotify.com/v1/albums/0OQxaj2MqTb9nEtoTPfN4P","id":"0OQxaj2MqTb9nEtoTPfN4P","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346c433f89c341ad1f3b9fcae"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246c433f89c341ad1f3b9fcae"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146c433f89c341ad1f3b9fcae"}],"is_playable":true,"name":"Fleetwood Mac (Deluxe Edition)","release_date":"1975-07-11","release_date_precision":"day","total_tracks":46,"type":"album","uri":"spotify:album:0OQxaj2MqTb9nEtoTPfN4P"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":228320,"explicit":false,"external_ids":{"isrc":"USRH11700083"},"external_urls":{"spotify":"https://open.spotify.com/track/0s6E8LxUNeRjm9rXEh9e9w"},"href":"https://api.spotify.com/v1/tracks/0s6E8LxUNeRjm9rXEh9e9w","id":"0s6E8LxUNeRjm9rXEh9e9w","is_local":false,"is_playable":true,"name":"Rhiannon (Will You Ever Win) - Single; 2017 Remaster","track_number":13,"type":"track","uri":"spotify:track:0s6E8LxUNeRjm9rXEh9e9w"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/7A0defNYClzfQHV8ifOBv0"},"href":"https://api.spotify.com/v1/albums/7A0defNYClzfQHV8ifOBv0","id":"7A0defNYClzfQHV8ifOBv0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27353dd2d2264885e16b3315516"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0253dd2d2264885e16b3315516"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485153dd2d2264885e16b3315516"}],"is_playable":true,"name":"The Very Best Of Fleetwood Mac","release_date":"2002-10-12","release_date_precision":"day","total_tracks":36,"type":"album","uri":"spotify:album:7A0defNYClzfQHV8ifOBv0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":226666,"explicit":false,"external_ids":{"isrc":"USWB10202606"},"external_urls":{"spotify":"https://open.spotify.com/track/023whGJfx9QY3JDDCajKHW"},"href":"https://api.spotify.com/v1/tracks/023whGJfx9QY3JDDCajKHW","id":"023whGJfx9QY3JDDCajKHW","is_local":false,"is_playable":true,"name":"Rhiannon - 2002 Remaster","track_number":5,"type":"track","uri":"spotify:track:023whGJfx9QY3JDDCajKHW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/5YzOUVdLMrItgSP3lMxReH"},"href":"https://api.spotify.com/v1/albums/5YzOUVdLMrItgSP3lMxReH","id":"5YzOUVdLMrItgSP3lMxReH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27318c0cb6bcd7bfecee189242f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0218c0cb6bcd7bfecee189242f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485118c0cb6bcd7bfecee189242f"}],"is_playable":true,"name":"Greatest Hits (Deluxe Edition)","release_date":"1988-11-22","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:5YzOUVdLMrItgSP3lMxReH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":250253,"explicit":false,"external_ids":{"isrc":"USWB22600008"},"external_urls":{"spotify":"https://open.spotify.com/track/2A4zRDiC1Z0QEpz8WA7kk7"},"href":"https://api.spotify.com/v1/tracks/2A4zRDiC1Z0QEpz8WA7kk7","id":"2A4zRDiC1Z0QEpz8WA7kk7","is_local":false,"is_playable":true,"name":"Rhiannon","track_number":1,"type":"track","uri":"spotify:track:2A4zRDiC1Z0QEpz8WA7kk7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/6jTUmLtY779ZNYsyugOq2q"},"href":"https://api.spotify.com/v1/albums/6jTUmLtY779ZNYsyugOq2q","id":"6jTUmLtY779ZNYsyugOq2q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273152f87dab60dcbd929169daa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02152f87dab60dcbd929169daa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851152f87dab60dcbd929169daa"}],"is_playable":true,"name":"Fleetwood Mac (2017 Remaster)","release_date":"1975-07-11","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6jTUmLtY779ZNYsyugOq2q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":250360,"explicit":false,"external_ids":{"isrc":"USRH11700074"},"external_urls":{"spotify":"https://open.spotify.com/track/3kZUnG3jVpgwh3TQFdTv18"},"href":"https://api.spotify.com/v1/tracks/3kZUnG3jVpgwh3TQFdTv18","id":"3kZUnG3jVpgwh3TQFdTv18","is_local":false,"is_playable":true,"name":"Rhiannon - 2017 Remaster","track_number":4,"type":"track","uri":"spotify:track:3kZUnG3jVpgwh3TQFdTv18"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OQxaj2MqTb9nEtoTPfN4P"},"href":"https://api.spotify.com/v1/albums/0OQxaj2MqTb9nEtoTPfN4P","id":"0OQxaj2MqTb9nEtoTPfN4P","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346c433f89c341ad1f3b9fcae"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246c433f89c341ad1f3b9fcae"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146c433f89c341ad1f3b9fcae"}],"is_playable":true,"name":"Fleetwood Mac (Deluxe Edition)","release_date":"1975-07-11","release_date_precision":"day","total_tracks":46,"type":"album","uri":"spotify:album:0OQxaj2MqTb9nEtoTPfN4P"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":250360,"explicit":false,"external_ids":{"isrc":"USRH11700074"},"external_urls":{"spotify":"https://open.spotify.com/track/37jorMjJhyf20GU3blbbPh"},"href":"https://api.spotify.com/v1/tracks/37jorMjJhyf20GU3blbbPh","id":"37jorMjJhyf20GU3blbbPh","is_local":false,"is_playable":true,"name":"Rhiannon - 2017 Remaster","track_number":4,"type":"track","uri":"spotify:track:37jorMjJhyf20GU3blbbPh"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJoaWFubm9uJTIyJTIwYXJ0aXN0JTNBJTIyRmxlZXR3b29kJTIwTWFjJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo3LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVZJUTNWYUFvUktPRXBKMGZld2R2byJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVWSVEzVmFBb1JLT0VwSjBmZXdkdm8iLCJpZCI6IjVWSVEzVmFBb1JLT0VwSjBmZXdkdm8iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5j", + "by9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNGZiMDQzMTk1ZThkMDdlNzJlZGM3MjI2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjRmYjA0MzE5NWU4ZDA3ZTcyZWRjNzIyNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNGZiMDQzMTk1ZThkMDdlNzJlZGM3MjI2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJyZWxlYXNlX2RhdGUiOiIxOTc1LTA3LTExIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVZJUTNWYUFvUktPRXBKMGZld2R2byJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjUyNzczLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNXQjE5OTAwMTg4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wNW9FVHpXYmQ0U0kzM3FLMmdiSmZSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDVvRVR6V2JkNFNJMzNxSzJnYkpmUiIsImlkIjoiMDVvRVR6V2JkNFNJMzNxSzJnYkpmUiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaGlhbm5vbiIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowNW9FVHpXYmQ0U0kzM3FLMmdiSmZSIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6Ig==", + "YXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBMZk0zUEdrWEU2S3ZKRUUxSGtPbnoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wTGZNM1BHa1hFNkt2SkVFMUhrT256IiwiaWQiOiIwTGZNM1BHa1hFNkt2SkVFMUhrT256IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ViODMyZWZlMDYxODg4ZWU3ZWYxMDQ1NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlYjgzMmVmZTA2MTg4OGVlN2VmMTA0NTYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWViODMyZWZlMDYxODg4ZWU3ZWYxMDQ1NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHcmVhdGVzdCBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMTk4OC0xMS0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBMZk0zUEdrWEU2S3ZKRUUxSGtPbnoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1Mjc3MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTV0IxOTkwMDE4OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVRXUGZrZU4wN2FFUk8wWW4yRDJ0MiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVUV1Bma2VOMDdhRVJPMFluMkQydDIiLCJpZCI6IjVUV1Bma2VOMDdhRVJPMFluMkQydDIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmhpYW5ub24iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZg==", + "eTp0cmFjazo1VFdQZmtlTjA3YUVSTzBZbjJEMnQyIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wT1F4YWoyTXFUYjluRXRvVFBmTjRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvME9ReGFqMk1xVGI5bkV0b1RQZk40UCIsImlkIjoiME9ReGFqMk1xVGI5bkV0b1RQZk40UCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0NmM0MzNmODljMzQxYWQxZjNiOWZjYWUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDZjNDMzZjg5YzM0MWFkMWYzYjlmY2FlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0NmM0MzNmODljMzQxYWQxZjNiOWZjYWUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmxlZXR3b29kIE1hYyAoRGVsdXhlIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMTk3NS0wNy0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBPUXhhajJNcVRiOW5FdG9UUGZONFAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyODMyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZA==", + "cyI6eyJpc3JjIjoiVVNSSDExNzAwMDgzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wczZFOEx4VU5lUmptOXJYRWg5ZTl3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMHM2RThMeFVOZVJqbTlyWEVoOWU5dyIsImlkIjoiMHM2RThMeFVOZVJqbTlyWEVoOWU5dyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaGlhbm5vbiAoV2lsbCBZb3UgRXZlciBXaW4pIC0gU2luZ2xlOyAyMDE3IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowczZFOEx4VU5lUmptOXJYRWg5ZTl3In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83QTBkZWZOWUNsemZRSFY4aWZPQnYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0EwZGVmTllDbHpmUUhWOGlmT0J2MCIsImlkIjoiN0EwZGVmTllDbHpmUUhWOGlmT0J2MCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1M2RkMmQyMjY0ODg1ZTE2YjMzMTU1MTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTNkZDJkMjI2NDg4NWUxNmIzMzE1NTE2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1M2RkMmQyMjY0ODg1ZTE2YjMzMTU1MTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIFZlcnkgQmVzdCBPZiBGbGVldHdvb2QgTWFjIiwicmVsZWFzZV9kYXRlIjoiMjAwMi0xMC0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdBMGRlZk5ZQ2x6ZlFIVg==", + "OGlmT0J2MCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI2NjY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNXQjEwMjAyNjA2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wMjN3aEdKZng5UVkzSkREQ2FqS0hXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDIzd2hHSmZ4OVFZM0pERENhaktIVyIsImlkIjoiMDIzd2hHSmZ4OVFZM0pERENhaktIVyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaGlhbm5vbiAtIDIwMDIgUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MDIzd2hHSmZ4OVFZM0pERENhaktIVyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVl6T1VWZExNckl0Z1NQM2xNeFJlSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVZek9VVmRMTXJJdGdTUDNsTXhSZUgiLCJpZCI6IjVZek9VVmRMTXJJdGdTUDNsTXhSZUgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMThjMGNiNmJjZDdiZmVjZWUxODkyNDJmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYQ==", + "YjY3NjE2ZDAwMDAxZTAyMThjMGNiNmJjZDdiZmVjZWUxODkyNDJmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExOGMwY2I2YmNkN2JmZWNlZTE4OTI0MmYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3JlYXRlc3QgSGl0cyAoRGVsdXhlIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMTk4OC0xMS0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVZek9VVmRMTXJJdGdTUDNsTXhSZUgifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1MDI1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTV0IyMjYwMDAwOCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMkE0elJEaUMxWjBRRXB6OFdBN2trNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJBNHpSRGlDMVowUUVwejhXQTdrazciLCJpZCI6IjJBNHpSRGlDMVowUUVwejhXQTdrazciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmhpYW5ub24iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MkE0elJEaUMxWjBRRXB6OFdBN2trNyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4ucw==", + "cG90aWZ5LmNvbS9hbGJ1bS82alRVbUx0WTc3OVpOWXN5dWdPcTJxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNmpUVW1MdFk3NzlaTllzeXVnT3EycSIsImlkIjoiNmpUVW1MdFk3NzlaTllzeXVnT3EycSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNTJmODdkYWI2MGRjYmQ5MjkxNjlkYWEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTUyZjg3ZGFiNjBkY2JkOTI5MTY5ZGFhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExNTJmODdkYWI2MGRjYmQ5MjkxNjlkYWEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmxlZXR3b29kIE1hYyAoMjAxNyBSZW1hc3RlcikiLCJyZWxlYXNlX2RhdGUiOiIxOTc1LTA3LTExIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NmpUVW1MdFk3NzlaTllzeXVnT3EycSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjUwMzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDExNzAwMDc0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8za1pVbkczalZwZ3doM1RRRmRUdjE4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM2taVW5HM2pWcGd3aDNUUUZkVHYxOCIsImlkIjoiM2taVW5HM2pWcGd3aDNUUUZkVHYxOCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaGlhbm5vbiAtIDIwMTcgUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2taVW5HM2pWcGd3aDNUUUZkVHYxOCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYQ==", + "cnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wT1F4YWoyTXFUYjluRXRvVFBmTjRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvME9ReGFqMk1xVGI5bkV0b1RQZk40UCIsImlkIjoiME9ReGFqMk1xVGI5bkV0b1RQZk40UCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0NmM0MzNmODljMzQxYWQxZjNiOWZjYWUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDZjNDMzZjg5YzM0MWFkMWYzYjlmY2FlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0NmM0MzNmODljMzQxYWQxZjNiOWZjYWUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmxlZXR3b29kIE1hYyAoRGVsdXhlIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMTk3NS0wNy0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBPUXhhajJNcVRiOW5FdG9UUGZONFAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1MDM2MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMTcwMDA3NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZQ==", + "bi5zcG90aWZ5LmNvbS90cmFjay8zN2pvck1qSmh5ZjIwR1UzYmxiYlBoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzdqb3JNakpoeWYyMEdVM2JsYmJQaCIsImlkIjoiMzdqb3JNakpoeWYyMEdVM2JsYmJQaCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSaGlhbm5vbiAtIDIwMTcgUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mzdqb3JNakpoeWYyMEdVM2JsYmJQaCJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Rhiannon%22+artist%3A%22Fleetwood+Mac%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Redbone%22%20artist%3A%22Childish%20Gambino%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"external_urls":{"spotify":"https://open.spotify.com/album/4JCybsNZUXWrK2Jpyn12Ni"},"href":"https://api.spotify.com/v1/albums/4JCybsNZUXWrK2Jpyn12Ni","id":"4JCybsNZUXWrK2Jpyn12Ni","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c29562d6e8c1f55bb1311d5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c29562d6e8c1f55bb1311d5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c29562d6e8c1f55bb1311d5"}],"is_playable":true,"name":"\"Awaken, My Love!\"","release_date":"2016-12-02","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4JCybsNZUXWrK2Jpyn12Ni"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326933,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/3vQ4T78TTMOjQXGfXVKQJo"},"href":"https://api.spotify.com/v1/tracks/3vQ4T78TTMOjQXGfXVKQJo","id":"3vQ4T78TTMOjQXGfXVKQJo","is_local":false,"is_playable":true,"name":"Redbone","track_number":6,"type":"track","uri":"spotify:track:3vQ4T78TTMOjQXGfXVKQJo"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4zudhmy5HSHVZ1y3gPfbAB"},"href":"https://api.spotify.com/v1/albums/4zudhmy5HSHVZ1y3gPfbAB","id":"4zudhmy5HSHVZ1y3gPfbAB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27372c666e8feebbb65253e4fba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0272c666e8feebbb65253e4fba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485172c666e8feebbb65253e4fba"}],"is_playable":true,"name":"Catch Feels","release_date":"2017-08-25","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:4zudhmy5HSHVZ1y3gPfbAB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":325272,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/1DFKBDsyc5eZKp7rhzMeNL"},"href":"https://api.spotify.com/v1/tracks/1DFKBDsyc5eZKp7rhzMeNL","id":"1DFKBDsyc5eZKp7rhzMeNL","is_local":false,"is_playable":true,"name":"Redbone","track_number":4,"type":"track","uri":"spotify:track:1DFKBDsyc5eZKp7rhzMeNL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7039WzytxariZTo4tsLUQF"},"href":"https://api.spotify.com/v1/albums/7039WzytxariZTo4tsLUQF","id":"7039WzytxariZTo4tsLUQF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27352bc5b49e2100091d225f95d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0252bc5b49e2100091d225f95d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485152bc5b49e2100091d225f95d"}],"is_playable":true,"name":"Nova Tunes 3.5","release_date":"2017-03-17","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:7039WzytxariZTo4tsLUQF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":324226,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/3aXo6nJjexSdb6wCpN7Ysy"},"href":"https://api.spotify.com/v1/tracks/3aXo6nJjexSdb6wCpN7Ysy","id":"3aXo6nJjexSdb6wCpN7Ysy","is_local":false,"is_playable":true,"name":"Redbone","track_number":8,"type":"track","uri":"spotify:track:3aXo6nJjexSdb6wCpN7Ysy"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/37vQAfEaacxeV4MGN31e9D"},"href":"https://api.spotify.com/v1/albums/37vQAfEaacxeV4MGN31e9D","id":"37vQAfEaacxeV4MGN31e9D","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b230fc4671b83d89951dd23f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b230fc4671b83d89951dd23f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b230fc4671b83d89951dd23f"}],"is_playable":true,"name":"R&Bae","release_date":"2017-07-07","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:37vQAfEaacxeV4MGN31e9D"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":325960,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/41OPM65MGwtCT0D4iAJ6qP"},"href":"https://api.spotify.com/v1/tracks/41OPM65MGwtCT0D4iAJ6qP","id":"41OPM65MGwtCT0D4iAJ6qP","is_local":false,"is_playable":true,"name":"Redbone","track_number":1,"type":"track","uri":"spotify:track:41OPM65MGwtCT0D4iAJ6qP"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5TszsWpms1lnB7c6EJ4Ux2"},"href":"https://api.spotify.com/v1/albums/5TszsWpms1lnB7c6EJ4Ux2","id":"5TszsWpms1lnB7c6EJ4Ux2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c05d415d1a371eadd2c4023"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c05d415d1a371eadd2c4023"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c05d415d1a371eadd2c4023"}],"is_playable":true,"name":"Hip Hop Love Songs","release_date":"2017-11-17","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:5TszsWpms1lnB7c6EJ4Ux2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326933,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/6u29Or89nZ784Mhgp1cuz4"},"href":"https://api.spotify.com/v1/tracks/6u29Or89nZ784Mhgp1cuz4","id":"6u29Or89nZ784Mhgp1cuz4","is_local":false,"is_playable":true,"name":"Redbone","track_number":2,"type":"track","uri":"spotify:track:6u29Or89nZ784Mhgp1cuz4"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/770DSqP3I7AwvIcd5pI6Od"},"href":"https://api.spotify.com/v1/albums/770DSqP3I7AwvIcd5pI6Od","id":"770DSqP3I7AwvIcd5pI6Od","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e4938ab9d8b5d085a3c0dfab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e4938ab9d8b5d085a3c0dfab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e4938ab9d8b5d085a3c0dfab"}],"is_playable":true,"name":"21st Century Funk","release_date":"2017-08-11","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:770DSqP3I7AwvIcd5pI6Od"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326229,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/3Bo79uipvzIBiOAG4zJPcm"},"href":"https://api.spotify.com/v1/tracks/3Bo79uipvzIBiOAG4zJPcm","id":"3Bo79uipvzIBiOAG4zJPcm","is_local":false,"is_playable":true,"name":"Redbone","track_number":3,"type":"track","uri":"spotify:track:3Bo79uipvzIBiOAG4zJPcm"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/197YY02cK93Yjrtpa1FrMY"},"href":"https://api.spotify.com/v1/albums/197YY02cK93Yjrtpa1FrMY","id":"197YY02cK93Yjrtpa1FrMY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735b11ac9a6b727e6e367a4dcd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025b11ac9a6b727e6e367a4dcd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515b11ac9a6b727e6e367a4dcd"}],"is_playable":true,"name":"Best Of 2017","release_date":"2017-12-08","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:197YY02cK93Yjrtpa1FrMY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326933,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/1QQIwEMJ5ftWNWapBfNbt7"},"href":"https://api.spotify.com/v1/tracks/1QQIwEMJ5ftWNWapBfNbt7","id":"1QQIwEMJ5ftWNWapBfNbt7","is_local":false,"is_playable":true,"name":"Redbone","track_number":15,"type":"track","uri":"spotify:track:1QQIwEMJ5ftWNWapBfNbt7"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/12JrzzPK17E7V4kArOJJ32"},"href":"https://api.spotify.com/v1/albums/12JrzzPK17E7V4kArOJJ32","id":"12JrzzPK17E7V4kArOJJ32","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a2cc66882283cfb2cb576a19"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a2cc66882283cfb2cb576a19"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a2cc66882283cfb2cb576a19"}],"is_playable":true,"name":"Best Of 2017 Pop","release_date":"2017-12-15","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:12JrzzPK17E7V4kArOJJ32"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/73sIBHcqh3Z3NyqHKZ7FOL"},"href":"https://api.spotify.com/v1/artists/73sIBHcqh3Z3NyqHKZ7FOL","id":"73sIBHcqh3Z3NyqHKZ7FOL","name":"Childish Gambino","type":"artist","uri":"spotify:artist:73sIBHcqh3Z3NyqHKZ7FOL"}],"disc_number":1,"duration_ms":326880,"explicit":true,"external_ids":{"isrc":"USYAH1600107"},"external_urls":{"spotify":"https://open.spotify.com/track/6wGbDxvg8wLWnk1HxcFTTO"},"href":"https://api.spotify.com/v1/tracks/6wGbDxvg8wLWnk1HxcFTTO","id":"6wGbDxvg8wLWnk1HxcFTTO","is_local":false,"is_playable":true,"name":"Redbone","track_number":7,"type":"track","uri":"spotify:track:6wGbDxvg8wLWnk1HxcFTTO"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJlZGJvbmUlMjIlMjBhcnRpc3QlM0ElMjJDaGlsZGlzaCUyMEdhbWJpbm8lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80SkN5YnNOWlVYV3JLMkpweW4xMk5pIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNEpDeWJzTlpVWFdySzJKcHluMTJOaSIsImlkIjoiNEpDeWJzTlpVWFdySzJKcHluMTJOaSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5z", + "Y2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYzI5NTYyZDZlOGMxZjU1YmIxMzExZDUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWMyOTU2MmQ2ZThjMWY1NWJiMTMxMWQ1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYzI5NTYyZDZlOGMxZjU1YmIxMzExZDUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiXCJBd2FrZW4sIE15IExvdmUhXCIiLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTEyLTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NEpDeWJzTlpVWFdySzJKcHluMTJOaSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojczc0lCSGNxaDNaM055cUhLWjdGT0wifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzI2OTMzLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1lBSDE2MDAxMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzN2UTRUNzhUVE1PalFYR2ZYVktRSm8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zdlE0VDc4VFRNT2pRWEdmWFZLUUpvIiwiaWQiOiIzdlE0VDc4VFRNT2pRWEdmWFZLUUpvIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlZGJvbmUiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M3ZRNFQ3OFRUTU9qUVhHZlhWS1FKbyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcg==", + "dGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzR6dWRobXk1SFNIVloxeTNnUGZiQUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80enVkaG15NUhTSFZaMXkzZ1BmYkFCIiwiaWQiOiI0enVkaG15NUhTSFZaMXkzZ1BmYkFCIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzcyYzY2NmU4ZmVlYmJiNjUyNTNlNGZiYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3MmM2NjZlOGZlZWJiYjY1MjUzZTRmYmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTcyYzY2NmU4ZmVlYmJiNjUyNTNlNGZiYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYXRjaCBGZWVscyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDgtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0enVkaG15NUhTSFZaMXkzZ1BmYkFCIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjUyNzIsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMURGS0JEc3ljNWVaS3A3cmh6TWVOTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFERktCRHN5YzVlWktwN3Joek1lTkwiLCJpZCI6IjFERktCRHN5YzVlWktwN3Joek1lTkwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIg==", + "LCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFERktCRHN5YzVlWktwN3Joek1lTkwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzAzOVd6eXR4YXJpWlRvNHRzTFVRRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzcwMzlXenl0eGFyaVpUbzR0c0xVUUYiLCJpZCI6IjcwMzlXenl0eGFyaVpUbzR0c0xVUUYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTJiYzViNDllMjEwMDA5MWQyMjVmOTVkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUyYmM1YjQ5ZTIxMDAwOTFkMjI1Zjk1ZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTJiYzViNDllMjEwMDA5MWQyMjVmOTVkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vdmEgVHVuZXMgMy41IiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wMy0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjcwMzlXenl0eGFyaVpUbzR0c0xVUUYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNDIyNiwiZXhwbGljaXQiOnRydWUsImV4dA==", + "ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1lBSDE2MDAxMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNhWG82bkpqZXhTZGI2d0NwTjdZc3kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zYVhvNm5KamV4U2RiNndDcE43WXN5IiwiaWQiOiIzYVhvNm5KamV4U2RiNndDcE43WXN5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlZGJvbmUiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2FYbzZuSmpleFNkYjZ3Q3BON1lzeSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zN3ZRQWZFYWFjeGVWNE1HTjMxZTlEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMzd2UUFmRWFhY3hlVjRNR04zMWU5RCIsImlkIjoiMzd2UUFmRWFhY3hlVjRNR04zMWU5RCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiMjMwZmM0NjcxYjgzZDg5OTUxZGQyM2YifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjIzMGZjNDY3MWI4M2Q4OTk1MWRkMjNmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiMjMwZmM0NjcxYjgzZDg5OTUxZGQyM2YifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUiZCYWUiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA3LTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Mzd2UUFmRWFhY3hlVjRNR04zMWU5RCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZQ==", + "bi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjU5NjAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDFPUE02NU1Hd3RDVDBENGlBSjZxUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQxT1BNNjVNR3d0Q1QwRDRpQUo2cVAiLCJpZCI6IjQxT1BNNjVNR3d0Q1QwRDRpQUo2cVAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0MU9QTTY1TUd3dENUMEQ0aUFKNnFQIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVUc3pzV3BtczFsbkI3YzZFSjRVeDIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81VHN6c1dwbXMxbG5CN2M2RUo0VXgyIiwiaWQiOiI1VHN6c1dwbXMxbG5CN2M2RUo0VXgyIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZjMDVkNDE1ZDFhMzcxZWFkZDJjNDAyMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2YzA1ZDQxNWQxYTM3MWVhZGQyYzQwMjMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaA==", + "dHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmMwNWQ0MTVkMWEzNzFlYWRkMmM0MDIzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhpcCBIb3AgTG92ZSBTb25ncyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMTEtMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1VHN6c1dwbXMxbG5CN2M2RUo0VXgyIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwiaWQiOiI3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIiwibmFtZSI6IkNoaWxkaXNoIEdhbWJpbm8iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjY5MzMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnUyOU9yODluWjc4NE1oZ3AxY3V6NCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ1MjlPcjg5blo3ODRNaGdwMWN1ejQiLCJpZCI6IjZ1MjlPcjg5blo3ODRNaGdwMWN1ejQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2dTI5T3I4OW5aNzg0TWhncDFjdXo0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxLw==", + "YWxidW1zLzc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QiLCJpZCI6Ijc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZTQ5MzhhYjlkOGI1ZDA4NWEzYzBkZmFiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmU0OTM4YWI5ZDhiNWQwODVhM2MwZGZhYiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZTQ5MzhhYjlkOGI1ZDA4NWEzYzBkZmFiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjIxc3QgQ2VudHVyeSBGdW5rIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wOC0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc3MERTcVAzSTdBd3ZJY2Q1cEk2T2QifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNjIyOSwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNZQUgxNjAwMTA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zQm83OXVpcHZ6SUJpT0FHNHpKUGNtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0JvNzl1aXB2eklCaU9BRzR6SlBjbSIsImlkIjoiM0JvNzl1aXB2eklCaU9BRzR6SlBjbSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWRib25lIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNCbzc5dWlwdnpJQmlPQUc0ekpQY20ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocg==", + "ZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xOTdZWTAyY0s5M1lqcnRwYTFGck1ZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTk3WVkwMmNLOTNZanJ0cGExRnJNWSIsImlkIjoiMTk3WVkwMmNLOTNZanJ0cGExRnJNWSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1YjExYWM5YTZiNzI3ZTZlMzY3YTRkY2QifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWIxMWFjOWE2YjcyN2U2ZTM2N2E0ZGNkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1YjExYWM5YTZiNzI3ZTZlMzY3YTRkY2QifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmVzdCBPZiAyMDE3IiwicmVsZWFzZV9kYXRlIjoiMjAxNy0xMi0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjE5N1lZMDJjSzkzWWpydHBhMUZyTVkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJpZCI6Ijczc0lCSGNxaDNaM055cUhLWjdGT0wiLCJuYW1lIjoiQ2hpbGRpc2ggR2FtYmlubyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3M3NJQkhjcWgzWjNOeXFIS1o3Rk9MIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyNjkzMywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNZQUgxNjAwMTA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xUVFJd0VNSjVmdFdOV2FwQmZOYnQ3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVFRSXdFTUo1ZnRXTldhcEJmTmJ0NyIsIg==", + "aWQiOiIxUVFJd0VNSjVmdFdOV2FwQmZOYnQ3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlZGJvbmUiLCJ0cmFja19udW1iZXIiOjE1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFRUUl3RU1KNWZ0V05XYXBCZk5idDcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMTJKcnp6UEsxN0U3VjRrQXJPSkozMiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzEySnJ6elBLMTdFN1Y0a0FyT0pKMzIiLCJpZCI6IjEySnJ6elBLMTdFN1Y0a0FyT0pKMzIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYTJjYzY2ODgyMjgzY2ZiMmNiNTc2YTE5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEyY2M2Njg4MjI4M2NmYjJjYjU3NmExOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTJjYzY2ODgyMjgzY2ZiMmNiNTc2YTE5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlc3QgT2YgMjAxNyBQb3AiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTEyLTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MTJKcnp6UEsxN0U3VjRrQXJPSkozMiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzczc0lCSGNxaDNaM055cUhLWjdGT0wifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsImlkIjoiNzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCIsIm5hbWUiOiJDaGlsZGlzaCBHYW1iaW5vIiwidHlwZQ==", + "IjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzNzSUJIY3FoM1ozTnlxSEtaN0ZPTCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjY4ODAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTWUFIMTYwMDEwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNndHYkR4dmc4d0xXbmsxSHhjRlRUTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ3R2JEeHZnOHdMV25rMUh4Y0ZUVE8iLCJpZCI6IjZ3R2JEeHZnOHdMV25rMUh4Y0ZUVE8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVkYm9uZSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2d0diRHh2Zzh3TFduazFIeGNGVFRPIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Redbone%22+artist%3A%22Childish+Gambino%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNraW5ueSUyMExvdmUlMjIlMjBhcnRpc3QlM0ElMjJCb24lMjBJdmVyJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80TEVpVW0xU1JiRk1nZnFuUVR3VWJRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJpZCI6IjRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJuYW1lIjoiQm9uIEl2ZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExFaVVtMVNSYkZNZ2ZxblFUd1ViUSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdFSjBPVDVacXliWHhjWVJhNm1jY00ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83RUowT1Q1WnF5Ylh4Y1lSYTZtY2NNIiwiaWQiOiI3RUowT1Q1WnF5Ylh4Y1lSYTZtY2NNIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZw==", + "ZS9hYjY3NjE2ZDAwMDBiMjczYmY3YzMxN2E2M2M0ZjEyOGI4ODIzNDA2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJmN2MzMTdhNjNjNGYxMjhiODgyMzQwNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYmY3YzMxN2E2M2M0ZjEyOGI4ODIzNDA2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZvciBFbW1hLCBGb3JldmVyIEFnbyIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMDItMTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdFSjBPVDVacXliWHhjWVJhNm1jY00ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80TEVpVW0xU1JiRk1nZnFuUVR3VWJRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJpZCI6IjRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJuYW1lIjoiQm9uIEl2ZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExFaVVtMVNSYkZNZ2ZxblFUd1ViUSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzg1MjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVUzM4WTA4MTE1MDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNCM2VPZ0xKU3FQRUEwUmZib0lRVk0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zQjNlT2dMSlNxUEVBMFJmYm9JUVZNIiwiaWQiOiIzQjNlT2dMSlNxUEVBMFJmYm9JUVZNIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNraW5ueSBMb3ZlIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNCM2VPZ0xKU3FQRUEwUmZib0lRVk0ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOg==", + "ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80djdlRDh6UDZqU2tBYlVBcjJMdVgxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHY3ZUQ4elA2alNrQWJVQXIyTHVYMSIsImlkIjoiNHY3ZUQ4elA2alNrQWJVQXIyTHVYMSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwYjliMzUzY2ExMjYyYjA1YzJkNGY2YmMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGI5YjM1M2NhMTI2MmIwNWMyZDRmNmJjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwYjliMzUzY2ExMjYyYjA1YzJkNGY2YmMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRm9sayBZb3UhIiwicmVsZWFzZV9kYXRlIjoiMjAxMy0wMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjR2N2VEOHpQNmpTa0FiVUFyMkx1WDEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80TEVpVW0xU1JiRk1nZnFuUVR3VWJRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJpZCI6IjRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJuYW1lIjoiQm9uIEl2ZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExFaVVtMVNSYkZNZ2ZxblFUd1ViUSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzIyMTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVUzM4WTA4MTE1MDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJhdk53QlhpS0R6bGVqYkRkQ0o5b0QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yYXZOd0JYaUtEemxlamJEZENKOW9EIiwiaWQiOiIyYXZOd0JYaUtEemxlamJEZENKOW9EIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNraW5ueSBMb3ZlIiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cg==", + "YWNrOjJhdk53QlhpS0R6bGVqYkRkQ0o5b0QifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Skinny+Love%22+artist%3A%22Bon+Iver%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNhc2lvJTIyJTIwYXJ0aXN0JTNBJTIySnVuZ2xlJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81OW9BNVdiYlF2b21KejJCdVJHMDcxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU5b0E1V2JiUXZvbUp6MkJ1UkcwNzEiLCJpZCI6IjU5b0E1V2JiUXZvbUp6MkJ1UkcwNzEiLCJuYW1lIjoiSnVuZ2xlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU5b0E1V2JiUXZvbUp6MkJ1UkcwNzEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81Z1lDWmdtWHp6V1h4T0NiOWZNZkJtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNWdZQ1pnbVh6eldYeE9DYjlmTWZCbSIsImlkIjoiNWdZQ1pnbVh6eldYeE9DYjlmTWZCbSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMA==", + "YjI3MzAxMGI4MGQ2Njc1YWY3YzljNjBjNGQ5OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwMTBiODBkNjY3NWFmN2M5YzYwYzRkOTgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTAxMGI4MGQ2Njc1YWY3YzljNjBjNGQ5OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGb3IgRXZlciIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDktMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1Z1lDWmdtWHp6V1h4T0NiOWZNZkJtIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTlvQTVXYmJRdm9tSnoyQnVSRzA3MSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81OW9BNVdiYlF2b21KejJCdVJHMDcxIiwiaWQiOiI1OW9BNVdiYlF2b21KejJCdVJHMDcxIiwibmFtZSI6Ikp1bmdsZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1OW9BNVdiYlF2b21KejJCdVJHMDcxIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNDM2OSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQktTMTgwMDEwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDRaS25mV0VrcDd3UHMwMzVqNFR1YSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQ0WktuZldFa3A3d1BzMDM1ajRUdWEiLCJpZCI6IjQ0WktuZldFa3A3d1BzMDM1ajRUdWEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2FzaW8iLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NDRaS25mV0VrcDd3UHMwMzVqNFR1YSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZ1ZDNjh4Rm9nQ1hTNUFlU0JuTFNQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNnVkM2OHhGb2dDWFM1QWVTQm5MU1AiLCJpZCI6IjNnVkM2OHhGb2dDWFM1QWVTQm5MU1AiLCJuYW1lIjoiUmV0cm8gSnVuZ2xlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNnVkM2OHhGb2dDWA==", + "UzVBZVNCbkxTUCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRURlp3djFEOG9aVjA0T0FNQmV3S2MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80VEZad3YxRDhvWlYwNE9BTUJld0tjIiwiaWQiOiI0VEZad3YxRDhvWlYwNE9BTUJld0tjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2M3MGVjNjY5ZTQ0Zjc1M2Y5ZjA2NzY5MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjNzBlYzY2OWU0NGY3NTNmOWYwNjc2OTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWM3MGVjNjY5ZTQ0Zjc1M2Y5ZjA2NzY5MSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW1tZXIgVmliZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA3LTE3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFRGWnd2MUQ4b1pWMDRPQU1CZXdLYyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNnVkM2OHhGb2dDWFM1QWVTQm5MU1AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2dWQzY4eEZvZ0NYUzVBZVNCbkxTUCIsImlkIjoiM2dWQzY4eEZvZ0NYUzVBZVNCbkxTUCIsIm5hbWUiOiJSZXRybyBKdW5nbGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2dWQzY4eEZvZ0NYUzVBZVNCbkxTUCJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zbDJ4c1E2OWFqbThyN0taRVJqcDZ4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNsMnhzUTY5YWptOHI3S1pFUmpwNngiLCJpZCI6IjNsMnhzUTY5YWptOHI3S1pFUmpwNngiLCJuYW1lIjoiRmxhbmRycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozbDJ4c1E2OWFqbThyN0taRVJqcDZ4In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEzODAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkNINjU0MTk0MTI5NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNA==", + "RHFla3ZHUVcyekhOTVZoMGdNM3FwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNERxZWt2R1FXMnpITk1WaDBnTTNxcCIsImlkIjoiNERxZWt2R1FXMnpITk1WaDBnTTNxcCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDYXNpbyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0RHFla3ZHUVcyekhOTVZoMGdNM3FwIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Casio%22+artist%3A%22Jungle%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJhaW55JTIwRGF5cyUyMiUyMGFydGlzdCUzQSUyMk1heWVyJTIwSGF3dGhvcm5lJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJhaW55JTIwRGF5cyUyMiUyMGFydGlzdCUzQSUyMk1heWVyJTIwSGF3dGhvcm5lJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Rainy+Days%22+artist%3A%22Mayer+Hawthorne%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Motion%20Sickness%22%20artist%3A%22Phoebe%20Bridgers%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1r1uxoy19fzMxunt3ONAkG"},"href":"https://api.spotify.com/v1/artists/1r1uxoy19fzMxunt3ONAkG","id":"1r1uxoy19fzMxunt3ONAkG","name":"Phoebe Bridgers","type":"artist","uri":"spotify:artist:1r1uxoy19fzMxunt3ONAkG"}],"external_urls":{"spotify":"https://open.spotify.com/album/5rcJ5xCMYYLCgGilFDKRZl"},"href":"https://api.spotify.com/v1/albums/5rcJ5xCMYYLCgGilFDKRZl","id":"5rcJ5xCMYYLCgGilFDKRZl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27308afb5dc296054856909f8fd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0208afb5dc296054856909f8fd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485108afb5dc296054856909f8fd"}],"is_playable":true,"name":"Stranger in the Alps (Deluxe Edition)","release_date":"2018-10-02","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:5rcJ5xCMYYLCgGilFDKRZl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1r1uxoy19fzMxunt3ONAkG"},"href":"https://api.spotify.com/v1/artists/1r1uxoy19fzMxunt3ONAkG","id":"1r1uxoy19fzMxunt3ONAkG","name":"Phoebe Bridgers","type":"artist","uri":"spotify:artist:1r1uxoy19fzMxunt3ONAkG"}],"disc_number":1,"duration_ms":229760,"explicit":false,"external_ids":{"isrc":"USJ5G1714202"},"external_urls":{"spotify":"https://open.spotify.com/track/25Syi9wnfn6ZGAmiOBypPq"},"href":"https://api.spotify.com/v1/tracks/25Syi9wnfn6ZGAmiOBypPq","id":"25Syi9wnfn6ZGAmiOBypPq","is_local":false,"is_playable":true,"name":"Motion Sickness","track_number":2,"type":"track","uri":"spotify:track:25Syi9wnfn6ZGAmiOBypPq"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1r1uxoy19fzMxunt3ONAkG"},"href":"https://api.spotify.com/v1/artists/1r1uxoy19fzMxunt3ONAkG","id":"1r1uxoy19fzMxunt3ONAkG","name":"Phoebe Bridgers","type":"artist","uri":"spotify:artist:1r1uxoy19fzMxunt3ONAkG"}],"external_urls":{"spotify":"https://open.spotify.com/album/0qWcLfCZ8wtcoOdX14oGNI"},"href":"https://api.spotify.com/v1/albums/0qWcLfCZ8wtcoOdX14oGNI","id":"0qWcLfCZ8wtcoOdX14oGNI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c26e4a2e4df94a55591c48f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c26e4a2e4df94a55591c48f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c26e4a2e4df94a55591c48f"}],"is_playable":true,"name":"Stranger in the Alps","release_date":"2017-09-22","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:0qWcLfCZ8wtcoOdX14oGNI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1r1uxoy19fzMxunt3ONAkG"},"href":"https://api.spotify.com/v1/artists/1r1uxoy19fzMxunt3ONAkG","id":"1r1uxoy19fzMxunt3ONAkG","name":"Phoebe Bridgers","type":"artist","uri":"spotify:artist:1r1uxoy19fzMxunt3ONAkG"}],"disc_number":1,"duration_ms":229760,"explicit":false,"external_ids":{"isrc":"USJ5G1714202"},"external_urls":{"spotify":"https://open.spotify.com/track/5xo8RrjJ9CVNrtRg2S3B1R"},"href":"https://api.spotify.com/v1/tracks/5xo8RrjJ9CVNrtRg2S3B1R","id":"5xo8RrjJ9CVNrtRg2S3B1R","is_local":false,"is_playable":true,"name":"Motion Sickness","track_number":2,"type":"track","uri":"spotify:track:5xo8RrjJ9CVNrtRg2S3B1R"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1r1uxoy19fzMxunt3ONAkG"},"href":"https://api.spotify.com/v1/artists/1r1uxoy19fzMxunt3ONAkG","id":"1r1uxoy19fzMxunt3ONAkG","name":"Phoebe Bridgers","type":"artist","uri":"spotify:artist:1r1uxoy19fzMxunt3ONAkG"}],"external_urls":{"spotify":"https://open.spotify.com/album/5rcJ5xCMYYLCgGilFDKRZl"},"href":"https://api.spotify.com/v1/albums/5rcJ5xCMYYLCgGilFDKRZl","id":"5rcJ5xCMYYLCgGilFDKRZl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27308afb5dc296054856909f8fd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0208afb5dc296054856909f8fd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485108afb5dc296054856909f8fd"}],"is_playable":true,"name":"Stranger in the Alps (Deluxe Edition)","release_date":"2018-10-02","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:5rcJ5xCMYYLCgGilFDKRZl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1r1uxoy19fzMxunt3ONAkG"},"href":"https://api.spotify.com/v1/artists/1r1uxoy19fzMxunt3ONAkG","id":"1r1uxoy19fzMxunt3ONAkG","name":"Phoebe Bridgers","type":"artist","uri":"spotify:artist:1r1uxoy19fzMxunt3ONAkG"}],"disc_number":1,"duration_ms":264452,"explicit":false,"external_ids":{"isrc":"USJ5G1714214"},"external_urls":{"spotify":"https://open.spotify.com/track/7xwyvVWewy01DhdgEt2WWq"},"href":"https://api.spotify.com/v1/tracks/7xwyvVWewy01DhdgEt2WWq","id":"7xwyvVWewy01DhdgEt2WWq","is_local":false,"is_playable":true,"name":"Motion Sickness (Demo - Bonus Track)","track_number":13,"type":"track","uri":"spotify:track:7xwyvVWewy01DhdgEt2WWq"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1r1uxoy19fzMxunt3ONAkG"},"href":"https://api.spotify.com/v1/artists/1r1uxoy19fzMxunt3ONAkG","id":"1r1uxoy19fzMxunt3ONAkG","name":"Phoebe Bridgers","type":"artist","uri":"spotify:artist:1r1uxoy19fzMxunt3ONAkG"}],"external_urls":{"spotify":"https://open.spotify.com/album/35SwvxbVW5F8uyRaOMvVTd"},"href":"https://api.spotify.com/v1/albums/35SwvxbVW5F8uyRaOMvVTd","id":"35SwvxbVW5F8uyRaOMvVTd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ee7ce70454911f4825a86cfa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ee7ce70454911f4825a86cfa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ee7ce70454911f4825a86cfa"}],"is_playable":true,"name":"Motion Sickness","release_date":"2017-07-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:35SwvxbVW5F8uyRaOMvVTd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1r1uxoy19fzMxunt3ONAkG"},"href":"https://api.spotify.com/v1/artists/1r1uxoy19fzMxunt3ONAkG","id":"1r1uxoy19fzMxunt3ONAkG","name":"Phoebe Bridgers","type":"artist","uri":"spotify:artist:1r1uxoy19fzMxunt3ONAkG"}],"disc_number":1,"duration_ms":229760,"explicit":false,"external_ids":{"isrc":"USJ5G1714202"},"external_urls":{"spotify":"https://open.spotify.com/track/6PQMS28DcGmPKubKVLJ9mr"},"href":"https://api.spotify.com/v1/tracks/6PQMS28DcGmPKubKVLJ9mr","id":"6PQMS28DcGmPKubKVLJ9mr","is_local":false,"is_playable":true,"name":"Motion Sickness","track_number":1,"type":"track","uri":"spotify:track:6PQMS28DcGmPKubKVLJ9mr"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk1vdGlvbiUyMFNpY2tuZXNzJTIyJTIwYXJ0aXN0JTNBJTIyUGhvZWJlJTIwQnJpZGdlcnMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsImlkIjoiMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsIm5hbWUiOiJQaG9lYmUgQnJpZGdlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVyY0o1eENNWVlMQ2dHaWxGREtSWmwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81cmNKNXhDTVlZTENnR2lsRkRLUlpsIiwiaWQiOiI1cmNKNXhDTVlZTENnR2lsRkRLUlpsIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cA==", + "czovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDhhZmI1ZGMyOTYwNTQ4NTY5MDlmOGZkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA4YWZiNWRjMjk2MDU0ODU2OTA5ZjhmZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDhhZmI1ZGMyOTYwNTQ4NTY5MDlmOGZkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0cmFuZ2VyIGluIHRoZSBBbHBzIChEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDE4LTEwLTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NXJjSjV4Q01ZWUxDZ0dpbEZES1JabCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsImlkIjoiMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsIm5hbWUiOiJQaG9lYmUgQnJpZGdlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjk3NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0o1RzE3MTQyMDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzI1U3lpOXduZm42WkdBbWlPQnlwUHEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yNVN5aTl3bmZuNlpHQW1pT0J5cFBxIiwiaWQiOiIyNVN5aTl3bmZuNlpHQW1pT0J5cFBxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1vdGlvbiBTaWNrbmVzcyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyNVN5aTl3bmZuNlpHQW1pT0J5cFBxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsImlkIjoiMXIxdXhveTE5ZnpNeHVudA==", + "M09OQWtHIiwibmFtZSI6IlBob2ViZSBCcmlkZ2VycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxcjF1eG95MTlmek14dW50M09OQWtHIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMHFXY0xmQ1o4d3Rjb09kWDE0b0dOSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBxV2NMZkNaOHd0Y29PZFgxNG9HTkkiLCJpZCI6IjBxV2NMZkNaOHd0Y29PZFgxNG9HTkkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmMyNmU0YTJlNGRmOTRhNTU1OTFjNDhmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZjMjZlNGEyZTRkZjk0YTU1NTkxYzQ4ZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmMyNmU0YTJlNGRmOTRhNTU1OTFjNDhmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0cmFuZ2VyIGluIHRoZSBBbHBzIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wOS0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBxV2NMZkNaOHd0Y29PZFgxNG9HTkkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xcjF1eG95MTlmek14dW50M09OQWtHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJpZCI6IjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJuYW1lIjoiUGhvZWJlIEJyaWRnZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI5NzYwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNKNUcxNzE0MjAyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81eG84UnJqSjlDVk5ydFJnMlMzQjFSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNXhvOFJyako5Q1ZOcnRSZzJTM0IxUiIsImlkIjoiNXhvOFJyako5Q1ZOcnRSZzJTM0IxUiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb3Rpbw==", + "biBTaWNrbmVzcyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1eG84UnJqSjlDVk5ydFJnMlMzQjFSIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsImlkIjoiMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsIm5hbWUiOiJQaG9lYmUgQnJpZGdlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVyY0o1eENNWVlMQ2dHaWxGREtSWmwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81cmNKNXhDTVlZTENnR2lsRkRLUlpsIiwiaWQiOiI1cmNKNXhDTVlZTENnR2lsRkRLUlpsIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzA4YWZiNWRjMjk2MDU0ODU2OTA5ZjhmZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwOGFmYjVkYzI5NjA1NDg1NjkwOWY4ZmQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTA4YWZiNWRjMjk2MDU0ODU2OTA5ZjhmZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdHJhbmdlciBpbiB0aGUgQWxwcyAoRGVsdXhlIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0xMC0wMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVyY0o1eENNWVlMQ2dHaWxGREtSWmwifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xcjF1eG95MTlmek14dW50M09OQWtHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJpZCI6IjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0ciLCJuYW1lIjoiUGhvZWJlIEJyaWRnZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifQ==", + "XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjQ0NTIsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0o1RzE3MTQyMTQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzd4d3l2Vldld3kwMURoZGdFdDJXV3EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83eHd5dlZXZXd5MDFEaGRnRXQyV1dxIiwiaWQiOiI3eHd5dlZXZXd5MDFEaGRnRXQyV1dxIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1vdGlvbiBTaWNrbmVzcyAoRGVtbyAtIEJvbnVzIFRyYWNrKSIsInRyYWNrX251bWJlciI6MTMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N3h3eXZWV2V3eTAxRGhkZ0V0MldXcSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xcjF1eG95MTlmek14dW50M09OQWtHIiwiaWQiOiIxcjF1eG95MTlmek14dW50M09OQWtHIiwibmFtZSI6IlBob2ViZSBCcmlkZ2VycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxcjF1eG95MTlmek14dW50M09OQWtHIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMzVTd3Z4YlZXNUY4dXlSYU9NdlZUZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzM1U3d2eGJWVzVGOHV5UmFPTXZWVGQiLCJpZCI6IjM1U3d2eGJWVzVGOHV5UmFPTXZWVGQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZWU3Y2U3MDQ1NDkxMWY0ODI1YTg2Y2ZhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmVlN2NlNzA0NTQ5MTFmNDgyNWE4NmNmYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZWU3Y2U3MDQ1NDkxMWY0ODI1YTg2Y2ZhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1vdGlvbiBTaWNrbmVzcyIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDctMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cg==", + "aSI6InNwb3RpZnk6YWxidW06MzVTd3Z4YlZXNUY4dXlSYU9NdlZUZCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFyMXV4b3kxOWZ6TXh1bnQzT05Ba0cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsImlkIjoiMXIxdXhveTE5ZnpNeHVudDNPTkFrRyIsIm5hbWUiOiJQaG9lYmUgQnJpZGdlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXIxdXhveTE5ZnpNeHVudDNPTkFrRyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjk3NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0o1RzE3MTQyMDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZQUU1TMjhEY0dtUEt1YktWTEo5bXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82UFFNUzI4RGNHbVBLdWJLVkxKOW1yIiwiaWQiOiI2UFFNUzI4RGNHbVBLdWJLVkxKOW1yIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1vdGlvbiBTaWNrbmVzcyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2UFFNUzI4RGNHbVBLdWJLVkxKOW1yIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Motion+Sickness%22+artist%3A%22Phoebe+Bridgers%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkhvbG9jZW5lJTIyJTIwYXJ0aXN0JTNBJTIyQm9uJTIwSXZlciUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MiwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80TEVpVW0xU1JiRk1nZnFuUVR3VWJRIiwiaWQiOiI0TEVpVW0xU1JiRk1nZnFuUVR3VWJRIiwibmFtZSI6IkJvbiBJdmVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRMRWlVbTFTUmJGTWdmcW5RVHdVYlEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yTHBmTmozdkI1ck9YZmFhd0xjT0JnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMkxwZk5qM3ZCNXJPWGZhYXdMY09CZyIsImlkIjoiMkxwZk5qM3ZCNXJPWGZhYXdMY09CZyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNg==", + "NzYxNmQwMDAwYjI3MzRiNmIxNTQ3NDU1YmJlY2I5ZjZiYmE2NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0YjZiMTU0NzQ1NWJiZWNiOWY2YmJhNjQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRiNmIxNTQ3NDU1YmJlY2I5ZjZiYmE2NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCb24gSXZlciwgQm9uIEl2ZXIiLCJyZWxlYXNlX2RhdGUiOiIyMDExLTA2LTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MkxwZk5qM3ZCNXJPWGZhYXdMY09CZyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRMRWlVbTFTUmJGTWdmcW5RVHdVYlEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSIsImlkIjoiNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSIsIm5hbWUiOiJCb24gSXZlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0TEVpVW0xU1JiRk1nZnFuUVR3VWJRIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMzNjYxMywiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVMzOFkxMTEzNTAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zNUtpaUlMa2x5ZTFKUlJjdGFMVWI0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzVLaWlJTGtseWUxSlJSY3RhTFViNCIsImlkIjoiMzVLaWlJTGtseWUxSlJSY3RhTFViNCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb2xvY2VuZSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozNUtpaUlMa2x5ZTFKUlJjdGFMVWI0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRMRWlVbTFTUmJGTWdmcW5RVHdVYlEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSIsImlkIjoiNExFaVVtMVNSYkZNZ2ZxblFUd1ViUSIsIm5hbWUiOiJCb24gSXZlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5Og==", + "YXJ0aXN0OjRMRWlVbTFTUmJGTWdmcW5RVHdVYlEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82eGZPQ3FtUXZwdmdSNWFxNmZwS01EIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnhmT0NxbVF2cHZnUjVhcTZmcEtNRCIsImlkIjoiNnhmT0NxbVF2cHZnUjVhcTZmcEtNRCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNGM2MTMyOTIyMDY4ZjdjZDIxNzg2MmQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTRjNjEzMjkyMjA2OGY3Y2QyMTc4NjJkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExNGM2MTMyOTIyMDY4ZjdjZDIxNzg2MmQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQm9uIEl2ZXIsIEJvbiBJdmVyICgxMHRoIEFubml2ZXJzYXJ5IEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAxMS0wNi0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZ4Zk9DcW1RdnB2Z1I1YXE2ZnBLTUQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80TEVpVW0xU1JiRk1nZnFuUVR3VWJRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJpZCI6IjRMRWlVbTFTUmJGTWdmcW5RVHdVYlEiLCJuYW1lIjoiQm9uIEl2ZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExFaVVtMVNSYkZNZ2ZxblFUd1ViUSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMzY2MTMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTMzhZMTExMzUwMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUlMRUs2TlJmeG9zZW9Qbm9sUmNWQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFJTEVLNk5SZnhvc2VvUG5vbFJjVkEiLCJpZCI6IjFJTEVLNk5SZnhvc2VvUG5vbFJjVkEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9sb2NlbmUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwbw==", + "dGlmeTp0cmFjazoxSUxFSzZOUmZ4b3Nlb1Bub2xSY1ZBIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Holocene%22+artist%3A%22Bon+Iver%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Liability%22%20artist%3A%22Lorde%22&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=track%3A%22Liability%22%20artist%3A%22Lorde%22&type=track","offset":0,"previous":null,"total":83,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"external_urls":{"spotify":"https://open.spotify.com/album/2B87zXm9bOWvAJdkJBTpzF"},"href":"https://api.spotify.com/v1/albums/2B87zXm9bOWvAJdkJBTpzF","id":"2B87zXm9bOWvAJdkJBTpzF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f8553e18a11209d4becd0336"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f8553e18a11209d4becd0336"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f8553e18a11209d4becd0336"}],"is_playable":true,"name":"Melodrama","release_date":"2017-06-16","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:2B87zXm9bOWvAJdkJBTpzF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171727,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/6Kkt27YmFyIFrcX3QXFi2o"},"href":"https://api.spotify.com/v1/tracks/6Kkt27YmFyIFrcX3QXFi2o","id":"6Kkt27YmFyIFrcX3QXFi2o","is_local":false,"is_playable":true,"name":"Liability","track_number":5,"type":"track","uri":"spotify:track:6Kkt27YmFyIFrcX3QXFi2o"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"external_urls":{"spotify":"https://open.spotify.com/album/0RprDFd8KN06rt0jyKXBsC"},"href":"https://api.spotify.com/v1/albums/0RprDFd8KN06rt0jyKXBsC","id":"0RprDFd8KN06rt0jyKXBsC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27334b24bc065105d1fa5df4fa6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0234b24bc065105d1fa5df4fa6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485134b24bc065105d1fa5df4fa6"}],"is_playable":true,"name":"Melodrama","release_date":"2017-06-16","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:0RprDFd8KN06rt0jyKXBsC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171727,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/0p09nVtk8gkpHJsyi0Ha5g"},"href":"https://api.spotify.com/v1/tracks/0p09nVtk8gkpHJsyi0Ha5g","id":"0p09nVtk8gkpHJsyi0Ha5g","is_local":false,"is_playable":true,"name":"Liability","track_number":5,"type":"track","uri":"spotify:track:0p09nVtk8gkpHJsyi0Ha5g"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Jyqs62y8rSt8h5KPNtRBF"},"href":"https://api.spotify.com/v1/albums/0Jyqs62y8rSt8h5KPNtRBF","id":"0Jyqs62y8rSt8h5KPNtRBF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733ef8115fdd3883a132d0e553"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023ef8115fdd3883a132d0e553"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513ef8115fdd3883a132d0e553"}],"is_playable":true,"name":"Dinner with friends - Best dinner music","release_date":"2020-06-26","release_date_precision":"day","total_tracks":46,"type":"album","uri":"spotify:album:0Jyqs62y8rSt8h5KPNtRBF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171727,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/4CXZFhLtktcXRkkO6Fkdli"},"href":"https://api.spotify.com/v1/tracks/4CXZFhLtktcXRkkO6Fkdli","id":"4CXZFhLtktcXRkkO6Fkdli","is_local":false,"is_playable":true,"name":"Liability","track_number":10,"type":"track","uri":"spotify:track:4CXZFhLtktcXRkkO6Fkdli"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6tW47DNFjXOHr1NSd1Vq84"},"href":"https://api.spotify.com/v1/albums/6tW47DNFjXOHr1NSd1Vq84","id":"6tW47DNFjXOHr1NSd1Vq84","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27382fea2698c7b4cd264c1fb6a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0282fea2698c7b4cd264c1fb6a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485182fea2698c7b4cd264c1fb6a"}],"is_playable":true,"name":"Summer Acoustic Hits","release_date":"2022-07-07","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:6tW47DNFjXOHr1NSd1Vq84"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171727,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/0VjsHXrXxWzp1bAW3K9UbU"},"href":"https://api.spotify.com/v1/tracks/0VjsHXrXxWzp1bAW3K9UbU","id":"0VjsHXrXxWzp1bAW3K9UbU","is_local":false,"is_playable":true,"name":"Liability","track_number":10,"type":"track","uri":"spotify:track:0VjsHXrXxWzp1bAW3K9UbU"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6CXHd3lt6zQvxla7vqSpf4"},"href":"https://api.spotify.com/v1/albums/6CXHd3lt6zQvxla7vqSpf4","id":"6CXHd3lt6zQvxla7vqSpf4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27390aef617b1cf446ca7d32fb4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0290aef617b1cf446ca7d32fb4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485190aef617b1cf446ca7d32fb4"}],"is_playable":true,"name":"sad songs 2021: crying and depressing","release_date":"2021-12-10","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6CXHd3lt6zQvxla7vqSpf4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171727,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/6wAAdHDNdPrwDYzyK8LFQl"},"href":"https://api.spotify.com/v1/tracks/6wAAdHDNdPrwDYzyK8LFQl","id":"6wAAdHDNdPrwDYzyK8LFQl","is_local":false,"is_playable":true,"name":"Liability","track_number":8,"type":"track","uri":"spotify:track:6wAAdHDNdPrwDYzyK8LFQl"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3KbxuOfIFhl89F4wM2qF0E"},"href":"https://api.spotify.com/v1/albums/3KbxuOfIFhl89F4wM2qF0E","id":"3KbxuOfIFhl89F4wM2qF0E","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27386105c6c2c7f8e8945ed0771"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0286105c6c2c7f8e8945ed0771"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485186105c6c2c7f8e8945ed0771"}],"is_playable":true,"name":"Acoustic Pop Edition","release_date":"2017-06-16","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:3KbxuOfIFhl89F4wM2qF0E"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171802,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/5N10ncr6bomVEjcyXyLONM"},"href":"https://api.spotify.com/v1/tracks/5N10ncr6bomVEjcyXyLONM","id":"5N10ncr6bomVEjcyXyLONM","is_local":false,"is_playable":true,"name":"Liability","track_number":9,"type":"track","uri":"spotify:track:5N10ncr6bomVEjcyXyLONM"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/55BxFSeJAUHIIzctEAGBOb"},"href":"https://api.spotify.com/v1/albums/55BxFSeJAUHIIzctEAGBOb","id":"55BxFSeJAUHIIzctEAGBOb","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273912ee3b45954a7e6113fb0ba"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02912ee3b45954a7e6113fb0ba"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851912ee3b45954a7e6113fb0ba"}],"is_playable":true,"name":"Dinner Party","release_date":"2017-09-22","release_date_precision":"day","total_tracks":36,"type":"album","uri":"spotify:album:55BxFSeJAUHIIzctEAGBOb"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171749,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/0OA6gYIu0wHJqhpfM1sTFz"},"href":"https://api.spotify.com/v1/tracks/0OA6gYIu0wHJqhpfM1sTFz","id":"0OA6gYIu0wHJqhpfM1sTFz","is_local":false,"is_playable":true,"name":"Liability","track_number":11,"type":"track","uri":"spotify:track:0OA6gYIu0wHJqhpfM1sTFz"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7EmEMtHBMXRn3NhjoW17Pu"},"href":"https://api.spotify.com/v1/albums/7EmEMtHBMXRn3NhjoW17Pu","id":"7EmEMtHBMXRn3NhjoW17Pu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739a49e7038c7410fc13bfc143"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029a49e7038c7410fc13bfc143"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519a49e7038c7410fc13bfc143"}],"is_playable":true,"name":"Academic Burn Out","release_date":"2024-11-01","release_date_precision":"day","total_tracks":54,"type":"album","uri":"spotify:album:7EmEMtHBMXRn3NhjoW17Pu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171727,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/7CnT22nbpFT5QizTJ4hlmG"},"href":"https://api.spotify.com/v1/tracks/7CnT22nbpFT5QizTJ4hlmG","id":"7CnT22nbpFT5QizTJ4hlmG","is_local":false,"is_playable":true,"name":"Liability","track_number":27,"type":"track","uri":"spotify:track:7CnT22nbpFT5QizTJ4hlmG"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1UDLsBgbTfGzUOumBY7WxT"},"href":"https://api.spotify.com/v1/albums/1UDLsBgbTfGzUOumBY7WxT","id":"1UDLsBgbTfGzUOumBY7WxT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27332a47aaf11acae79a003701c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0232a47aaf11acae79a003701c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485132a47aaf11acae79a003701c"}],"is_playable":true,"name":"yearning","release_date":"2025-09-12","release_date_precision":"day","total_tracks":68,"type":"album","uri":"spotify:album:1UDLsBgbTfGzUOumBY7WxT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171727,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/6XHYumdHMBEm5zw20M7P8F"},"href":"https://api.spotify.com/v1/tracks/6XHYumdHMBEm5zw20M7P8F","id":"6XHYumdHMBEm5zw20M7P8F","is_local":false,"is_playable":true,"name":"Liability","track_number":36,"type":"track","uri":"spotify:track:6XHYumdHMBEm5zw20M7P8F"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Er0Wtg4knOMxGxItUCigO"},"href":"https://api.spotify.com/v1/albums/0Er0Wtg4knOMxGxItUCigO","id":"0Er0Wtg4knOMxGxItUCigO","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27344287ce4ffd6d2fbc43eb9fe"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0244287ce4ffd6d2fbc43eb9fe"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485144287ce4ffd6d2fbc43eb9fe"}],"is_playable":true,"name":"Chillout music 2020","release_date":"2020-06-12","release_date_precision":"day","total_tracks":47,"type":"album","uri":"spotify:album:0Er0Wtg4knOMxGxItUCigO"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/163tK9Wjr9P9DmM0AVK7lm"},"href":"https://api.spotify.com/v1/artists/163tK9Wjr9P9DmM0AVK7lm","id":"163tK9Wjr9P9DmM0AVK7lm","name":"Lorde","type":"artist","uri":"spotify:artist:163tK9Wjr9P9DmM0AVK7lm"}],"disc_number":1,"duration_ms":171727,"explicit":false,"external_ids":{"isrc":"NZUM71700064"},"external_urls":{"spotify":"https://open.spotify.com/track/08BmOcgmJpYwVerm9ZYNX2"},"href":"https://api.spotify.com/v1/tracks/08BmOcgmJpYwVerm9ZYNX2","id":"08BmOcgmJpYwVerm9ZYNX2","is_local":false,"is_playable":true,"name":"Liability","track_number":10,"type":"track","uri":"spotify:track:08BmOcgmJpYwVerm9ZYNX2"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkxpYWJpbGl0eSUyMiUyMGFydGlzdCUzQSUyMkxvcmRlJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9zZWFyY2g/b2Zmc2V0PTEwJmxpbWl0PTEwJnF1ZXJ5PXRyYWNrJTNBJTIyTGlhYmlsaXR5JTIyJTIwYXJ0aXN0JTNBJTIyTG9yZGUlMjImdHlwZT10cmFjayIsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo4MywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTYzdEs5V2pyOVA5RG1NMEFWSzdsbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwiaWQiOiIxNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwibmFtZSI6IkxvcmRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE2M3RLOVdqcjlQOURtTTBBVks3bG0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yQjg3elhtOWJPV3ZBSmRrSkJUcHpGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMkI4N3pYbTliT1d2QUpk", + "a0pCVHB6RiIsImlkIjoiMkI4N3pYbTliT1d2QUpka0pCVHB6RiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmODU1M2UxOGExMTIwOWQ0YmVjZDAzMzYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjg1NTNlMThhMTEyMDlkNGJlY2QwMzM2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmODU1M2UxOGExMTIwOWQ0YmVjZDAzMzYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWVsb2RyYW1hIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wNi0xNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJCODd6WG05Yk9XdkFKZGtKQlRwekYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzE2M3RLOVdqcjlQOURtTTBBVks3bG0iLCJpZCI6IjE2M3RLOVdqcjlQOURtTTBBVks3bG0iLCJuYW1lIjoiTG9yZGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTYzdEs5V2pyOVA5RG1NMEFWSzdsbSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzE3MjcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOWlVNNzE3MDAwNjQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZLa3QyN1ltRnlJRnJjWDNRWEZpMm8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82S2t0MjdZbUZ5SUZyY1gzUVhGaTJvIiwiaWQiOiI2S2t0MjdZbUZ5SUZyY1gzUVhGaTJvIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxpYWJpbGl0eSIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2S2t0MjdZbUZ5SUZyY1gzUVhGaTJvIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzE2M3RLOVdqcjlQOURtTTBBVks3bG0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTYzdA==", + "SzlXanI5UDlEbU0wQVZLN2xtIiwiaWQiOiIxNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwibmFtZSI6IkxvcmRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE2M3RLOVdqcjlQOURtTTBBVks3bG0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wUnByREZkOEtOMDZydDBqeUtYQnNDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMFJwckRGZDhLTjA2cnQwanlLWEJzQyIsImlkIjoiMFJwckRGZDhLTjA2cnQwanlLWEJzQyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzNGIyNGJjMDY1MTA1ZDFmYTVkZjRmYTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzRiMjRiYzA2NTEwNWQxZmE1ZGY0ZmE2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzNGIyNGJjMDY1MTA1ZDFmYTVkZjRmYTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTWVsb2RyYW1hIiwicmVsZWFzZV9kYXRlIjoiMjAxNy0wNi0xNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBScHJERmQ4S04wNnJ0MGp5S1hCc0MifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzE2M3RLOVdqcjlQOURtTTBBVks3bG0iLCJpZCI6IjE2M3RLOVdqcjlQOURtTTBBVks3bG0iLCJuYW1lIjoiTG9yZGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTYzdEs5V2pyOVA5RG1NMEFWSzdsbSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzE3MjcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOWlVNNzE3MDAwNjQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBwMDluVnRrOGdrcEhKc3lpMEhhNWcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wcDA5blZ0azhna3BISnN5aTBIYTVnIiwiaWQiOiIwcDA5blZ0azhna3BISnN5aTBIYTVnIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibg==", + "YW1lIjoiTGlhYmlsaXR5IiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBwMDluVnRrOGdrcEhKc3lpMEhhNWcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMEp5cXM2Mnk4clN0OGg1S1BOdFJCRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBKeXFzNjJ5OHJTdDhoNUtQTnRSQkYiLCJpZCI6IjBKeXFzNjJ5OHJTdDhoNUtQTnRSQkYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczM2VmODExNWZkZDM4ODNhMTMyZDBlNTUzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjNlZjgxMTVmZGQzODgzYTEzMmQwZTU1MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxM2VmODExNWZkZDM4ODNhMTMyZDBlNTUzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRpbm5lciB3aXRoIGZyaWVuZHMgLSBCZXN0IGRpbm5lciBtdXNpYyIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDYtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0NiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowSnlxczYyeThyU3Q4aDVLUE50UkJGIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTYzdEs5V2pyOVA5RG1NMEFWSzdsbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwiaWQiOiIxNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwibmFtZSI6IkxvcmRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE2M3RLOVdqcjlQOURtTTBBVks3bA==", + "bSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzE3MjcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOWlVNNzE3MDAwNjQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRDWFpGaEx0a3RjWFJra082RmtkbGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80Q1haRmhMdGt0Y1hSa2tPNkZrZGxpIiwiaWQiOiI0Q1haRmhMdGt0Y1hSa2tPNkZrZGxpIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxpYWJpbGl0eSIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NENYWkZoTHRrdGNYUmtrTzZGa2RsaSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82dFc0N0RORmpYT0hyMU5TZDFWcTg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnRXNDdETkZqWE9IcjFOU2QxVnE4NCIsImlkIjoiNnRXNDdETkZqWE9IcjFOU2QxVnE4NCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4MmZlYTI2OThjN2I0Y2QyNjRjMWZiNmEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODJmZWEyNjk4YzdiNGNkMjY0YzFmYjZhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4MmZlYTI2OThjN2I0Y2QyNjRjMWZiNmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VtbWVyIEFjb3VzdGljIEhpdHMiLCJyZWxlYXNlX2RhdGUiOiIyMDIyLTA3LTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YQ==", + "bGJ1bTo2dFc0N0RORmpYT0hyMU5TZDFWcTg0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTYzdEs5V2pyOVA5RG1NMEFWSzdsbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwiaWQiOiIxNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwibmFtZSI6IkxvcmRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE2M3RLOVdqcjlQOURtTTBBVks3bG0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTcxNzI3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTlpVTTcxNzAwMDY0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wVmpzSFhyWHhXenAxYkFXM0s5VWJVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMFZqc0hYclh4V3pwMWJBVzNLOVViVSIsImlkIjoiMFZqc0hYclh4V3pwMWJBVzNLOVViVSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMaWFiaWxpdHkiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBWanNIWHJYeFd6cDFiQVczSzlVYlUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkNYSGQzbHQ2elF2eGxhN3ZxU3BmNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZDWEhkM2x0NnpRdnhsYTd2cVNwZjQiLCJpZCI6IjZDWEhkM2x0NnpRdnhsYTd2cVNwZjQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTBhZWY2MTdiMWNmNDQ2Y2E3ZDMyZmI0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYQ==", + "YjY3NjE2ZDAwMDAxZTAyOTBhZWY2MTdiMWNmNDQ2Y2E3ZDMyZmI0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5MGFlZjYxN2IxY2Y0NDZjYTdkMzJmYjQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoic2FkIHNvbmdzIDIwMjE6IGNyeWluZyBhbmQgZGVwcmVzc2luZyIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMTItMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2Q1hIZDNsdDZ6UXZ4bGE3dnFTcGY0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTYzdEs5V2pyOVA5RG1NMEFWSzdsbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwiaWQiOiIxNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwibmFtZSI6IkxvcmRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE2M3RLOVdqcjlQOURtTTBBVks3bG0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTcxNzI3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTlpVTTcxNzAwMDY0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82d0FBZEhETmRQcndEWXp5SzhMRlFsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNndBQWRIRE5kUHJ3RFl6eUs4TEZRbCIsImlkIjoiNndBQWRIRE5kUHJ3RFl6eUs4TEZRbCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMaWFiaWxpdHkiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NndBQWRIRE5kUHJ3RFl6eUs4TEZRbCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOg==", + "Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNLYnh1T2ZJRmhsODlGNHdNMnFGMEUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zS2J4dU9mSUZobDg5RjR3TTJxRjBFIiwiaWQiOiIzS2J4dU9mSUZobDg5RjR3TTJxRjBFIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzg2MTA1YzZjMmM3ZjhlODk0NWVkMDc3MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4NjEwNWM2YzJjN2Y4ZTg5NDVlZDA3NzEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTg2MTA1YzZjMmM3ZjhlODk0NWVkMDc3MSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBY291c3RpYyBQb3AgRWRpdGlvbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTctMDYtMTYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozS2J4dU9mSUZobDg5RjR3TTJxRjBFIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTYzdEs5V2pyOVA5RG1NMEFWSzdsbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwiaWQiOiIxNjN0SzlXanI5UDlEbU0wQVZLN2xtIiwibmFtZSI6IkxvcmRlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE2M3RLOVdqcjlQOURtTTBBVks3bG0ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTcxODAyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTlpVTTcxNzAwMDY0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81TjEwbmNyNmJvbVZFamN5WHlMT05NIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNU4xMG5jcjZib21WRWpjeVh5TE9OTSIsImlkIjoiNU4xMG5jcjZib21WRWpjeVh5TE9OTSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMaWFiaWxpdHkiLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NU4xMG5jcjZib21WRWpjeVh5TE9OTSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYQ==", + "bF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzU1QnhGU2VKQVVISUl6Y3RFQUdCT2IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81NUJ4RlNlSkFVSElJemN0RUFHQk9iIiwiaWQiOiI1NUJ4RlNlSkFVSElJemN0RUFHQk9iIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzkxMmVlM2I0NTk1NGE3ZTYxMTNmYjBiYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5MTJlZTNiNDU5NTRhN2U2MTEzZmIwYmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTkxMmVlM2I0NTk1NGE3ZTYxMTNmYjBiYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEaW5uZXIgUGFydHkiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTA5LTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NTVCeEZTZUpBVUhJSXpjdEVBR0JPYiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzE2M3RLOVdqcjlQOURtTTBBVks3bG0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTYzdEs5V2pyOVA5RG1NMEFWSzdsbSIsImlkIjoiMTYzdEs5V2pyOVA5RG1NMEFWSzdsbSIsIm5hbWUiOiJMb3JkZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxNjN0SzlXanI5UDlEbU0wQVZLN2xtIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3MTc0OSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5aVU03MTcwMDA2NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svME9BNmdZSXUwd0hKcWhwZk0xc1RGeg==", + "In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvME9BNmdZSXUwd0hKcWhwZk0xc1RGeiIsImlkIjoiME9BNmdZSXUwd0hKcWhwZk0xc1RGeiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMaWFiaWxpdHkiLCJ0cmFja19udW1iZXIiOjExLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBPQTZnWUl1MHdISnFocGZNMXNURnoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN0VtRU10SEJNWFJuM05oam9XMTdQdSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdFbUVNdEhCTVhSbjNOaGpvVzE3UHUiLCJpZCI6IjdFbUVNdEhCTVhSbjNOaGpvVzE3UHUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWE0OWU3MDM4Yzc0MTBmYzEzYmZjMTQzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjlhNDllNzAzOGM3NDEwZmMxM2JmYzE0MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWE0OWU3MDM4Yzc0MTBmYzEzYmZjMTQzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFjYWRlbWljIEJ1cm4gT3V0IiwicmVsZWFzZV9kYXRlIjoiMjAyNC0xMS0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjU0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdFbUVNdEhCTVhSbjNOaGpvVzE3UHUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzE2M3RLOVdqcjlQOQ==", + "RG1NMEFWSzdsbSIsImlkIjoiMTYzdEs5V2pyOVA5RG1NMEFWSzdsbSIsIm5hbWUiOiJMb3JkZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxNjN0SzlXanI5UDlEbU0wQVZLN2xtIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3MTcyNywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5aVU03MTcwMDA2NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN0NuVDIybmJwRlQ1UWl6VEo0aGxtRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdDblQyMm5icEZUNVFpelRKNGhsbUciLCJpZCI6IjdDblQyMm5icEZUNVFpelRKNGhsbUciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGlhYmlsaXR5IiwidHJhY2tfbnVtYmVyIjoyNywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3Q25UMjJuYnBGVDVRaXpUSjRobG1HIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFVRExzQmdiVGZHelVPdW1CWTdXeFQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xVURMc0JnYlRmR3pVT3VtQlk3V3hUIiwiaWQiOiIxVURMc0JnYlRmR3pVT3VtQlk3V3hUIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzMyYTQ3YWFmMTFhY2FlNzlhMDAzNzAxYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzMmE0N2FhZjExYWNhZTc5YTAwMzcwMWMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTMyYTQ3YWFmMTFhY2FlNzlhMDAzNzAxYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJ5ZWFybmluZyIsInJlbA==", + "ZWFzZV9kYXRlIjoiMjAyNS0wOS0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjY4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFVRExzQmdiVGZHelVPdW1CWTdXeFQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzE2M3RLOVdqcjlQOURtTTBBVks3bG0iLCJpZCI6IjE2M3RLOVdqcjlQOURtTTBBVks3bG0iLCJuYW1lIjoiTG9yZGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTYzdEs5V2pyOVA5RG1NMEFWSzdsbSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzE3MjcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOWlVNNzE3MDAwNjQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZYSFl1bWRITUJFbTV6dzIwTTdQOEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82WEhZdW1kSE1CRW01encyME03UDhGIiwiaWQiOiI2WEhZdW1kSE1CRW01encyME03UDhGIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxpYWJpbGl0eSIsInRyYWNrX251bWJlciI6MzYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NlhIWXVtZEhNQkVtNXp3MjBNN1A4RiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wRXIwV3RnNGtuT014R3hJdFVDaWdPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMEVyMFd0ZzRrbk9NeEd4SXRVQ2lnTyIsImlkIjoiMEVyMFd0ZzRrbk9NeEd4SXRVQ2lnTyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYQ==", + "Z2UvYWI2NzYxNmQwMDAwYjI3MzQ0Mjg3Y2U0ZmZkNmQyZmJjNDNlYjlmZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0NDI4N2NlNGZmZDZkMmZiYzQzZWI5ZmUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTQ0Mjg3Y2U0ZmZkNmQyZmJjNDNlYjlmZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDaGlsbG91dCBtdXNpYyAyMDIwIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wNi0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ3LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBFcjBXdGc0a25PTXhHeEl0VUNpZ08ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xNjN0SzlXanI5UDlEbU0wQVZLN2xtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzE2M3RLOVdqcjlQOURtTTBBVks3bG0iLCJpZCI6IjE2M3RLOVdqcjlQOURtTTBBVks3bG0iLCJuYW1lIjoiTG9yZGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTYzdEs5V2pyOVA5RG1NMEFWSzdsbSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzE3MjcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJOWlVNNzE3MDAwNjQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzA4Qm1PY2dtSnBZd1Zlcm05WllOWDIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wOEJtT2NnbUpwWXdWZXJtOVpZTlgyIiwiaWQiOiIwOEJtT2NnbUpwWXdWZXJtOVpZTlgyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxpYWJpbGl0eSIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MDhCbU9jZ21KcFl3VmVybTlaWU5YMiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Liability%22+artist%3A%22Lorde%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Cherry%20Wine%22%20artist%3A%22Hozier%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FXC3k01G6Gw61bmprjgqS"},"href":"https://api.spotify.com/v1/artists/2FXC3k01G6Gw61bmprjgqS","id":"2FXC3k01G6Gw61bmprjgqS","name":"Hozier","type":"artist","uri":"spotify:artist:2FXC3k01G6Gw61bmprjgqS"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Uv83rRhY5QvHKkQoULRKk"},"href":"https://api.spotify.com/v1/albums/0Uv83rRhY5QvHKkQoULRKk","id":"0Uv83rRhY5QvHKkQoULRKk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737a9bf5f82e32d33d4503fe7b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027a9bf5f82e32d33d4503fe7b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517a9bf5f82e32d33d4503fe7b"}],"is_playable":true,"name":"Hozier","release_date":"2014-09-19","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:0Uv83rRhY5QvHKkQoULRKk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FXC3k01G6Gw61bmprjgqS"},"href":"https://api.spotify.com/v1/artists/2FXC3k01G6Gw61bmprjgqS","id":"2FXC3k01G6Gw61bmprjgqS","name":"Hozier","type":"artist","uri":"spotify:artist:2FXC3k01G6Gw61bmprjgqS"}],"disc_number":1,"duration_ms":240147,"explicit":false,"external_ids":{"isrc":"IEACJ1300034"},"external_urls":{"spotify":"https://open.spotify.com/track/4Q66chx9WzqWcLItXoZ5r4"},"href":"https://api.spotify.com/v1/tracks/4Q66chx9WzqWcLItXoZ5r4","id":"4Q66chx9WzqWcLItXoZ5r4","is_local":false,"is_playable":true,"name":"Cherry Wine - Live","track_number":13,"type":"track","uri":"spotify:track:4Q66chx9WzqWcLItXoZ5r4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FXC3k01G6Gw61bmprjgqS"},"href":"https://api.spotify.com/v1/artists/2FXC3k01G6Gw61bmprjgqS","id":"2FXC3k01G6Gw61bmprjgqS","name":"Hozier","type":"artist","uri":"spotify:artist:2FXC3k01G6Gw61bmprjgqS"}],"external_urls":{"spotify":"https://open.spotify.com/album/44zQnmrFcPCmPp6NLMfTuz"},"href":"https://api.spotify.com/v1/albums/44zQnmrFcPCmPp6NLMfTuz","id":"44zQnmrFcPCmPp6NLMfTuz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732303ece0e9af3917d0bce05f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022303ece0e9af3917d0bce05f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512303ece0e9af3917d0bce05f"}],"is_playable":true,"name":"Hozier (Special Edition)","release_date":"2014-09-19","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:44zQnmrFcPCmPp6NLMfTuz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FXC3k01G6Gw61bmprjgqS"},"href":"https://api.spotify.com/v1/artists/2FXC3k01G6Gw61bmprjgqS","id":"2FXC3k01G6Gw61bmprjgqS","name":"Hozier","type":"artist","uri":"spotify:artist:2FXC3k01G6Gw61bmprjgqS"}],"disc_number":1,"duration_ms":240147,"explicit":false,"external_ids":{"isrc":"IEACJ1300034"},"external_urls":{"spotify":"https://open.spotify.com/track/1FWFmQZwvNctmy8kT5ESw1"},"href":"https://api.spotify.com/v1/tracks/1FWFmQZwvNctmy8kT5ESw1","id":"1FWFmQZwvNctmy8kT5ESw1","is_local":false,"is_playable":true,"name":"Cherry Wine - Live","track_number":13,"type":"track","uri":"spotify:track:1FWFmQZwvNctmy8kT5ESw1"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FXC3k01G6Gw61bmprjgqS"},"href":"https://api.spotify.com/v1/artists/2FXC3k01G6Gw61bmprjgqS","id":"2FXC3k01G6Gw61bmprjgqS","name":"Hozier","type":"artist","uri":"spotify:artist:2FXC3k01G6Gw61bmprjgqS"}],"external_urls":{"spotify":"https://open.spotify.com/album/0qGyw4fHuIt3FdhQGm4q6T"},"href":"https://api.spotify.com/v1/albums/0qGyw4fHuIt3FdhQGm4q6T","id":"0qGyw4fHuIt3FdhQGm4q6T","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27306b96e50d50a8ddb6ace40fe"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0206b96e50d50a8ddb6ace40fe"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485106b96e50d50a8ddb6ace40fe"}],"is_playable":true,"name":"Spotify Sessions (Live From Spotify SXSW)","release_date":"2014-07-25","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:0qGyw4fHuIt3FdhQGm4q6T"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FXC3k01G6Gw61bmprjgqS"},"href":"https://api.spotify.com/v1/artists/2FXC3k01G6Gw61bmprjgqS","id":"2FXC3k01G6Gw61bmprjgqS","name":"Hozier","type":"artist","uri":"spotify:artist:2FXC3k01G6Gw61bmprjgqS"}],"disc_number":1,"duration_ms":257787,"explicit":false,"external_ids":{"isrc":"IEACJ1400207"},"external_urls":{"spotify":"https://open.spotify.com/track/1NJqqnQ60kYiqXQxcLGAEj"},"href":"https://api.spotify.com/v1/tracks/1NJqqnQ60kYiqXQxcLGAEj","id":"1NJqqnQ60kYiqXQxcLGAEj","is_local":false,"is_playable":true,"name":"Cherry Wine - Live","track_number":2,"type":"track","uri":"spotify:track:1NJqqnQ60kYiqXQxcLGAEj"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/23Mpmb0EV7aUooveD0YJUx"},"href":"https://api.spotify.com/v1/albums/23Mpmb0EV7aUooveD0YJUx","id":"23Mpmb0EV7aUooveD0YJUx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273af40af47e48ab29c5b0e975d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02af40af47e48ab29c5b0e975d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851af40af47e48ab29c5b0e975d"}],"is_playable":true,"name":"Chilled Acoustic Guitar","release_date":"2020-03-01","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:23Mpmb0EV7aUooveD0YJUx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4si0Z3C5HiS4pt5L7Z631M"},"href":"https://api.spotify.com/v1/artists/4si0Z3C5HiS4pt5L7Z631M","id":"4si0Z3C5HiS4pt5L7Z631M","name":"Andrew Hozier-Byrne","type":"artist","uri":"spotify:artist:4si0Z3C5HiS4pt5L7Z631M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1SrtjQi2tlAty4Z1No5JFW"},"href":"https://api.spotify.com/v1/artists/1SrtjQi2tlAty4Z1No5JFW","id":"1SrtjQi2tlAty4Z1No5JFW","name":"Arlo Vega","type":"artist","uri":"spotify:artist:1SrtjQi2tlAty4Z1No5JFW"}],"disc_number":1,"duration_ms":243500,"explicit":false,"external_ids":{"isrc":"UKUZW2000235"},"external_urls":{"spotify":"https://open.spotify.com/track/7mXi4rIIzrPyW4mTv2nxKp"},"href":"https://api.spotify.com/v1/tracks/7mXi4rIIzrPyW4mTv2nxKp","id":"7mXi4rIIzrPyW4mTv2nxKp","is_local":false,"is_playable":true,"name":"Cherry Wine (Arr. for Guitar)","track_number":12,"type":"track","uri":"spotify:track:7mXi4rIIzrPyW4mTv2nxKp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5pdvIjLJ1wTTbT3XA6gPoS"},"href":"https://api.spotify.com/v1/albums/5pdvIjLJ1wTTbT3XA6gPoS","id":"5pdvIjLJ1wTTbT3XA6gPoS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739fe97b27ee9f55e4ac4bf29f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029fe97b27ee9f55e4ac4bf29f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519fe97b27ee9f55e4ac4bf29f"}],"is_playable":true,"name":"Relaxing Guitar","release_date":"2020-05-10","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5pdvIjLJ1wTTbT3XA6gPoS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4si0Z3C5HiS4pt5L7Z631M"},"href":"https://api.spotify.com/v1/artists/4si0Z3C5HiS4pt5L7Z631M","id":"4si0Z3C5HiS4pt5L7Z631M","name":"Andrew Hozier-Byrne","type":"artist","uri":"spotify:artist:4si0Z3C5HiS4pt5L7Z631M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5Wh0V6exDDvYu74sz3Ab89"},"href":"https://api.spotify.com/v1/artists/5Wh0V6exDDvYu74sz3Ab89","id":"5Wh0V6exDDvYu74sz3Ab89","name":"Daniel Flowers","type":"artist","uri":"spotify:artist:5Wh0V6exDDvYu74sz3Ab89"}],"disc_number":1,"duration_ms":243500,"explicit":false,"external_ids":{"isrc":"UKUZW2000828"},"external_urls":{"spotify":"https://open.spotify.com/track/6s17rbdGNbFfe0KnItGsZk"},"href":"https://api.spotify.com/v1/tracks/6s17rbdGNbFfe0KnItGsZk","id":"6s17rbdGNbFfe0KnItGsZk","is_local":false,"is_playable":true,"name":"Cherry Wine (Arr. for Guitar)","track_number":6,"type":"track","uri":"spotify:track:6s17rbdGNbFfe0KnItGsZk"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4XCq6MX9FBVhU1VX7yn2gH"},"href":"https://api.spotify.com/v1/albums/4XCq6MX9FBVhU1VX7yn2gH","id":"4XCq6MX9FBVhU1VX7yn2gH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739579e2f4fba1ccb838d3c7e4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029579e2f4fba1ccb838d3c7e4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519579e2f4fba1ccb838d3c7e4"}],"is_playable":true,"name":"Relaxing Acoustic Guitar Covers","release_date":"2021-05-16","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:4XCq6MX9FBVhU1VX7yn2gH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4si0Z3C5HiS4pt5L7Z631M"},"href":"https://api.spotify.com/v1/artists/4si0Z3C5HiS4pt5L7Z631M","id":"4si0Z3C5HiS4pt5L7Z631M","name":"Andrew Hozier-Byrne","type":"artist","uri":"spotify:artist:4si0Z3C5HiS4pt5L7Z631M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0XCFBli8lXOvIusJZG8XGM"},"href":"https://api.spotify.com/v1/artists/0XCFBli8lXOvIusJZG8XGM","id":"0XCFBli8lXOvIusJZG8XGM","name":"Thomas Tiersen","type":"artist","uri":"spotify:artist:0XCFBli8lXOvIusJZG8XGM"}],"disc_number":1,"duration_ms":236750,"explicit":false,"external_ids":{"isrc":"GBMNA2100388"},"external_urls":{"spotify":"https://open.spotify.com/track/1yiz2Lmj3yKMK3ZGpNG2cq"},"href":"https://api.spotify.com/v1/tracks/1yiz2Lmj3yKMK3ZGpNG2cq","id":"1yiz2Lmj3yKMK3ZGpNG2cq","is_local":false,"is_playable":true,"name":"Cherry Wine (Arr. for Guitar)","track_number":4,"type":"track","uri":"spotify:track:1yiz2Lmj3yKMK3ZGpNG2cq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3mRiZCoYhoPIIHyWpvp8qX"},"href":"https://api.spotify.com/v1/albums/3mRiZCoYhoPIIHyWpvp8qX","id":"3mRiZCoYhoPIIHyWpvp8qX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d86c1b8a97200404633326b2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d86c1b8a97200404633326b2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d86c1b8a97200404633326b2"}],"is_playable":true,"name":"Esquenta Festival 2024","release_date":"2024-03-22","release_date_precision":"day","total_tracks":31,"type":"album","uri":"spotify:album:3mRiZCoYhoPIIHyWpvp8qX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FXC3k01G6Gw61bmprjgqS"},"href":"https://api.spotify.com/v1/artists/2FXC3k01G6Gw61bmprjgqS","id":"2FXC3k01G6Gw61bmprjgqS","name":"Hozier","type":"artist","uri":"spotify:artist:2FXC3k01G6Gw61bmprjgqS"}],"disc_number":1,"duration_ms":240147,"explicit":false,"external_ids":{"isrc":"IEACJ1300034"},"external_urls":{"spotify":"https://open.spotify.com/track/1SsXvXsAv3ivIq5bQa4Vmn"},"href":"https://api.spotify.com/v1/tracks/1SsXvXsAv3ivIq5bQa4Vmn","id":"1SsXvXsAv3ivIq5bQa4Vmn","is_local":false,"is_playable":true,"name":"Cherry Wine - Live","track_number":28,"type":"track","uri":"spotify:track:1SsXvXsAv3ivIq5bQa4Vmn"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3xeOFpKSPogIkB7ubGxrDI"},"href":"https://api.spotify.com/v1/albums/3xeOFpKSPogIkB7ubGxrDI","id":"3xeOFpKSPogIkB7ubGxrDI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737bdab23b4fb40f2aee4f7d39"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027bdab23b4fb40f2aee4f7d39"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517bdab23b4fb40f2aee4f7d39"}],"is_playable":true,"name":"Pop Hits on Acoustic Guitar","release_date":"2021-03-28","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:3xeOFpKSPogIkB7ubGxrDI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4si0Z3C5HiS4pt5L7Z631M"},"href":"https://api.spotify.com/v1/artists/4si0Z3C5HiS4pt5L7Z631M","id":"4si0Z3C5HiS4pt5L7Z631M","name":"Andrew Hozier-Byrne","type":"artist","uri":"spotify:artist:4si0Z3C5HiS4pt5L7Z631M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0XCFBli8lXOvIusJZG8XGM"},"href":"https://api.spotify.com/v1/artists/0XCFBli8lXOvIusJZG8XGM","id":"0XCFBli8lXOvIusJZG8XGM","name":"Thomas Tiersen","type":"artist","uri":"spotify:artist:0XCFBli8lXOvIusJZG8XGM"}],"disc_number":1,"duration_ms":236750,"explicit":false,"external_ids":{"isrc":"GBMNA2100202"},"external_urls":{"spotify":"https://open.spotify.com/track/7f0UF9k1kMDNIuYeQxuDyE"},"href":"https://api.spotify.com/v1/tracks/7f0UF9k1kMDNIuYeQxuDyE","id":"7f0UF9k1kMDNIuYeQxuDyE","is_local":false,"is_playable":true,"name":"Cherry Wine (Arr. for Guitar)","track_number":4,"type":"track","uri":"spotify:track:7f0UF9k1kMDNIuYeQxuDyE"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1ixEFLdxoz6h6YeR17zJ9C"},"href":"https://api.spotify.com/v1/albums/1ixEFLdxoz6h6YeR17zJ9C","id":"1ixEFLdxoz6h6YeR17zJ9C","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731e92096fd6b633d1ab1d58a1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021e92096fd6b633d1ab1d58a1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511e92096fd6b633d1ab1d58a1"}],"is_playable":true,"name":"Relaxing Acoustic Guitar Covers","release_date":"2019-12-22","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1ixEFLdxoz6h6YeR17zJ9C"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4si0Z3C5HiS4pt5L7Z631M"},"href":"https://api.spotify.com/v1/artists/4si0Z3C5HiS4pt5L7Z631M","id":"4si0Z3C5HiS4pt5L7Z631M","name":"Andrew Hozier-Byrne","type":"artist","uri":"spotify:artist:4si0Z3C5HiS4pt5L7Z631M"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1SrtjQi2tlAty4Z1No5JFW"},"href":"https://api.spotify.com/v1/artists/1SrtjQi2tlAty4Z1No5JFW","id":"1SrtjQi2tlAty4Z1No5JFW","name":"Arlo Vega","type":"artist","uri":"spotify:artist:1SrtjQi2tlAty4Z1No5JFW"}],"disc_number":1,"duration_ms":243500,"explicit":false,"external_ids":{"isrc":"UKUZW1900143"},"external_urls":{"spotify":"https://open.spotify.com/track/3jS8h3NqeqtdbzGZ75IQgO"},"href":"https://api.spotify.com/v1/tracks/3jS8h3NqeqtdbzGZ75IQgO","id":"3jS8h3NqeqtdbzGZ75IQgO","is_local":false,"is_playable":true,"name":"Cherry Wine (Arr. for Guitar)","track_number":9,"type":"track","uri":"spotify:track:3jS8h3NqeqtdbzGZ75IQgO"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNoZXJyeSUyMFdpbmUlMjIlMjBhcnRpc3QlM0ElMjJIb3ppZXIlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJGWEMzazAxRzZHdzYxYm1wcmpncVMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkZYQzNrMDFHNkd3NjFibXByamdxUyIsImlkIjoiMkZYQzNrMDFHNkd3NjFibXByamdxUyIsIm5hbWUiOiJIb3ppZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkZYQzNrMDFHNkd3NjFibXByamdxUyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBVdjgzclJoWTVRdkhLa1FvVUxSS2sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wVXY4M3JSaFk1UXZIS2tRb1VMUktrIiwiaWQiOiIwVXY4M3JSaFk1UXZIS2tRb1VMUktrIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzdhOWJmNWY4MmUzMmQzM2Q0NTAzZmU3YiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3YTliZjVmODJlMzJkMzNkNDUwM2ZlN2IifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTdhOWJmNWY4MmUzMmQzM2Q0NTAzZmU3YiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb3ppZXIiLCJyZWxlYXNlX2RhdGUiOiIyMDE0LTA5LTE5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MFV2ODNyUmhZNVF2SEtrUW9VTFJLayJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJGWEMzazAxRzZHdzYxYm1wcmpncVMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkZYQzNrMDFHNkd3NjFibXByamdxUyIsImlkIjoiMkZYQzNrMDFHNkd3NjFibXByamdxUyIsIm5hbWUiOg==", + "IkhvemllciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRlhDM2swMUc2R3c2MWJtcHJqZ3FTIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDE0NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IklFQUNKMTMwMDAzNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNFE2NmNoeDlXenFXY0xJdFhvWjVyNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRRNjZjaHg5V3pxV2NMSXRYb1o1cjQiLCJpZCI6IjRRNjZjaHg5V3pxV2NMSXRYb1o1cjQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2hlcnJ5IFdpbmUgLSBMaXZlIiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0UTY2Y2h4OVd6cVdjTEl0WG9aNXI0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJGWEMzazAxRzZHdzYxYm1wcmpncVMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkZYQzNrMDFHNkd3NjFibXByamdxUyIsImlkIjoiMkZYQzNrMDFHNkd3NjFibXByamdxUyIsIm5hbWUiOiJIb3ppZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkZYQzNrMDFHNkd3NjFibXByamdxUyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzQ0elFubXJGY1BDbVBwNk5MTWZUdXoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80NHpRbm1yRmNQQ21QcDZOTE1mVHV6IiwiaWQiOiI0NHpRbm1yRmNQQ21QcDZOTE1mVHV6IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzIzMDNlY2UwZTlhZjM5MTdkMGJjZTA1ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyMzAzZWNlMGU5YWYzOTE3ZDBiY2UwNWYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTIzMDNlY2UwZTlhZjM5MTdkMGJjZTA1ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb3ppZXIgKFNwZWNpYWwgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDE0LTA5LTE5IiwicmVsZWFzZV9kYXRlXw==", + "cHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0NHpRbm1yRmNQQ21QcDZOTE1mVHV6In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkZYQzNrMDFHNkd3NjFibXByamdxUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRlhDM2swMUc2R3c2MWJtcHJqZ3FTIiwiaWQiOiIyRlhDM2swMUc2R3c2MWJtcHJqZ3FTIiwibmFtZSI6IkhvemllciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRlhDM2swMUc2R3c2MWJtcHJqZ3FTIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDE0NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IklFQUNKMTMwMDAzNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMUZXRm1RWnd2TmN0bXk4a1Q1RVN3MSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFGV0ZtUVp3dk5jdG15OGtUNUVTdzEiLCJpZCI6IjFGV0ZtUVp3dk5jdG15OGtUNUVTdzEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2hlcnJ5IFdpbmUgLSBMaXZlIiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxRldGbVFad3ZOY3RteThrVDVFU3cxIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRlhDM2swMUc2R3c2MWJtcHJqZ3FTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJGWEMzazAxRzZHdzYxYm1wcmpncVMiLCJpZCI6IjJGWEMzazAxRzZHdzYxYm1wcmpncVMiLCJuYW1lIjoiSG96aWVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJGWEMzazAxRzZHdzYxYm1wcmpncVMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wcUd5dzRmSHVJdDNGZGhRR200cTZUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMHFHeXc0Zkh1SXQzRmRoUUdtNHE2VCIsImlkIjoiMHFHeXc0Zkh1SXQzRmRoUUdtNHE2VCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwNmI5NmU1MGQ1MGE4ZGRiNmFjZTQwZg==", + "ZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIwNmI5NmU1MGQ1MGE4ZGRiNmFjZTQwZmUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTA2Yjk2ZTUwZDUwYThkZGI2YWNlNDBmZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTcG90aWZ5IFNlc3Npb25zIChMaXZlIEZyb20gU3BvdGlmeSBTWFNXKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTQtMDctMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBxR3l3NGZIdUl0M0ZkaFFHbTRxNlQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRlhDM2swMUc2R3c2MWJtcHJqZ3FTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJGWEMzazAxRzZHdzYxYm1wcmpncVMiLCJpZCI6IjJGWEMzazAxRzZHdzYxYm1wcmpncVMiLCJuYW1lIjoiSG96aWVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJGWEMzazAxRzZHdzYxYm1wcmpncVMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjU3Nzg3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiSUVBQ0oxNDAwMjA3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xTkpxcW5RNjBrWWlxWFF4Y0xHQUVqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMU5KcXFuUTYwa1lpcVhReGNMR0FFaiIsImlkIjoiMU5KcXFuUTYwa1lpcVhReGNMR0FFaiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDaGVycnkgV2luZSAtIExpdmUiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MU5KcXFuUTYwa1lpcVhReGNMR0FFaiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6Ig==", + "c3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzIzTXBtYjBFVjdhVW9vdmVEMFlKVXgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yM01wbWIwRVY3YVVvb3ZlRDBZSlV4IiwiaWQiOiIyM01wbWIwRVY3YVVvb3ZlRDBZSlV4IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FmNDBhZjQ3ZTQ4YWIyOWM1YjBlOTc1ZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhZjQwYWY0N2U0OGFiMjljNWIwZTk3NWQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFmNDBhZjQ3ZTQ4YWIyOWM1YjBlOTc1ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDaGlsbGVkIEFjb3VzdGljIEd1aXRhciIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDMtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyM01wbWIwRVY3YVVvb3ZlRDBZSlV4In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHNpMFozQzVIaVM0cHQ1TDdaNjMxTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80c2kwWjNDNUhpUzRwdDVMN1o2MzFNIiwiaWQiOiI0c2kwWjNDNUhpUzRwdDVMN1o2MzFNIiwibmFtZSI6IkFuZHJldyBIb3ppZXItQnlybmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHNpMFozQzVIaVM0cHQ1TDdaNjMxTSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xU3J0alFpMnRsQXR5NFoxTm81SkZXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFTcnRqUWkydGxBdHk0WjFObzVKRlciLCJpZCI6IjFTcnRqUWkydGxBdHk0WjFObzVKRlciLCJuYW1lIjoiQXJsbyBWZWdhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFTcnRqUWkydGxBdHk0WjFObzVKRlcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQzNTAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVUtVWlcyMDAwMjM1In0sImV4dGVybmFsX3VybA==", + "cyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdtWGk0cklJenJQeVc0bVR2Mm54S3AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83bVhpNHJJSXpyUHlXNG1UdjJueEtwIiwiaWQiOiI3bVhpNHJJSXpyUHlXNG1UdjJueEtwIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNoZXJyeSBXaW5lIChBcnIuIGZvciBHdWl0YXIpIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3bVhpNHJJSXpyUHlXNG1UdjJueEtwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVwZHZJakxKMXdUVGJUM1hBNmdQb1MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81cGR2SWpMSjF3VFRiVDNYQTZnUG9TIiwiaWQiOiI1cGR2SWpMSjF3VFRiVDNYQTZnUG9TIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzlmZTk3YjI3ZWU5ZjU1ZTRhYzRiZjI5ZiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5ZmU5N2IyN2VlOWY1NWU0YWM0YmYyOWYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTlmZTk3YjI3ZWU5ZjU1ZTRhYzRiZjI5ZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWxheGluZyBHdWl0YXIiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTA1LTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NXBkdklqTEoxd1RUYlQzWEE2Z1BvUyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYQ==", + "cnRpc3QvNHNpMFozQzVIaVM0cHQ1TDdaNjMxTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80c2kwWjNDNUhpUzRwdDVMN1o2MzFNIiwiaWQiOiI0c2kwWjNDNUhpUzRwdDVMN1o2MzFNIiwibmFtZSI6IkFuZHJldyBIb3ppZXItQnlybmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHNpMFozQzVIaVM0cHQ1TDdaNjMxTSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81V2gwVjZleEREdll1NzRzejNBYjg5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVXaDBWNmV4RER2WXU3NHN6M0FiODkiLCJpZCI6IjVXaDBWNmV4RER2WXU3NHN6M0FiODkiLCJuYW1lIjoiRGFuaWVsIEZsb3dlcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVdoMFY2ZXhERHZZdTc0c3ozQWI4OSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDM1MDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVS1VaVzIwMDA4MjgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZzMTdyYmRHTmJGZmUwS25JdEdzWmsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82czE3cmJkR05iRmZlMEtuSXRHc1prIiwiaWQiOiI2czE3cmJkR05iRmZlMEtuSXRHc1prIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNoZXJyeSBXaW5lIChBcnIuIGZvciBHdWl0YXIpIiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZzMTdyYmRHTmJGZmUwS25JdEdzWmsifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFhDcTZNWDlGQlZoVTFWWDd5bjJnSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRYQ3E2TVg5RkJWaFUxVg==", + "WDd5bjJnSCIsImlkIjoiNFhDcTZNWDlGQlZoVTFWWDd5bjJnSCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5NTc5ZTJmNGZiYTFjY2I4MzhkM2M3ZTQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTU3OWUyZjRmYmExY2NiODM4ZDNjN2U0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5NTc5ZTJmNGZiYTFjY2I4MzhkM2M3ZTQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVsYXhpbmcgQWNvdXN0aWMgR3VpdGFyIENvdmVycyIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDUtMTYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0WENxNk1YOUZCVmhVMVZYN3luMmdIIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHNpMFozQzVIaVM0cHQ1TDdaNjMxTSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80c2kwWjNDNUhpUzRwdDVMN1o2MzFNIiwiaWQiOiI0c2kwWjNDNUhpUzRwdDVMN1o2MzFNIiwibmFtZSI6IkFuZHJldyBIb3ppZXItQnlybmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHNpMFozQzVIaVM0cHQ1TDdaNjMxTSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wWENGQmxpOGxYT3ZJdXNKWkc4WEdNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBYQ0ZCbGk4bFhPdkl1c0paRzhYR00iLCJpZCI6IjBYQ0ZCbGk4bFhPdkl1c0paRzhYR00iLCJuYW1lIjoiVGhvbWFzIFRpZXJzZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFhDRkJsaThsWE92SXVzSlpHOFhHTSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzY3NTAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQk1OQTIxMDAzODgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzF5aXoyTG1qM3lLTUszWkdwTkcyY3EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xeWl6MkxtajN5S01LM1pHcE5HMmNxIiwiaWQiOiIxeWl6MkxtajN5S01LM1pHcE5HMmNxIiwiaQ==", + "c19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2hlcnJ5IFdpbmUgKEFyci4gZm9yIEd1aXRhcikiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MXlpejJMbWozeUtNSzNaR3BORzJjcSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zbVJpWkNvWWhvUElJSHlXcHZwOHFYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM21SaVpDb1lob1BJSUh5V3B2cDhxWCIsImlkIjoiM21SaVpDb1lob1BJSUh5V3B2cDhxWCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkODZjMWI4YTk3MjAwNDA0NjMzMzI2YjIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZDg2YzFiOGE5NzIwMDQwNDYzMzMyNmIyIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkODZjMWI4YTk3MjAwNDA0NjMzMzI2YjIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRXNxdWVudGEgRmVzdGl2YWwgMjAyNCIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDMtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozbVJpWkNvWWhvUElJSHlXcHZwOHFYIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkZYQzNrMDFHNkd3NjFibXByamdxUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yRlhDM2swMUc2R3c2MWJtcHJqZ3FTIiwiaWQiOiIyRlhDM2swMUc2R3c2MWJtcHJqZ3FTIiwibmFtZSI6IkhvemllciIsInR5cGUiOiJhcnRpc3QiLCJ1cg==", + "aSI6InNwb3RpZnk6YXJ0aXN0OjJGWEMzazAxRzZHdzYxYm1wcmpncVMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQwMTQ3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiSUVBQ0oxMzAwMDM0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xU3NYdlhzQXYzaXZJcTViUWE0Vm1uIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVNzWHZYc0F2M2l2SXE1YlFhNFZtbiIsImlkIjoiMVNzWHZYc0F2M2l2SXE1YlFhNFZtbiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDaGVycnkgV2luZSAtIExpdmUiLCJ0cmFja19udW1iZXIiOjI4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFTc1h2WHNBdjNpdklxNWJRYTRWbW4ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM3hlT0ZwS1NQb2dJa0I3dWJHeHJESSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzN4ZU9GcEtTUG9nSWtCN3ViR3hyREkiLCJpZCI6IjN4ZU9GcEtTUG9nSWtCN3ViR3hyREkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2JkYWIyM2I0ZmI0MGYyYWVlNGY3ZDM5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdiZGFiMjNiNGZiNDBmMmFlZTRmN2QzOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2JkYWIyM2I0ZmI0MGYyYWVlNGY3ZDM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBvcCBIaXRzIG9uIEFjb3VzdGljIEd1aXRhciIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDMtMjgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIg==", + "OiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjN4ZU9GcEtTUG9nSWtCN3ViR3hyREkifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80c2kwWjNDNUhpUzRwdDVMN1o2MzFNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRzaTBaM0M1SGlTNHB0NUw3WjYzMU0iLCJpZCI6IjRzaTBaM0M1SGlTNHB0NUw3WjYzMU0iLCJuYW1lIjoiQW5kcmV3IEhvemllci1CeXJuZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0c2kwWjNDNUhpUzRwdDVMN1o2MzFNIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBYQ0ZCbGk4bFhPdkl1c0paRzhYR00ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFhDRkJsaThsWE92SXVzSlpHOFhHTSIsImlkIjoiMFhDRkJsaThsWE92SXVzSlpHOFhHTSIsIm5hbWUiOiJUaG9tYXMgVGllcnNlbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowWENGQmxpOGxYT3ZJdXNKWkc4WEdNIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNjc1MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCTU5BMjEwMDIwMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2YwVUY5azFrTUROSXVZZVF4dUR5RSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdmMFVGOWsxa01ETkl1WWVReHVEeUUiLCJpZCI6IjdmMFVGOWsxa01ETkl1WWVReHVEeUUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2hlcnJ5IFdpbmUgKEFyci4gZm9yIEd1aXRhcikiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6N2YwVUY5azFrTUROSXVZZVF4dUR5RSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUA==", + "WnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFpeEVGTGR4b3o2aDZZZVIxN3pKOUMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xaXhFRkxkeG96Nmg2WWVSMTd6SjlDIiwiaWQiOiIxaXhFRkxkeG96Nmg2WWVSMTd6SjlDIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzFlOTIwOTZmZDZiNjMzZDFhYjFkNThhMSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxZTkyMDk2ZmQ2YjYzM2QxYWIxZDU4YTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTFlOTIwOTZmZDZiNjMzZDFhYjFkNThhMSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWxheGluZyBBY291c3RpYyBHdWl0YXIgQ292ZXJzIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0xMi0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFpeEVGTGR4b3o2aDZZZVIxN3pKOUMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80c2kwWjNDNUhpUzRwdDVMN1o2MzFNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRzaTBaM0M1SGlTNHB0NUw3WjYzMU0iLCJpZCI6IjRzaTBaM0M1SGlTNHB0NUw3WjYzMU0iLCJuYW1lIjoiQW5kcmV3IEhvemllci1CeXJuZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0c2kwWjNDNUhpUzRwdDVMN1o2MzFNIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFTcnRqUWkydGxBdHk0WjFObzVKRlcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVNydGpRaTJ0bEF0eTRaMU5vNUpGVyIsImlkIjoiMVNydGpRaTJ0bEF0eTRaMU5vNUpGVyIsIm5hbWUiOiJBcmxvIFZlZ2EiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVNydGpRaTJ0bEF0eTRaMU5vNUpGVyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDM1MDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVS1VaVzE5MDAxNDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Lw==", + "L29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2pTOGgzTnFlcXRkYnpHWjc1SVFnTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNqUzhoM05xZXF0ZGJ6R1o3NUlRZ08iLCJpZCI6IjNqUzhoM05xZXF0ZGJ6R1o3NUlRZ08iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ2hlcnJ5IFdpbmUgKEFyci4gZm9yIEd1aXRhcikiLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2pTOGgzTnFlcXRkYnpHWjc1SVFnTyJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Cherry+Wine%22+artist%3A%22Hozier%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Sunday%20Morning%22%20artist%3A%22Maroon%205%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"external_urls":{"spotify":"https://open.spotify.com/album/5zClcGCSWj926AMjvBNSLc"},"href":"https://api.spotify.com/v1/albums/5zClcGCSWj926AMjvBNSLc","id":"5zClcGCSWj926AMjvBNSLc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27392f2d790c6a97b195f66d51e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0292f2d790c6a97b195f66d51e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485192f2d790c6a97b195f66d51e"}],"is_playable":true,"name":"Songs About Jane: 10th Anniversary Edition","release_date":"2002","release_date_precision":"year","total_tracks":29,"type":"album","uri":"spotify:album:5zClcGCSWj926AMjvBNSLc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"disc_number":1,"duration_ms":244880,"explicit":false,"external_ids":{"isrc":"USJAY0300086"},"external_urls":{"spotify":"https://open.spotify.com/track/5qII2n90lVdPDcgXEEVHNy"},"href":"https://api.spotify.com/v1/tracks/5qII2n90lVdPDcgXEEVHNy","id":"5qII2n90lVdPDcgXEEVHNy","is_local":false,"is_playable":true,"name":"Sunday Morning","track_number":8,"type":"track","uri":"spotify:track:5qII2n90lVdPDcgXEEVHNy"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"external_urls":{"spotify":"https://open.spotify.com/album/1Rv9WRKyYhFaGbuYDaQunN"},"href":"https://api.spotify.com/v1/albums/1Rv9WRKyYhFaGbuYDaQunN","id":"1Rv9WRKyYhFaGbuYDaQunN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27317b3850d758fff5a2301e537"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0217b3850d758fff5a2301e537"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485117b3850d758fff5a2301e537"}],"is_playable":true,"name":"Songs About Jane","release_date":"2002-06-25","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:1Rv9WRKyYhFaGbuYDaQunN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"disc_number":1,"duration_ms":244866,"explicit":false,"external_ids":{"isrc":"USJAY0300086"},"external_urls":{"spotify":"https://open.spotify.com/track/1YI0uK36eupTmw9F8kHysr"},"href":"https://api.spotify.com/v1/tracks/1YI0uK36eupTmw9F8kHysr","id":"1YI0uK36eupTmw9F8kHysr","is_local":false,"is_playable":true,"name":"Sunday Morning","track_number":8,"type":"track","uri":"spotify:track:1YI0uK36eupTmw9F8kHysr"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3h4hern6IoIQV1gfFEFLRL"},"href":"https://api.spotify.com/v1/albums/3h4hern6IoIQV1gfFEFLRL","id":"3h4hern6IoIQV1gfFEFLRL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273608dc677f90bbf7e9a9703b5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02608dc677f90bbf7e9a9703b5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851608dc677f90bbf7e9a9703b5"}],"is_playable":true,"name":"Chill Hits","release_date":"2020-05-08","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:3h4hern6IoIQV1gfFEFLRL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"disc_number":1,"duration_ms":244546,"explicit":false,"external_ids":{"isrc":"USJAY0300086"},"external_urls":{"spotify":"https://open.spotify.com/track/2sMkh8GxgR3Gy6Rn8tCchL"},"href":"https://api.spotify.com/v1/tracks/2sMkh8GxgR3Gy6Rn8tCchL","id":"2sMkh8GxgR3Gy6Rn8tCchL","is_local":false,"is_playable":true,"name":"Sunday Morning","track_number":6,"type":"track","uri":"spotify:track:2sMkh8GxgR3Gy6Rn8tCchL"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0YsFtjCfzhaAGuVFEpwxWx"},"href":"https://api.spotify.com/v1/albums/0YsFtjCfzhaAGuVFEpwxWx","id":"0YsFtjCfzhaAGuVFEpwxWx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a25f0ca362d1ddf43301ea7b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a25f0ca362d1ddf43301ea7b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a25f0ca362d1ddf43301ea7b"}],"is_playable":true,"name":"Sunday Morning Breakfast Music","release_date":"2019-12-06","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:0YsFtjCfzhaAGuVFEpwxWx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"disc_number":1,"duration_ms":244546,"explicit":false,"external_ids":{"isrc":"USJAY0300086"},"external_urls":{"spotify":"https://open.spotify.com/track/5Yz9hQBlYgxWOeGEG3tW6V"},"href":"https://api.spotify.com/v1/tracks/5Yz9hQBlYgxWOeGEG3tW6V","id":"5Yz9hQBlYgxWOeGEG3tW6V","is_local":false,"is_playable":true,"name":"Sunday Morning","track_number":1,"type":"track","uri":"spotify:track:5Yz9hQBlYgxWOeGEG3tW6V"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Jyqs62y8rSt8h5KPNtRBF"},"href":"https://api.spotify.com/v1/albums/0Jyqs62y8rSt8h5KPNtRBF","id":"0Jyqs62y8rSt8h5KPNtRBF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733ef8115fdd3883a132d0e553"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023ef8115fdd3883a132d0e553"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513ef8115fdd3883a132d0e553"}],"is_playable":true,"name":"Dinner with friends - Best dinner music","release_date":"2020-06-26","release_date_precision":"day","total_tracks":46,"type":"album","uri":"spotify:album:0Jyqs62y8rSt8h5KPNtRBF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"disc_number":1,"duration_ms":243080,"explicit":false,"external_ids":{"isrc":"USJAY0300086"},"external_urls":{"spotify":"https://open.spotify.com/track/6W3PmslGLwA1S8MiicP1Mf"},"href":"https://api.spotify.com/v1/tracks/6W3PmslGLwA1S8MiicP1Mf","id":"6W3PmslGLwA1S8MiicP1Mf","is_local":false,"is_playable":true,"name":"Sunday Morning","track_number":9,"type":"track","uri":"spotify:track:6W3PmslGLwA1S8MiicP1Mf"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/10aGJWYzrfa7qzgkmEbgTX"},"href":"https://api.spotify.com/v1/albums/10aGJWYzrfa7qzgkmEbgTX","id":"10aGJWYzrfa7qzgkmEbgTX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273feb1599576a9f4ca0fac4217"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02feb1599576a9f4ca0fac4217"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851feb1599576a9f4ca0fac4217"}],"is_playable":true,"name":"Summer Acoustic","release_date":"2020-08-17","release_date_precision":"day","total_tracks":39,"type":"album","uri":"spotify:album:10aGJWYzrfa7qzgkmEbgTX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"disc_number":1,"duration_ms":244546,"explicit":false,"external_ids":{"isrc":"USJAY0300086"},"external_urls":{"spotify":"https://open.spotify.com/track/0KegimOvrv7DsQbCml2Kfp"},"href":"https://api.spotify.com/v1/tracks/0KegimOvrv7DsQbCml2Kfp","id":"0KegimOvrv7DsQbCml2Kfp","is_local":false,"is_playable":true,"name":"Sunday Morning","track_number":4,"type":"track","uri":"spotify:track:0KegimOvrv7DsQbCml2Kfp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1P2qhDeq4RJCbsAujcfaWe"},"href":"https://api.spotify.com/v1/albums/1P2qhDeq4RJCbsAujcfaWe","id":"1P2qhDeq4RJCbsAujcfaWe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273678fe49acd330439e9c290ab"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02678fe49acd330439e9c290ab"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851678fe49acd330439e9c290ab"}],"is_playable":true,"name":"Happy Morning","release_date":"2021-04-27","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:1P2qhDeq4RJCbsAujcfaWe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"disc_number":1,"duration_ms":244546,"explicit":false,"external_ids":{"isrc":"USJAY0300086"},"external_urls":{"spotify":"https://open.spotify.com/track/74EJr7taVZYZPiKjOXiJlu"},"href":"https://api.spotify.com/v1/tracks/74EJr7taVZYZPiKjOXiJlu","id":"74EJr7taVZYZPiKjOXiJlu","is_local":false,"is_playable":true,"name":"Sunday Morning","track_number":16,"type":"track","uri":"spotify:track:74EJr7taVZYZPiKjOXiJlu"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3b2sjpxeUWNtGyW5JNdYSW"},"href":"https://api.spotify.com/v1/albums/3b2sjpxeUWNtGyW5JNdYSW","id":"3b2sjpxeUWNtGyW5JNdYSW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dad139cc1f78c02cd82ac250"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dad139cc1f78c02cd82ac250"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dad139cc1f78c02cd82ac250"}],"is_playable":true,"name":"2000's HITS","release_date":"2022-11-08","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:3b2sjpxeUWNtGyW5JNdYSW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"disc_number":1,"duration_ms":244546,"explicit":false,"external_ids":{"isrc":"USJAY0300086"},"external_urls":{"spotify":"https://open.spotify.com/track/7vaJ12a7bP7EGBl7UnMCzw"},"href":"https://api.spotify.com/v1/tracks/7vaJ12a7bP7EGBl7UnMCzw","id":"7vaJ12a7bP7EGBl7UnMCzw","is_local":false,"is_playable":true,"name":"Sunday Morning","track_number":18,"type":"track","uri":"spotify:track:7vaJ12a7bP7EGBl7UnMCzw"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6B14wxCZ4i9QiZL4ReYNVY"},"href":"https://api.spotify.com/v1/albums/6B14wxCZ4i9QiZL4ReYNVY","id":"6B14wxCZ4i9QiZL4ReYNVY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738edd937370caca8c71a6522e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028edd937370caca8c71a6522e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518edd937370caca8c71a6522e"}],"is_playable":true,"name":"Thankful 2022","release_date":"2022-06-29","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:6B14wxCZ4i9QiZL4ReYNVY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/04gDigrS5kc9YWfZHwBETP"},"href":"https://api.spotify.com/v1/artists/04gDigrS5kc9YWfZHwBETP","id":"04gDigrS5kc9YWfZHwBETP","name":"Maroon 5","type":"artist","uri":"spotify:artist:04gDigrS5kc9YWfZHwBETP"}],"disc_number":1,"duration_ms":244546,"explicit":false,"external_ids":{"isrc":"USJAY0300086"},"external_urls":{"spotify":"https://open.spotify.com/track/6FtvmRwMAl646iypUR9PDY"},"href":"https://api.spotify.com/v1/tracks/6FtvmRwMAl646iypUR9PDY","id":"6FtvmRwMAl646iypUR9PDY","is_local":false,"is_playable":true,"name":"Sunday Morning","track_number":25,"type":"track","uri":"spotify:track:6FtvmRwMAl646iypUR9PDY"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN1bmRheSUyME1vcm5pbmclMjIlMjBhcnRpc3QlM0ElMjJNYXJvb24lMjA1JTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo5LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJpZCI6IjA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJuYW1lIjoiTWFyb29uIDUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDRnRGlnclM1a2M5WVdmWkh3QkVUUCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzV6Q2xjR0NTV2o5MjZBTWp2Qk5TTGMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81ekNsY0dDU1dqOTI2QU1qdkJOU0xjIiwiaWQiOiI1ekNsY0dDU1dqOTI2QU1qdkJOU0xjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzkyZjJkNzkwYzZhOTdiMTk1ZjY2ZDUxZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5MmYyZDc5MGM2YTk3YjE5NWY2NmQ1MWUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTkyZjJkNzkwYzZhOTdiMTk1ZjY2ZDUxZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb25ncyBBYm91dCBKYW5lOiAxMHRoIEFubml2ZXJzYXJ5IEVkaXRpb24iLCJyZWxlYXNlX2RhdGUiOiIyMDAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6InllYXIiLCJ0b3RhbF90cmFja3MiOjI5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjV6Q2xjR0NTV2o5MjZBTWp2Qk5TTGMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA0Z0RpZ3JTNWtjOVlXZlpId0JFVA==", + "UCIsImlkIjoiMDRnRGlnclM1a2M5WVdmWkh3QkVUUCIsIm5hbWUiOiJNYXJvb24gNSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NDg4MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSkFZMDMwMDA4NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNXFJSTJuOTBsVmRQRGNnWEVFVkhOeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVxSUkybjkwbFZkUERjZ1hFRVZITnkiLCJpZCI6IjVxSUkybjkwbFZkUERjZ1hFRVZITnkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VuZGF5IE1vcm5pbmciLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXFJSTJuOTBsVmRQRGNnWEVFVkhOeSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJpZCI6IjA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJuYW1lIjoiTWFyb29uIDUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDRnRGlnclM1a2M5WVdmWkh3QkVUUCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFSdjlXUkt5WWhGYUdidVlEYVF1bk4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xUnY5V1JLeVloRmFHYnVZRGFRdW5OIiwiaWQiOiIxUnY5V1JLeVloRmFHYnVZRGFRdW5OIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE3YjM4NTBkNzU4ZmZmNWEyMzAxZTUzNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxN2IzODUwZDc1OGZmZjVhMjMwMWU1MzcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE3YjM4NTBkNzU4ZmZmNWEyMzAxZTUzNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTb25ncyBBYm91dCBKYW5lIiwicmVsZWFzZV9kYQ==", + "dGUiOiIyMDAyLTA2LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MVJ2OVdSS3lZaEZhR2J1WURhUXVuTiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDRnRGlnclM1a2M5WVdmWkh3QkVUUCIsImlkIjoiMDRnRGlnclM1a2M5WVdmWkh3QkVUUCIsIm5hbWUiOiJNYXJvb24gNSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NDg2NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSkFZMDMwMDA4NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVlJMHVLMzZldXBUbXc5RjhrSHlzciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFZSTB1SzM2ZXVwVG13OUY4a0h5c3IiLCJpZCI6IjFZSTB1SzM2ZXVwVG13OUY4a0h5c3IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VuZGF5IE1vcm5pbmciLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MVlJMHVLMzZldXBUbXc5RjhrSHlzciJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zaDRoZXJuNklvSVFWMWdmRkVGTFJMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2g0aGVybjZJb0lRVjFnZkZFRkxSTCIsImlkIjoiM2g0aGVybjZJb0lRVjFnZkZFRkxSTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYQ==", + "Z2UvYWI2NzYxNmQwMDAwYjI3MzYwOGRjNjc3ZjkwYmJmN2U5YTk3MDNiNSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2MDhkYzY3N2Y5MGJiZjdlOWE5NzAzYjUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTYwOGRjNjc3ZjkwYmJmN2U5YTk3MDNiNSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDaGlsbCBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wNS0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNoNGhlcm42SW9JUVYxZ2ZGRUZMUkwifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJpZCI6IjA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJuYW1lIjoiTWFyb29uIDUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDRnRGlnclM1a2M5WVdmWkh3QkVUUCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDQ1NDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0pBWTAzMDAwODYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJzTWtoOEd4Z1IzR3k2Um44dENjaEwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yc01raDhHeGdSM0d5NlJuOHRDY2hMIiwiaWQiOiIyc01raDhHeGdSM0d5NlJuOHRDY2hMIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bmRheSBNb3JuaW5nIiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJzTWtoOEd4Z1IzR3k2Um44dENjaEwifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpcw==", + "dCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wWXNGdGpDZnpoYUFHdVZGRXB3eFd4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMFlzRnRqQ2Z6aGFBR3VWRkVwd3hXeCIsImlkIjoiMFlzRnRqQ2Z6aGFBR3VWRkVwd3hXeCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhMjVmMGNhMzYyZDFkZGY0MzMwMWVhN2IifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTI1ZjBjYTM2MmQxZGRmNDMzMDFlYTdiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhMjVmMGNhMzYyZDFkZGY0MzMwMWVhN2IifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VuZGF5IE1vcm5pbmcgQnJlYWtmYXN0IE11c2ljIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0xMi0wNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBZc0Z0akNmemhhQUd1VkZFcHd4V3gifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJpZCI6IjA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJuYW1lIjoiTWFyb29uIDUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDRnRGlnclM1a2M5WVdmWkh3QkVUUCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDQ1NDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0pBWTAzMDAwODYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVZejloUUJsWWd4V09lR0VHM3RXNlYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81WXo5aFFCbFlneFdPZUdFRzN0VzZWIiwiaWQiOiI1WXo5aFFCbFlneFdPZUdFRzN0VzZWIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bmRheSBNb3JuaW5nIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLA==", + "InVyaSI6InNwb3RpZnk6dHJhY2s6NVl6OWhRQmxZZ3hXT2VHRUczdFc2ViJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wSnlxczYyeThyU3Q4aDVLUE50UkJGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMEp5cXM2Mnk4clN0OGg1S1BOdFJCRiIsImlkIjoiMEp5cXM2Mnk4clN0OGg1S1BOdFJCRiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzZWY4MTE1ZmRkMzg4M2ExMzJkMGU1NTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyM2VmODExNWZkZDM4ODNhMTMyZDBlNTUzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzZWY4MTE1ZmRkMzg4M2ExMzJkMGU1NTMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGlubmVyIHdpdGggZnJpZW5kcyAtIEJlc3QgZGlubmVyIG11c2ljIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wNi0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBKeXFzNjJ5OHJTdDhoNUtQTnRSQkYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJpZCI6IjA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJuYW1lIjoiTWFyb29uIDUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDRnRGlnclM1a2M5WVdmWkh3QkVUUCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDMwODAsImV4cA==", + "bGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSkFZMDMwMDA4NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNlczUG1zbEdMd0ExUzhNaWljUDFNZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZXM1Btc2xHTHdBMVM4TWlpY1AxTWYiLCJpZCI6IjZXM1Btc2xHTHdBMVM4TWlpY1AxTWYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VuZGF5IE1vcm5pbmciLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NlczUG1zbEdMd0ExUzhNaWljUDFNZiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xMGFHSldZenJmYTdxemdrbUViZ1RYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTBhR0pXWXpyZmE3cXpna21FYmdUWCIsImlkIjoiMTBhR0pXWXpyZmE3cXpna21FYmdUWCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmZWIxNTk5NTc2YTlmNGNhMGZhYzQyMTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZmViMTU5OTU3NmE5ZjRjYTBmYWM0MjE3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmZWIxNTk5NTc2YTlmNGNhMGZhYzQyMTcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VtbWVyIEFjb3VzdGljIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wOC0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjEwYUdKV1l6cmZhN3F6Z2ttRWJnVFgifSwiYXJ0aXN0cyI6W3siZXh0ZQ==", + "cm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDRnRGlnclM1a2M5WVdmWkh3QkVUUCIsImlkIjoiMDRnRGlnclM1a2M5WVdmWkh3QkVUUCIsIm5hbWUiOiJNYXJvb24gNSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NDU0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSkFZMDMwMDA4NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMEtlZ2ltT3ZydjdEc1FiQ21sMktmcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBLZWdpbU92cnY3RHNRYkNtbDJLZnAiLCJpZCI6IjBLZWdpbU92cnY3RHNRYkNtbDJLZnAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3VuZGF5IE1vcm5pbmciLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MEtlZ2ltT3ZydjdEc1FiQ21sMktmcCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xUDJxaERlcTRSSkNic0F1amNmYVdlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVAycWhEZXE0UkpDYnNBdWpjZmFXZSIsImlkIjoiMVAycWhEZXE0UkpDYnNBdWpjZmFXZSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2NzhmZTQ5YWNkMzMwNDM5ZTljMjkwYWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNjc4ZmU0OWFjZDMzMDQzOWU5YzI5MGFiIg==", + "fSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTY3OGZlNDlhY2QzMzA0MzllOWMyOTBhYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIYXBweSBNb3JuaW5nIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wNC0yNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFQMnFoRGVxNFJKQ2JzQXVqY2ZhV2UifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJpZCI6IjA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJuYW1lIjoiTWFyb29uIDUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDRnRGlnclM1a2M5WVdmWkh3QkVUUCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDQ1NDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0pBWTAzMDAwODYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzc0RUpyN3RhVlpZWlBpS2pPWGlKbHUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83NEVKcjd0YVZaWVpQaUtqT1hpSmx1IiwiaWQiOiI3NEVKcjd0YVZaWVpQaUtqT1hpSmx1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bmRheSBNb3JuaW5nIiwidHJhY2tfbnVtYmVyIjoxNiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3NEVKcjd0YVZaWVpQaUtqT1hpSmx1In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNiMnNqcHhlVVdOdEd5VzVKTmRZU1cifSwiaHJlZg==", + "IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNiMnNqcHhlVVdOdEd5VzVKTmRZU1ciLCJpZCI6IjNiMnNqcHhlVVdOdEd5VzVKTmRZU1ciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZGFkMTM5Y2MxZjc4YzAyY2Q4MmFjMjUwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmRhZDEzOWNjMWY3OGMwMmNkODJhYzI1MCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZGFkMTM5Y2MxZjc4YzAyY2Q4MmFjMjUwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjIwMDAncyBISVRTIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0xMS0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNiMnNqcHhlVVdOdEd5VzVKTmRZU1cifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJpZCI6IjA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAiLCJuYW1lIjoiTWFyb29uIDUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDRnRGlnclM1a2M5WVdmWkh3QkVUUCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDQ1NDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0pBWTAzMDAwODYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzd2YUoxMmE3YlA3RUdCbDdVbk1DencifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83dmFKMTJhN2JQN0VHQmw3VW5NQ3p3IiwiaWQiOiI3dmFKMTJhN2JQN0VHQmw3VW5NQ3p3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1bmRheSBNb3JuaW5nIiwidHJhY2tfbnVtYmVyIjoxOCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3dmFKMTJhN2JQN0VHQmw3VW5NQ3p3In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeQ==", + "ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkIxNHd4Q1o0aTlRaVpMNFJlWU5WWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZCMTR3eENaNGk5UWlaTDRSZVlOVlkiLCJpZCI6IjZCMTR3eENaNGk5UWlaTDRSZVlOVlkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOGVkZDkzNzM3MGNhY2E4YzcxYTY1MjJlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjhlZGQ5MzczNzBjYWNhOGM3MWE2NTIyZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOGVkZDkzNzM3MGNhY2E4YzcxYTY1MjJlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoYW5rZnVsIDIwMjIiLCJyZWxlYXNlX2RhdGUiOiIyMDIyLTA2LTI5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkIxNHd4Q1o0aTlRaVpMNFJlWU5WWSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA0Z0RpZ3JTNWtjOVlXZlpId0JFVFAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDRnRGlnclM1a2M5WVdmWkh3QkVUUCIsImlkIjoiMDRnRGlnclM1a2M5WVdmWkh3QkVUUCIsIm5hbWUiOiJNYXJvb24gNSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowNGdEaWdyUzVrYzlZV2ZaSHdCRVRQIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NDU0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTSkFZMDMwMDA4NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNkZ0dm1Sd01BbDY0Nml5cFVSOVBEWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZGdHZtUg==", + "d01BbDY0Nml5cFVSOVBEWSIsImlkIjoiNkZ0dm1Sd01BbDY0Nml5cFVSOVBEWSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdW5kYXkgTW9ybmluZyIsInRyYWNrX251bWJlciI6MjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NkZ0dm1Sd01BbDY0Nml5cFVSOVBEWSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Sunday+Morning%22+artist%3A%22Maroon+5%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1SYWlueSUyMERheXMlMjBNYXllciUyMEhhd3Rob3JuZSZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1SYWlueSUyMERheXMlMjBNYXllciUyMEhhd3Rob3JuZSZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Rainy+Days+Mayer+Hawthorne&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Fake%20Empire%22%20artist%3A%22The%20National%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Td1c2eAXaFzU4F8QCbFbp"},"href":"https://api.spotify.com/v1/albums/3Td1c2eAXaFzU4F8QCbFbp","id":"3Td1c2eAXaFzU4F8QCbFbp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c7a2d8675f75bc64fbf137d2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c7a2d8675f75bc64fbf137d2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c7a2d8675f75bc64fbf137d2"}],"is_playable":true,"name":"Boxer","release_date":"2007-05-21","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3Td1c2eAXaFzU4F8QCbFbp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":205040,"explicit":false,"external_ids":{"isrc":"GBAZP0700003"},"external_urls":{"spotify":"https://open.spotify.com/track/65aZDJQwNllPxuLPixJ4YO"},"href":"https://api.spotify.com/v1/tracks/65aZDJQwNllPxuLPixJ4YO","id":"65aZDJQwNllPxuLPixJ4YO","is_local":false,"is_playable":true,"name":"Fake Empire","track_number":1,"type":"track","uri":"spotify:track:65aZDJQwNllPxuLPixJ4YO"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/7zoPW334cQNfQyWWteTwMj"},"href":"https://api.spotify.com/v1/albums/7zoPW334cQNfQyWWteTwMj","id":"7zoPW334cQNfQyWWteTwMj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e044188d0c236d8fd2e02e20"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e044188d0c236d8fd2e02e20"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e044188d0c236d8fd2e02e20"}],"is_playable":true,"name":"A Skin, A Night + The Virginia EP","release_date":"2008-05-19","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:7zoPW334cQNfQyWWteTwMj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":234146,"explicit":false,"external_ids":{"isrc":"GBAZP0700123"},"external_urls":{"spotify":"https://open.spotify.com/track/0SoR3Yd7DDubnxORMHBoCj"},"href":"https://api.spotify.com/v1/tracks/0SoR3Yd7DDubnxORMHBoCj","id":"0SoR3Yd7DDubnxORMHBoCj","is_local":false,"is_playable":true,"name":"Fake Empire - Live","track_number":11,"type":"track","uri":"spotify:track:0SoR3Yd7DDubnxORMHBoCj"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/1e2uNOopZUlKxiOxb5NSCP"},"href":"https://api.spotify.com/v1/albums/1e2uNOopZUlKxiOxb5NSCP","id":"1e2uNOopZUlKxiOxb5NSCP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738ab5f9c036cde7f1751293f0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028ab5f9c036cde7f1751293f0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518ab5f9c036cde7f1751293f0"}],"is_playable":true,"name":"Rome","release_date":"2024-10-23","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:1e2uNOopZUlKxiOxb5NSCP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":207733,"explicit":false,"external_ids":{"isrc":"GBAFL2400415"},"external_urls":{"spotify":"https://open.spotify.com/track/0v5g72kZs5syL5qXHcxfHs"},"href":"https://api.spotify.com/v1/tracks/0v5g72kZs5syL5qXHcxfHs","id":"0v5g72kZs5syL5qXHcxfHs","is_local":false,"is_playable":true,"name":"Fake Empire - Live in Rome","track_number":1,"type":"track","uri":"spotify:track:0v5g72kZs5syL5qXHcxfHs"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2nCtwH1K9gt9sJJQDrtVVd"},"href":"https://api.spotify.com/v1/albums/2nCtwH1K9gt9sJJQDrtVVd","id":"2nCtwH1K9gt9sJJQDrtVVd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27324289f95aee971b9c0bafeec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0224289f95aee971b9c0bafeec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485124289f95aee971b9c0bafeec"}],"is_playable":true,"name":"Rome","release_date":"2024-12-13","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:2nCtwH1K9gt9sJJQDrtVVd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":207733,"explicit":false,"external_ids":{"isrc":"GBAFL2400415"},"external_urls":{"spotify":"https://open.spotify.com/track/0IpJMpcvBGA5qqW1xwpeQy"},"href":"https://api.spotify.com/v1/tracks/0IpJMpcvBGA5qqW1xwpeQy","id":"0IpJMpcvBGA5qqW1xwpeQy","is_local":false,"is_playable":true,"name":"Fake Empire - Live in Rome","track_number":17,"type":"track","uri":"spotify:track:0IpJMpcvBGA5qqW1xwpeQy"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/62TcfUc3NeWjLLxXM9x6H6"},"href":"https://api.spotify.com/v1/albums/62TcfUc3NeWjLLxXM9x6H6","id":"62TcfUc3NeWjLLxXM9x6H6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e440453acbad7c0d883da86a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e440453acbad7c0d883da86a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e440453acbad7c0d883da86a"}],"is_playable":true,"name":"Rome (Full Concert)","release_date":"2025-12-13","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:62TcfUc3NeWjLLxXM9x6H6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":207733,"explicit":false,"external_ids":{"isrc":"GBAFL2400415"},"external_urls":{"spotify":"https://open.spotify.com/track/39b4rMtsfjqB0uA2WCNygO"},"href":"https://api.spotify.com/v1/tracks/39b4rMtsfjqB0uA2WCNygO","id":"39b4rMtsfjqB0uA2WCNygO","is_local":false,"is_playable":true,"name":"Fake Empire - Live in Rome","track_number":20,"type":"track","uri":"spotify:track:39b4rMtsfjqB0uA2WCNygO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2qkziMtty89VX13g27aIFL"},"href":"https://api.spotify.com/v1/albums/2qkziMtty89VX13g27aIFL","id":"2qkziMtty89VX13g27aIFL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273091f826e35525a92b4d6f1e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02091f826e35525a92b4d6f1e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851091f826e35525a92b4d6f1e8"}],"is_playable":true,"name":"Boxer (Live in Brussels)","release_date":"2018-07-13","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:2qkziMtty89VX13g27aIFL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":201420,"explicit":false,"external_ids":{"isrc":"GBAFL1800014"},"external_urls":{"spotify":"https://open.spotify.com/track/0azRmczvz97kixqOScQ1vQ"},"href":"https://api.spotify.com/v1/tracks/0azRmczvz97kixqOScQ1vQ","id":"0azRmczvz97kixqOScQ1vQ","is_local":false,"is_playable":true,"name":"Fake Empire - Live in Brussels","track_number":1,"type":"track","uri":"spotify:track:0azRmczvz97kixqOScQ1vQ"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZha2UlMjBFbXBpcmUlMjIlMjBhcnRpc3QlM0ElMjJUaGUlMjBOYXRpb25hbCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmNDVXRHSzlzRFUyRW9FbG5rMEdOQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yY0NVdEdLOXNEVTJFb0VsbmswR05CIiwiaWQiOiIyY0NVdEdLOXNEVTJFb0VsbmswR05CIiwibmFtZSI6IlRoZSBOYXRpb25hbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyY0NVdEdLOXNEVTJFb0VsbmswR05CIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM1RkMWMyZUFYYUZ6VTRGOFFDYkZicCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNUZDFjMmVBWGFGelU0RjhRQ2JGYnAiLCJpZCI6IjNUZDFjMmVBWGFGelU0RjhRQ2JGYnAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nk", + "bi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzdhMmQ4Njc1Zjc1YmM2NGZiZjEzN2QyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM3YTJkODY3NWY3NWJjNjRmYmYxMzdkMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzdhMmQ4Njc1Zjc1YmM2NGZiZjEzN2QyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJveGVyIiwicmVsZWFzZV9kYXRlIjoiMjAwNy0wNS0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNUZDFjMmVBWGFGelU0RjhRQ2JGYnAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yY0NVdEdLOXNEVTJFb0VsbmswR05CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJpZCI6IjJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJuYW1lIjoiVGhlIE5hdGlvbmFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJjQ1V0R0s5c0RVMkVvRWxuazBHTkIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA1MDQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBWlAwNzAwMDAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82NWFaREpRd05sbFB4dUxQaXhKNFlPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNjVhWkRKUXdObGxQeHVMUGl4SjRZTyIsImlkIjoiNjVhWkRKUXdObGxQeHVMUGl4SjRZTyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGYWtlIEVtcGlyZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2NWFaREpRd05sbFB4dUxQaXhKNFlPIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yY0NVdEdLOXNEVTJFb0VsbmswR05CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJpZCI6IjJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJuYW1lIjoiVGhlIE5hdGlvbmFsIiwidHlwZSI6ImFydGlzdCIsIg==", + "dXJpIjoic3BvdGlmeTphcnRpc3Q6MmNDVXRHSzlzRFUyRW9FbG5rMEdOQiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzd6b1BXMzM0Y1FOZlF5V1d0ZVR3TWoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83em9QVzMzNGNRTmZReVdXdGVUd01qIiwiaWQiOiI3em9QVzMzNGNRTmZReVdXdGVUd01qIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2UwNDQxODhkMGMyMzZkOGZkMmUwMmUyMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJlMDQ0MTg4ZDBjMjM2ZDhmZDJlMDJlMjAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWUwNDQxODhkMGMyMzZkOGZkMmUwMmUyMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBIFNraW4sIEEgTmlnaHQgKyBUaGUgVmlyZ2luaWEgRVAiLCJyZWxlYXNlX2RhdGUiOiIyMDA4LTA1LTE5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N3pvUFczMzRjUU5mUXlXV3RlVHdNaiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJjQ1V0R0s5c0RVMkVvRWxuazBHTkIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMmNDVXRHSzlzRFUyRW9FbG5rMEdOQiIsImlkIjoiMmNDVXRHSzlzRFUyRW9FbG5rMEdOQiIsIm5hbWUiOiJUaGUgTmF0aW9uYWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MmNDVXRHSzlzRFUyRW9FbG5rMEdOQiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzQxNDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFaUDA3MDAxMjMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBTb1IzWWQ3RER1Ym54T1JNSEJvQ2oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wU29SM1lkN0REdWJueE9STUhCb0NqIiwiaWQiOiIwU29SM1lkN0REdWJueE9STUhCb0NqIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZha2UgRW1waXJlIC0gTGl2ZSIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOg==", + "InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowU29SM1lkN0REdWJueE9STUhCb0NqIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yY0NVdEdLOXNEVTJFb0VsbmswR05CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJpZCI6IjJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJuYW1lIjoiVGhlIE5hdGlvbmFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJjQ1V0R0s5c0RVMkVvRWxuazBHTkIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xZTJ1Tk9vcFpVbEt4aU94YjVOU0NQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWUydU5Pb3BaVWxLeGlPeGI1TlNDUCIsImlkIjoiMWUydU5Pb3BaVWxLeGlPeGI1TlNDUCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4YWI1ZjljMDM2Y2RlN2YxNzUxMjkzZjAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOGFiNWY5YzAzNmNkZTdmMTc1MTI5M2YwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4YWI1ZjljMDM2Y2RlN2YxNzUxMjkzZjAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm9tZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMTAtMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFlMnVOT29wWlVsS3hpT3hiNU5TQ1AifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yY0NVdEdLOXNEVTJFb0VsbmswR05CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJpZCI6IjJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJuYW1lIjoiVGhlIE5hdGlvbmFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJjQ1V0R0s5c0RVMkVvRWxuazBHTkIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA3NzMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpcw==", + "cmMiOiJHQkFGTDI0MDA0MTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzB2NWc3MmtaczVzeUw1cVhIY3hmSHMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wdjVnNzJrWnM1c3lMNXFYSGN4ZkhzIiwiaWQiOiIwdjVnNzJrWnM1c3lMNXFYSGN4ZkhzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZha2UgRW1waXJlIC0gTGl2ZSBpbiBSb21lIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjB2NWc3MmtaczVzeUw1cVhIY3hmSHMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmNDVXRHSzlzRFUyRW9FbG5rMEdOQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yY0NVdEdLOXNEVTJFb0VsbmswR05CIiwiaWQiOiIyY0NVdEdLOXNEVTJFb0VsbmswR05CIiwibmFtZSI6IlRoZSBOYXRpb25hbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyY0NVdEdLOXNEVTJFb0VsbmswR05CIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMm5DdHdIMUs5Z3Q5c0pKUURydFZWZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJuQ3R3SDFLOWd0OXNKSlFEcnRWVmQiLCJpZCI6IjJuQ3R3SDFLOWd0OXNKSlFEcnRWVmQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjQyODlmOTVhZWU5NzFiOWMwYmFmZWVjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI0Mjg5Zjk1YWVlOTcxYjljMGJhZmVlYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjQyODlmOTVhZWU5NzFiOWMwYmFmZWVjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvbWUiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTEyLTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Mm5DdHdIMUs5Z3Q5c0pKUURydFZWZCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdA==", + "aWZ5LmNvbS9hcnRpc3QvMmNDVXRHSzlzRFUyRW9FbG5rMEdOQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yY0NVdEdLOXNEVTJFb0VsbmswR05CIiwiaWQiOiIyY0NVdEdLOXNEVTJFb0VsbmswR05CIiwibmFtZSI6IlRoZSBOYXRpb25hbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyY0NVdEdLOXNEVTJFb0VsbmswR05CIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNzczMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUZMMjQwMDQxNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMElwSk1wY3ZCR0E1cXFXMXh3cGVReSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBJcEpNcGN2QkdBNXFxVzF4d3BlUXkiLCJpZCI6IjBJcEpNcGN2QkdBNXFxVzF4d3BlUXkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmFrZSBFbXBpcmUgLSBMaXZlIGluIFJvbWUiLCJ0cmFja19udW1iZXIiOjE3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBJcEpNcGN2QkdBNXFxVzF4d3BlUXkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmNDVXRHSzlzRFUyRW9FbG5rMEdOQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yY0NVdEdLOXNEVTJFb0VsbmswR05CIiwiaWQiOiIyY0NVdEdLOXNEVTJFb0VsbmswR05CIiwibmFtZSI6IlRoZSBOYXRpb25hbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyY0NVdEdLOXNEVTJFb0VsbmswR05CIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNjJUY2ZVYzNOZVdqTEx4WE05eDZINiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzYyVGNmVWMzTmVXakxMeFhNOXg2SDYiLCJpZCI6IjYyVGNmVWMzTmVXakxMeFhNOXg2SDYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZTQ0MDQ1M2FjYmFkN2MwZDg4M2RhODZhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmU0NDA0NTNhY2JhZDdjMGQ4ODNkYTg2YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOg==", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlNDQwNDUzYWNiYWQ3YzBkODgzZGE4NmEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm9tZSAoRnVsbCBDb25jZXJ0KSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMTItMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2MlRjZlVjM05lV2pMTHhYTTl4Nkg2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmNDVXRHSzlzRFUyRW9FbG5rMEdOQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yY0NVdEdLOXNEVTJFb0VsbmswR05CIiwiaWQiOiIyY0NVdEdLOXNEVTJFb0VsbmswR05CIiwibmFtZSI6IlRoZSBOYXRpb25hbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyY0NVdEdLOXNEVTJFb0VsbmswR05CIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNzczMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUZMMjQwMDQxNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMzliNHJNdHNmanFCMHVBMldDTnlnTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzM5YjRyTXRzZmpxQjB1QTJXQ055Z08iLCJpZCI6IjM5YjRyTXRzZmpxQjB1QTJXQ055Z08iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmFrZSBFbXBpcmUgLSBMaXZlIGluIFJvbWUiLCJ0cmFja19udW1iZXIiOjIwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjM5YjRyTXRzZmpxQjB1QTJXQ055Z08ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMmNDVXRHSzlzRFUyRW9FbG5rMEdOQiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yY0NVdEdLOXNEVTJFb0VsbmswR05CIiwiaWQiOiIyY0NVdEdLOXNEVTJFb0VsbmswR05CIiwibmFtZSI6IlRoZSBOYXRpb25hbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyY0NVdEdLOXNEVTJFb0VsbmswR05CIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMnFremlNdHR5ODlWWDEzZzI3YUlGTCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdA==", + "aWZ5LmNvbS92MS9hbGJ1bXMvMnFremlNdHR5ODlWWDEzZzI3YUlGTCIsImlkIjoiMnFremlNdHR5ODlWWDEzZzI3YUlGTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwOTFmODI2ZTM1NTI1YTkyYjRkNmYxZTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMDkxZjgyNmUzNTUyNWE5MmI0ZDZmMWU4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwOTFmODI2ZTM1NTI1YTkyYjRkNmYxZTgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQm94ZXIgKExpdmUgaW4gQnJ1c3NlbHMpIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0wNy0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJxa3ppTXR0eTg5VlgxM2cyN2FJRkwifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yY0NVdEdLOXNEVTJFb0VsbmswR05CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJpZCI6IjJjQ1V0R0s5c0RVMkVvRWxuazBHTkIiLCJuYW1lIjoiVGhlIE5hdGlvbmFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJjQ1V0R0s5c0RVMkVvRWxuazBHTkIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjAxNDIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBRkwxODAwMDE0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wYXpSbWN6dno5N2tpeHFPU2NRMXZRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGF6Um1jenZ6OTdraXhxT1NjUTF2USIsImlkIjoiMGF6Um1jenZ6OTdraXhxT1NjUTF2USIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGYWtlIEVtcGlyZSAtIExpdmUgaW4gQnJ1c3NlbHMiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGF6Um1jenZ6OTdraXhxT1NjUTF2USJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Fake+Empire%22+artist%3A%22The+National%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22I%20Fall%20Apart%22%20artist%3A%22Post%20Malone%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/5s0rmjP8XOPhP6HhqOhuyC"},"href":"https://api.spotify.com/v1/albums/5s0rmjP8XOPhP6HhqOhuyC","id":"5s0rmjP8XOPhP6HhqOhuyC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27355404f712deb84d0650a4b41"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0255404f712deb84d0650a4b41"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485155404f712deb84d0650a4b41"}],"is_playable":true,"name":"Stoney (Deluxe)","release_date":"2016-12-09","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:5s0rmjP8XOPhP6HhqOhuyC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"disc_number":1,"duration_ms":223346,"explicit":true,"external_ids":{"isrc":"USUM71614475"},"external_urls":{"spotify":"https://open.spotify.com/track/75ZvA4QfFiZvzhj2xkaWAh"},"href":"https://api.spotify.com/v1/tracks/75ZvA4QfFiZvzhj2xkaWAh","id":"75ZvA4QfFiZvzhj2xkaWAh","is_local":false,"is_playable":true,"name":"I Fall Apart","track_number":7,"type":"track","uri":"spotify:track:75ZvA4QfFiZvzhj2xkaWAh"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/2TbtBmA00IP0P1GpUqIaXS"},"href":"https://api.spotify.com/v1/albums/2TbtBmA00IP0P1GpUqIaXS","id":"2TbtBmA00IP0P1GpUqIaXS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273894a761abf954838a84c8db9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02894a761abf954838a84c8db9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851894a761abf954838a84c8db9"}],"is_playable":true,"name":"Stoney (Deluxe)","release_date":"2016-12-09","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:2TbtBmA00IP0P1GpUqIaXS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"disc_number":1,"duration_ms":223346,"explicit":false,"external_ids":{"isrc":"USUM71614476"},"external_urls":{"spotify":"https://open.spotify.com/track/0ClXCMqM8JPf6RkW0lR73g"},"href":"https://api.spotify.com/v1/tracks/0ClXCMqM8JPf6RkW0lR73g","id":"0ClXCMqM8JPf6RkW0lR73g","is_local":false,"is_playable":true,"name":"I Fall Apart","track_number":7,"type":"track","uri":"spotify:track:0ClXCMqM8JPf6RkW0lR73g"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/3zAcZrky4QNM28YS0tHSYQ"},"href":"https://api.spotify.com/v1/albums/3zAcZrky4QNM28YS0tHSYQ","id":"3zAcZrky4QNM28YS0tHSYQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273555365f6d2da5f78f1f66b3b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02555365f6d2da5f78f1f66b3b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851555365f6d2da5f78f1f66b3b"}],"is_playable":true,"name":"Stoney","release_date":"2016-12-09","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:3zAcZrky4QNM28YS0tHSYQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"disc_number":1,"duration_ms":223346,"explicit":true,"external_ids":{"isrc":"USUM71614475"},"external_urls":{"spotify":"https://open.spotify.com/track/6bFrZX74iudanCuwP63LTX"},"href":"https://api.spotify.com/v1/tracks/6bFrZX74iudanCuwP63LTX","id":"6bFrZX74iudanCuwP63LTX","is_local":false,"is_playable":true,"name":"I Fall Apart","track_number":7,"type":"track","uri":"spotify:track:6bFrZX74iudanCuwP63LTX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/16XHoXcTPdm7CczEvLNlMP"},"href":"https://api.spotify.com/v1/albums/16XHoXcTPdm7CczEvLNlMP","id":"16XHoXcTPdm7CczEvLNlMP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734c65275edad3ab7ddb4ed230"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024c65275edad3ab7ddb4ed230"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514c65275edad3ab7ddb4ed230"}],"is_playable":true,"name":"Stoney (Complete Edition)","release_date":"2016-12-09","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:16XHoXcTPdm7CczEvLNlMP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"disc_number":1,"duration_ms":223346,"explicit":true,"external_ids":{"isrc":"USUM71614475"},"external_urls":{"spotify":"https://open.spotify.com/track/6ZdQdhzevxGJ27YQozoI9V"},"href":"https://api.spotify.com/v1/tracks/6ZdQdhzevxGJ27YQozoI9V","id":"6ZdQdhzevxGJ27YQozoI9V","is_local":false,"is_playable":true,"name":"I Fall Apart","track_number":7,"type":"track","uri":"spotify:track:6ZdQdhzevxGJ27YQozoI9V"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/0HeDKsZqyskYWkoHmXObsv"},"href":"https://api.spotify.com/v1/albums/0HeDKsZqyskYWkoHmXObsv","id":"0HeDKsZqyskYWkoHmXObsv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273891337202ac8b6fc09991b9c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02891337202ac8b6fc09991b9c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851891337202ac8b6fc09991b9c"}],"is_playable":true,"name":"The Diamond Collection (Deluxe)","release_date":"2023-04-21","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:0HeDKsZqyskYWkoHmXObsv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"disc_number":1,"duration_ms":223350,"explicit":true,"external_ids":{"isrc":"USUM71614475"},"external_urls":{"spotify":"https://open.spotify.com/track/5OIUS4S7uQAm3Adp910eEi"},"href":"https://api.spotify.com/v1/tracks/5OIUS4S7uQAm3Adp910eEi","id":"5OIUS4S7uQAm3Adp910eEi","is_local":false,"is_playable":true,"name":"I Fall Apart","track_number":3,"type":"track","uri":"spotify:track:5OIUS4S7uQAm3Adp910eEi"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/50PT458zbmJ71tLjqvjcoP"},"href":"https://api.spotify.com/v1/albums/50PT458zbmJ71tLjqvjcoP","id":"50PT458zbmJ71tLjqvjcoP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734d4196d02cf28cad7077f11c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024d4196d02cf28cad7077f11c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514d4196d02cf28cad7077f11c"}],"is_playable":true,"name":"The Diamond Collection (Deluxe)","release_date":"2023-04-21","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:50PT458zbmJ71tLjqvjcoP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"disc_number":1,"duration_ms":223350,"explicit":true,"external_ids":{"isrc":"USUM71614475"},"external_urls":{"spotify":"https://open.spotify.com/track/0PlismAOSFJn0H9Wo0xj7f"},"href":"https://api.spotify.com/v1/tracks/0PlismAOSFJn0H9Wo0xj7f","id":"0PlismAOSFJn0H9Wo0xj7f","is_local":false,"is_playable":true,"name":"I Fall Apart","track_number":3,"type":"track","uri":"spotify:track:0PlismAOSFJn0H9Wo0xj7f"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/31z2OBrrfVwrqU68ouWCwx"},"href":"https://api.spotify.com/v1/albums/31z2OBrrfVwrqU68ouWCwx","id":"31z2OBrrfVwrqU68ouWCwx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b065ada1e28a057f51545817"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b065ada1e28a057f51545817"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b065ada1e28a057f51545817"}],"is_playable":true,"name":"Stoney","release_date":"2016-12-09","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:31z2OBrrfVwrqU68ouWCwx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"disc_number":1,"duration_ms":223346,"explicit":false,"external_ids":{"isrc":"USUM71614476"},"external_urls":{"spotify":"https://open.spotify.com/track/1hU5zwjfLsaSlK4SPb6KbI"},"href":"https://api.spotify.com/v1/tracks/1hU5zwjfLsaSlK4SPb6KbI","id":"1hU5zwjfLsaSlK4SPb6KbI","is_local":false,"is_playable":true,"name":"I Fall Apart","track_number":7,"type":"track","uri":"spotify:track:1hU5zwjfLsaSlK4SPb6KbI"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2yqE49L1yCXlNYkMRZ0x5D"},"href":"https://api.spotify.com/v1/albums/2yqE49L1yCXlNYkMRZ0x5D","id":"2yqE49L1yCXlNYkMRZ0x5D","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27396b66d3535be881d630ff592"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0296b66d3535be881d630ff592"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485196b66d3535be881d630ff592"}],"is_playable":true,"name":"Break Ups To Make Ups","release_date":"2018-05-25","release_date_precision":"day","total_tracks":27,"type":"album","uri":"spotify:album:2yqE49L1yCXlNYkMRZ0x5D"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"disc_number":1,"duration_ms":224106,"explicit":true,"external_ids":{"isrc":"USUM71614475"},"external_urls":{"spotify":"https://open.spotify.com/track/6f9oASEX8dZbW85L4AX3ah"},"href":"https://api.spotify.com/v1/tracks/6f9oASEX8dZbW85L4AX3ah","id":"6f9oASEX8dZbW85L4AX3ah","is_local":false,"is_playable":true,"name":"I Fall Apart","track_number":8,"type":"track","uri":"spotify:track:6f9oASEX8dZbW85L4AX3ah"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"external_urls":{"spotify":"https://open.spotify.com/album/1nKIHlqMCuwkO19LEOHF5x"},"href":"https://api.spotify.com/v1/albums/1nKIHlqMCuwkO19LEOHF5x","id":"1nKIHlqMCuwkO19LEOHF5x","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733831590da594a5f457334528"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023831590da594a5f457334528"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513831590da594a5f457334528"}],"is_playable":true,"name":"The Diamond Collection (Deluxe)","release_date":"2023-04-21","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:1nKIHlqMCuwkO19LEOHF5x"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/246dkjvS1zLTtiykXe5h60"},"href":"https://api.spotify.com/v1/artists/246dkjvS1zLTtiykXe5h60","id":"246dkjvS1zLTtiykXe5h60","name":"Post Malone","type":"artist","uri":"spotify:artist:246dkjvS1zLTtiykXe5h60"}],"disc_number":1,"duration_ms":223350,"explicit":false,"external_ids":{"isrc":"USUM71614476"},"external_urls":{"spotify":"https://open.spotify.com/track/6XsgQ2HaII5VqKIJsnESkk"},"href":"https://api.spotify.com/v1/tracks/6XsgQ2HaII5VqKIJsnESkk","id":"6XsgQ2HaII5VqKIJsnESkk","is_local":false,"is_playable":true,"name":"I Fall Apart","track_number":3,"type":"track","uri":"spotify:track:6XsgQ2HaII5VqKIJsnESkk"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkklMjBGYWxsJTIwQXBhcnQlMjIlMjBhcnRpc3QlM0ElMjJQb3N0JTIwTWFsb25lJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjo5LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVzMHJtalA4WE9QaFA2SGhxT2h1eUMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81czBybWpQOFhPUGhQNkhocU9odXlDIiwiaWQiOiI1czBybWpQOFhPUGhQNkhocU9odXlDIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzU1NDA0ZjcxMmRlYjg0ZDA2NTBhNGI0MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1NTQwNGY3MTJkZWI4NGQwNjUwYTRiNDEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTU1NDA0ZjcxMmRlYjg0ZDA2NTBhNGI0MSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdG9uZXkgKERlbHV4ZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDE2LTEyLTA5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NXMwcm1qUDhYT1BoUDZIaHFPaHV5QyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVHRpeWtYZTVoNjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsImlkIjoiMjQ2ZGtqdg==", + "UzF6TFR0aXlrWGU1aDYwIiwibmFtZSI6IlBvc3QgTWFsb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0NmRranZTMXpMVHRpeWtYZTVoNjAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjIzMzQ2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzE2MTQ0NzUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzc1WnZBNFFmRmladnpoajJ4a2FXQWgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83NVp2QTRRZkZpWnZ6aGoyeGthV0FoIiwiaWQiOiI3NVp2QTRRZkZpWnZ6aGoyeGthV0FoIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkkgRmFsbCBBcGFydCIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3NVp2QTRRZkZpWnZ6aGoyeGthV0FoIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVHRpeWtYZTVoNjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsImlkIjoiMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsIm5hbWUiOiJQb3N0IE1hbG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDZka2p2UzF6TFR0aXlrWGU1aDYwIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlRidEJtQTAwSVAwUDFHcFVxSWFYUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJUYnRCbUEwMElQMFAxR3BVcUlhWFMiLCJpZCI6IjJUYnRCbUEwMElQMFAxR3BVcUlhWFMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODk0YTc2MWFiZjk1NDgzOGE4NGM4ZGI5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjg5NGE3NjFhYmY5NTQ4MzhhODRjOGRiOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODk0YTc2MWFiZjk1NDgzOGE4NGM4ZGI5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0b25leSAoRGVsdXhlKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTYtMTItMA==", + "OSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJUYnRCbUEwMElQMFAxR3BVcUlhWFMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjMzNDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzE2MTQ0NzYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBDbFhDTXFNOEpQZjZSa1cwbFI3M2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wQ2xYQ01xTThKUGY2UmtXMGxSNzNnIiwiaWQiOiIwQ2xYQ01xTThKUGY2UmtXMGxSNzNnIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkkgRmFsbCBBcGFydCIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowQ2xYQ01xTThKUGY2UmtXMGxSNzNnIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVHRpeWtYZTVoNjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsImlkIjoiMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsIm5hbWUiOiJQb3N0IE1hbG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDZka2p2UzF6TFR0aXlrWGU1aDYwIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM3pBY1pya3k0UU5NMjhZUzB0SFNZUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzN6QWNacmt5NFFOTTI4WVMwdEhTWVEiLCJpZCI6IjN6QWNacmt5NFFOTTI4WVMwdEhTWVEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTU1Mw==", + "NjVmNmQyZGE1Zjc4ZjFmNjZiM2IifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTU1MzY1ZjZkMmRhNWY3OGYxZjY2YjNiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1NTUzNjVmNmQyZGE1Zjc4ZjFmNjZiM2IifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3RvbmV5IiwicmVsZWFzZV9kYXRlIjoiMjAxNi0xMi0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjN6QWNacmt5NFFOTTI4WVMwdEhTWVEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjMzNDYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTYxNDQ3NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNmJGclpYNzRpdWRhbkN1d1A2M0xUWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZiRnJaWDc0aXVkYW5DdXdQNjNMVFgiLCJpZCI6IjZiRnJaWDc0aXVkYW5DdXdQNjNMVFgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSBGYWxsIEFwYXJ0IiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZiRnJaWDc0aXVkYW5DdXdQNjNMVFgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwiaWQiOiIyNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwibmFtZSI6IlBvc3QgTWFsb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0NmRranZTMXpMVA==", + "dGl5a1hlNWg2MCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzE2WEhvWGNUUGRtN0NjekV2TE5sTVAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xNlhIb1hjVFBkbTdDY3pFdkxObE1QIiwiaWQiOiIxNlhIb1hjVFBkbTdDY3pFdkxObE1QIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRjNjUyNzVlZGFkM2FiN2RkYjRlZDIzMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0YzY1Mjc1ZWRhZDNhYjdkZGI0ZWQyMzAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRjNjUyNzVlZGFkM2FiN2RkYjRlZDIzMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdG9uZXkgKENvbXBsZXRlIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAxNi0xMi0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjE2WEhvWGNUUGRtN0NjekV2TE5sTVAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjMzNDYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTYxNDQ3NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNlpkUWRoemV2eEdKMjdZUW96b0k5ViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZaZFFkaHpldnhHSjI3WVFvem9JOVYiLCJpZCI6IjZaZFFkaHpldnhHSjI3WVFvem9JOVYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSBGYWxsIEFwYXJ0IiwidHJhY2tfbnVtYmVyIjo3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZaZFFkaHpldnhHSjI3WVFvem9JOQ==", + "ViJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBIZURLc1pxeXNrWVdrb0htWE9ic3YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wSGVES3NacXlza1lXa29IbVhPYnN2IiwiaWQiOiIwSGVES3NacXlza1lXa29IbVhPYnN2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzg5MTMzNzIwMmFjOGI2ZmMwOTk5MWI5YyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4OTEzMzcyMDJhYzhiNmZjMDk5OTFiOWMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTg5MTMzNzIwMmFjOGI2ZmMwOTk5MWI5YyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgRGlhbW9uZCBDb2xsZWN0aW9uIChEZWx1eGUpIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wNC0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBIZURLc1pxeXNrWVdrb0htWE9ic3YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjMzNTAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTYxNDQ3NSJ9LA==", + "ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81T0lVUzRTN3VRQW0zQWRwOTEwZUVpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNU9JVVM0Uzd1UUFtM0FkcDkxMGVFaSIsImlkIjoiNU9JVVM0Uzd1UUFtM0FkcDkxMGVFaSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJIEZhbGwgQXBhcnQiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NU9JVVM0Uzd1UUFtM0FkcDkxMGVFaSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzUwUFQ0NTh6Ym1KNzF0TGpxdmpjb1AifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81MFBUNDU4emJtSjcxdExqcXZqY29QIiwiaWQiOiI1MFBUNDU4emJtSjcxdExqcXZqY29QIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRkNDE5NmQwMmNmMjhjYWQ3MDc3ZjExYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0ZDQxOTZkMDJjZjI4Y2FkNzA3N2YxMWMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRkNDE5NmQwMmNmMjhjYWQ3MDc3ZjExYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgRGlhbW9uZCBDb2xsZWN0aW9uIChEZWx1eGUpIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wNC0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjUwUFQ0NTh6Ym1KNzF0TGpxdmpjb1AifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZg==", + "eS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVHRpeWtYZTVoNjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsImlkIjoiMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsIm5hbWUiOiJQb3N0IE1hbG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDZka2p2UzF6TFR0aXlrWGU1aDYwIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMzM1MCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxNjE0NDc1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wUGxpc21BT1NGSm4wSDlXbzB4ajdmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMFBsaXNtQU9TRkpuMEg5V28weGo3ZiIsImlkIjoiMFBsaXNtQU9TRkpuMEg5V28weGo3ZiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJIEZhbGwgQXBhcnQiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MFBsaXNtQU9TRkpuMEg5V28weGo3ZiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJpZCI6IjI0NmRranZTMXpMVHRpeWtYZTVoNjAiLCJuYW1lIjoiUG9zdCBNYWxvbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzMxejJPQnJyZlZ3cnFVNjhvdVdDd3gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zMXoyT0JycmZWd3JxVTY4b3VXQ3d4IiwiaWQiOiIzMXoyT0JycmZWd3JxVTY4b3VXQ3d4IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2IwNjVhZGExZTI4YTA1N2Y1MTU0NTgxNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiMDY1YWRhMWUyOGEwNTdmNTE1NDU4MTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaQ==", + "bWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjA2NWFkYTFlMjhhMDU3ZjUxNTQ1ODE3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0b25leSIsInJlbGVhc2VfZGF0ZSI6IjIwMTYtMTItMDkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozMXoyT0JycmZWd3JxVTY4b3VXQ3d4In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwiaWQiOiIyNDZka2p2UzF6TFR0aXlrWGU1aDYwIiwibmFtZSI6IlBvc3QgTWFsb25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0NmRranZTMXpMVHRpeWtYZTVoNjAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjIzMzQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxNjE0NDc2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xaFU1endqZkxzYVNsSzRTUGI2S2JJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMWhVNXp3amZMc2FTbEs0U1BiNktiSSIsImlkIjoiMWhVNXp3amZMc2FTbEs0U1BiNktiSSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJIEZhbGwgQXBhcnQiLCJ0cmFja19udW1iZXIiOjcsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MWhVNXp3amZMc2FTbEs0U1BiNktiSSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yeXFFNDlMMXlDWGxOWWtNUloweDVEIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMnlxRTQ5TDF5Q1hsTllrTVJaMHg1RA==", + "IiwiaWQiOiIyeXFFNDlMMXlDWGxOWWtNUloweDVEIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzk2YjY2ZDM1MzViZTg4MWQ2MzBmZjU5MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5NmI2NmQzNTM1YmU4ODFkNjMwZmY1OTIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTk2YjY2ZDM1MzViZTg4MWQ2MzBmZjU5MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCcmVhayBVcHMgVG8gTWFrZSBVcHMiLCJyZWxlYXNlX2RhdGUiOiIyMDE4LTA1LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MnlxRTQ5TDF5Q1hsTllrTVJaMHg1RCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVHRpeWtYZTVoNjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsImlkIjoiMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsIm5hbWUiOiJQb3N0IE1hbG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDZka2p2UzF6TFR0aXlrWGU1aDYwIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyNDEwNiwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNVTTcxNjE0NDc1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82ZjlvQVNFWDhkWmJXODVMNEFYM2FoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmY5b0FTRVg4ZFpiVzg1TDRBWDNhaCIsImlkIjoiNmY5b0FTRVg4ZFpiVzg1TDRBWDNhaCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJIEZhbGwgQXBhcnQiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NmY5b0FTRVg4ZFpiVzg1TDRBWDNhaCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNDZka2p2UzF6TFR0aXlrWGU1aDYwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5Lg==", + "Y29tL3YxL2FydGlzdHMvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsImlkIjoiMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsIm5hbWUiOiJQb3N0IE1hbG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDZka2p2UzF6TFR0aXlrWGU1aDYwIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMW5LSUhscU1DdXdrTzE5TEVPSEY1eCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFuS0lIbHFNQ3V3a08xOUxFT0hGNXgiLCJpZCI6IjFuS0lIbHFNQ3V3a08xOUxFT0hGNXgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzgzMTU5MGRhNTk0YTVmNDU3MzM0NTI4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjM4MzE1OTBkYTU5NGE1ZjQ1NzMzNDUyOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzgzMTU5MGRhNTk0YTVmNDU3MzM0NTI4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBEaWFtb25kIENvbGxlY3Rpb24gKERlbHV4ZSkiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA0LTIxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MW5LSUhscU1DdXdrTzE5TEVPSEY1eCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI0NmRranZTMXpMVHRpeWtYZTVoNjAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsImlkIjoiMjQ2ZGtqdlMxekxUdGl5a1hlNWg2MCIsIm5hbWUiOiJQb3N0IE1hbG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyNDZka2p2UzF6TFR0aXlrWGU1aDYwIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMzM1MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTVU03MTYxNDQ3NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNlhzZ1EySGFJSTVWcUtJSnNuRVNrayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZYc2dRMkhhSUk1VnFLSUpzbkVTa2siLCJpZCI6IjZYc2dRMkhhSQ==", + "STVWcUtJSnNuRVNrayIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJJIEZhbGwgQXBhcnQiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NlhzZ1EySGFJSTVWcUtJSnNuRVNrayJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22I+Fall+Apart%22+artist%3A%22Post+Malone%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Sweater%20Weather%22%20artist%3A%22The%20Neighbourhood%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":7,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"external_urls":{"spotify":"https://open.spotify.com/album/4xkM0BwLM9H2IUcbYzpcBI"},"href":"https://api.spotify.com/v1/albums/4xkM0BwLM9H2IUcbYzpcBI","id":"4xkM0BwLM9H2IUcbYzpcBI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738265a736a1eb838ad5a0b921"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028265a736a1eb838ad5a0b921"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518265a736a1eb838ad5a0b921"}],"is_playable":true,"name":"I Love You.","release_date":"2013-04-22","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:4xkM0BwLM9H2IUcbYzpcBI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":240400,"explicit":false,"external_ids":{"isrc":"USSM11300080"},"external_urls":{"spotify":"https://open.spotify.com/track/2QjOHCTQ1Jl3zawyYOpxh6"},"href":"https://api.spotify.com/v1/tracks/2QjOHCTQ1Jl3zawyYOpxh6","id":"2QjOHCTQ1Jl3zawyYOpxh6","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":4,"type":"track","uri":"spotify:track:2QjOHCTQ1Jl3zawyYOpxh6"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"external_urls":{"spotify":"https://open.spotify.com/album/64uUQtKfndQguejYmA40lL"},"href":"https://api.spotify.com/v1/albums/64uUQtKfndQguejYmA40lL","id":"64uUQtKfndQguejYmA40lL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737177fb5667cdafd34b871257"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027177fb5667cdafd34b871257"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517177fb5667cdafd34b871257"}],"is_playable":true,"name":"I'm Sorry...","release_date":"2012-08-07","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:64uUQtKfndQguejYmA40lL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":240040,"explicit":false,"external_ids":{"isrc":"USSM11204647"},"external_urls":{"spotify":"https://open.spotify.com/track/4pGqFOfzvfe6avb9kbZicC"},"href":"https://api.spotify.com/v1/tracks/4pGqFOfzvfe6avb9kbZicC","id":"4pGqFOfzvfe6avb9kbZicC","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":4,"type":"track","uri":"spotify:track:4pGqFOfzvfe6avb9kbZicC"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FRfJyV85zb19tO6uiXBGl"},"href":"https://api.spotify.com/v1/artists/2FRfJyV85zb19tO6uiXBGl","id":"2FRfJyV85zb19tO6uiXBGl","name":"sped up + slowed","type":"artist","uri":"spotify:artist:2FRfJyV85zb19tO6uiXBGl"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nDM0bDRJ1Ni1sMzx7YQ0J"},"href":"https://api.spotify.com/v1/albums/6nDM0bDRJ1Ni1sMzx7YQ0J","id":"6nDM0bDRJ1Ni1sMzx7YQ0J","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b46be90f276243fdd995cf83"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b46be90f276243fdd995cf83"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b46be90f276243fdd995cf83"}],"is_playable":true,"name":"I Love You. (Sped Up)","release_date":"2013-04-22","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:6nDM0bDRJ1Ni1sMzx7YQ0J"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":218938,"explicit":false,"external_ids":{"isrc":"USSM12302374"},"external_urls":{"spotify":"https://open.spotify.com/track/5HzMZWEwP8baubqhmpjX75"},"href":"https://api.spotify.com/v1/tracks/5HzMZWEwP8baubqhmpjX75","id":"5HzMZWEwP8baubqhmpjX75","is_local":false,"is_playable":true,"name":"Sweater Weather - Sped Up","track_number":4,"type":"track","uri":"spotify:track:5HzMZWEwP8baubqhmpjX75"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2FRfJyV85zb19tO6uiXBGl"},"href":"https://api.spotify.com/v1/artists/2FRfJyV85zb19tO6uiXBGl","id":"2FRfJyV85zb19tO6uiXBGl","name":"sped up + slowed","type":"artist","uri":"spotify:artist:2FRfJyV85zb19tO6uiXBGl"}],"external_urls":{"spotify":"https://open.spotify.com/album/742rc3IvCNtvhEZIsjLfyu"},"href":"https://api.spotify.com/v1/albums/742rc3IvCNtvhEZIsjLfyu","id":"742rc3IvCNtvhEZIsjLfyu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb85ef5503fd690ed5a8497b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb85ef5503fd690ed5a8497b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb85ef5503fd690ed5a8497b"}],"is_playable":true,"name":"I Love You. (Slowed Down)","release_date":"2013-04-23","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:742rc3IvCNtvhEZIsjLfyu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":301144,"explicit":false,"external_ids":{"isrc":"USSM12302385"},"external_urls":{"spotify":"https://open.spotify.com/track/6jhzQyn6cwPHc85PE4qBp0"},"href":"https://api.spotify.com/v1/tracks/6jhzQyn6cwPHc85PE4qBp0","id":"6jhzQyn6cwPHc85PE4qBp0","is_local":false,"is_playable":true,"name":"Sweater Weather - Slowed Down","track_number":4,"type":"track","uri":"spotify:track:6jhzQyn6cwPHc85PE4qBp0"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"external_urls":{"spotify":"https://open.spotify.com/album/5n7S9xN6tYY8aGJU3kE0Va"},"href":"https://api.spotify.com/v1/albums/5n7S9xN6tYY8aGJU3kE0Va","id":"5n7S9xN6tYY8aGJU3kE0Va","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273354be6d543058b65075b9d16"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02354be6d543058b65075b9d16"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851354be6d543058b65075b9d16"}],"is_playable":true,"name":"I Love You. (10th Anniversary Edition)","release_date":"2013-04-23","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:5n7S9xN6tYY8aGJU3kE0Va"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":240400,"explicit":false,"external_ids":{"isrc":"USSM11300891"},"external_urls":{"spotify":"https://open.spotify.com/track/00xYOITpx6SEi1ntfdlA39"},"href":"https://api.spotify.com/v1/tracks/00xYOITpx6SEi1ntfdlA39","id":"00xYOITpx6SEi1ntfdlA39","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":4,"type":"track","uri":"spotify:track:00xYOITpx6SEi1ntfdlA39"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2c3LBDNnptvWquptllUuyq"},"href":"https://api.spotify.com/v1/albums/2c3LBDNnptvWquptllUuyq","id":"2c3LBDNnptvWquptllUuyq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273659ba1ce127df61286fa26e1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02659ba1ce127df61286fa26e1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851659ba1ce127df61286fa26e1"}],"is_playable":true,"name":"Spooky Halloween Hits","release_date":"2022-10-03","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:2c3LBDNnptvWquptllUuyq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":240400,"explicit":false,"external_ids":{"isrc":"USSM11300080"},"external_urls":{"spotify":"https://open.spotify.com/track/0MHJpqfSeUIt5Xtjqbzssm"},"href":"https://api.spotify.com/v1/tracks/0MHJpqfSeUIt5Xtjqbzssm","id":"0MHJpqfSeUIt5Xtjqbzssm","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":8,"type":"track","uri":"spotify:track:0MHJpqfSeUIt5Xtjqbzssm"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7gErZg7XRuXGKutHCxLALG"},"href":"https://api.spotify.com/v1/albums/7gErZg7XRuXGKutHCxLALG","id":"7gErZg7XRuXGKutHCxLALG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b1cef7956d4363f0c3254f38"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b1cef7956d4363f0c3254f38"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b1cef7956d4363f0c3254f38"}],"is_playable":true,"name":"TikTok Pop Hits 2022 | 2023","release_date":"2022-12-16","release_date_precision":"day","total_tracks":64,"type":"album","uri":"spotify:album:7gErZg7XRuXGKutHCxLALG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/77SW9BnxLY8rJ0RciFqkHh"},"href":"https://api.spotify.com/v1/artists/77SW9BnxLY8rJ0RciFqkHh","id":"77SW9BnxLY8rJ0RciFqkHh","name":"The Neighbourhood","type":"artist","uri":"spotify:artist:77SW9BnxLY8rJ0RciFqkHh"}],"disc_number":1,"duration_ms":239813,"explicit":false,"external_ids":{"isrc":"USSM11300080"},"external_urls":{"spotify":"https://open.spotify.com/track/27J4hy0p05VQd8Dr6ajGf5"},"href":"https://api.spotify.com/v1/tracks/27J4hy0p05VQd8Dr6ajGf5","id":"27J4hy0p05VQd8Dr6ajGf5","is_local":false,"is_playable":true,"name":"Sweater Weather","track_number":7,"type":"track","uri":"spotify:track:27J4hy0p05VQd8Dr6ajGf5"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN3ZWF0ZXIlMjBXZWF0aGVyJTIyJTIwYXJ0aXN0JTNBJTIyVGhlJTIwTmVpZ2hib3VyaG9vZCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N1NXOUJueExZOHJKMFJjaUZxa0hoIiwiaWQiOiI3N1NXOUJueExZOHJKMFJjaUZxa0hoIiwibmFtZSI6IlRoZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80eGtNMEJ3TE05SDJJVWNiWXpwY0JJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNHhrTTBCd0xNOUgySVVjYll6cGNCSSIsImlkIjoiNHhrTTBCd0xNOUgySVVjYll6cGNCSSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6", + "Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4MjY1YTczNmExZWI4MzhhZDVhMGI5MjEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyODI2NWE3MzZhMWViODM4YWQ1YTBiOTIxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4MjY1YTczNmExZWI4MzhhZDVhMGI5MjEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSBMb3ZlIFlvdS4iLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTA0LTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NHhrTTBCd0xNOUgySVVjYll6cGNCSSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaGUgTmVpZ2hib3VyaG9vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N1NXOUJueExZOHJKMFJjaUZxa0hoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMTMwMDA4MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMlFqT0hDVFExSmwzemF3eVlPcHhoNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJRak9IQ1RRMUpsM3phd3lZT3B4aDYiLCJpZCI6IjJRak9IQ1RRMUpsM3phd3lZT3B4aDYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3dlYXRlciBXZWF0aGVyIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJRak9IQ1RRMUpsM3phd3lZT3B4aDYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaA==", + "ZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82NHVVUXRLZm5kUWd1ZWpZbUE0MGxMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjR1VVF0S2ZuZFFndWVqWW1BNDBsTCIsImlkIjoiNjR1VVF0S2ZuZFFndWVqWW1BNDBsTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM3MTc3ZmI1NjY3Y2RhZmQzNGI4NzEyNTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzE3N2ZiNTY2N2NkYWZkMzRiODcxMjU3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3MTc3ZmI1NjY3Y2RhZmQzNGI4NzEyNTcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSdtIFNvcnJ5Li4uIiwicmVsZWFzZV9kYXRlIjoiMjAxMi0wOC0wNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NjR1VVF0S2ZuZFFndWVqWW1BNDBsTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaGUgTmVpZ2hib3VyaG9vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N1NXOUJueExZOHJKMFJjaUZxa0hoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDA0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMTIwNDY0NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNHBHcUZPZnp2ZmU2YXZiOWtiWmljQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRwR3FGT2Z6dmZlNmF2YjlrYlppY0MiLCJpZCI6IjRwR3FGT2Z6dmZlNmF2YjlrYlppY0MiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3dlYXRlciBXZWF0aGVyIiwidHJhY2tfbnVtYg==", + "ZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NHBHcUZPZnp2ZmU2YXZiOWtiWmljQyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRlJmSnlWODV6YjE5dE82dWlYQkdsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJGUmZKeVY4NXpiMTl0TzZ1aVhCR2wiLCJpZCI6IjJGUmZKeVY4NXpiMTl0TzZ1aVhCR2wiLCJuYW1lIjoic3BlZCB1cCArIHNsb3dlZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRlJmSnlWODV6YjE5dE82dWlYQkdsIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNm5ETTBiRFJKMU5pMXNNeng3WVEwSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZuRE0wYkRSSjFOaTFzTXp4N1lRMEoiLCJpZCI6IjZuRE0wYkRSSjFOaTFzTXp4N1lRMEoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjQ2YmU5MGYyNzYyNDNmZGQ5OTVjZjgzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmI0NmJlOTBmMjc2MjQzZmRkOTk1Y2Y4MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjQ2YmU5MGYyNzYyNDNmZGQ5OTVjZjgzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkkgTG92ZSBZb3UuIChTcGVkIFVwKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDQtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2bkRNMGJEUkoxTmkxc016eDdZUTBKIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N1NXOUJueExZOHJKMFJjaUZxa0hoIiwiaWQiOiI3N1NXOUJueExZOHJKMFJjaUZxa0hoIiwibmFtZSI6IlRoZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjE4OQ==", + "MzgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTIzMDIzNzQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVIek1aV0V3UDhiYXVicWhtcGpYNzUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81SHpNWldFd1A4YmF1YnFobXBqWDc1IiwiaWQiOiI1SHpNWldFd1A4YmF1YnFobXBqWDc1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN3ZWF0ZXIgV2VhdGhlciAtIFNwZWQgVXAiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUh6TVpXRXdQOGJhdWJxaG1walg3NSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yRlJmSnlWODV6YjE5dE82dWlYQkdsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJGUmZKeVY4NXpiMTl0TzZ1aVhCR2wiLCJpZCI6IjJGUmZKeVY4NXpiMTl0TzZ1aVhCR2wiLCJuYW1lIjoic3BlZCB1cCArIHNsb3dlZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyRlJmSnlWODV6YjE5dE82dWlYQkdsIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzQycmMzSXZDTnR2aEVaSXNqTGZ5dSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc0MnJjM0l2Q050dmhFWklzakxmeXUiLCJpZCI6Ijc0MnJjM0l2Q050dmhFWklzakxmeXUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmI4NWVmNTUwM2ZkNjkwZWQ1YTg0OTdiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZiODVlZjU1MDNmZDY5MGVkNWE4NDk3YiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmI4NWVmNTUwM2ZkNjkwZWQ1YTg0OTdiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkkgTG92ZSBZb3UuIChTbG93ZWQgRG93bikiLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTA0LTIzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzQycmMzSXZDTnR2aEVaSXNqTA==", + "Znl1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N1NXOUJueExZOHJKMFJjaUZxa0hoIiwiaWQiOiI3N1NXOUJueExZOHJKMFJjaUZxa0hoIiwibmFtZSI6IlRoZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzAxMTQ0LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTEyMzAyMzg1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82amh6UXluNmN3UEhjODVQRTRxQnAwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNmpoelF5bjZjd1BIYzg1UEU0cUJwMCIsImlkIjoiNmpoelF5bjZjd1BIYzg1UEU0cUJwMCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTd2VhdGVyIFdlYXRoZXIgLSBTbG93ZWQgRG93biIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2amh6UXluNmN3UEhjODVQRTRxQnAwIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaGUgTmVpZ2hib3VyaG9vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N1NXOUJueExZOHJKMFJjaUZxa0hoIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNW43Uzl4TjZ0WVk4YUdKVTNrRTBWYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVuN1M5eE42dFlZOGFHSlUza0UwVmEiLCJpZCI6IjVuN1M5eE42dFlZOGFHSlUza0UwVmEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzU0YmU2ZDU0MzA1OGI2NTA3NWI5ZDE2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZw==", + "ZS9hYjY3NjE2ZDAwMDAxZTAyMzU0YmU2ZDU0MzA1OGI2NTA3NWI5ZDE2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzNTRiZTZkNTQzMDU4YjY1MDc1YjlkMTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSBMb3ZlIFlvdS4gKDEwdGggQW5uaXZlcnNhcnkgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTA0LTIzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NW43Uzl4TjZ0WVk4YUdKVTNrRTBWYSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lzc3U1c5Qm54TFk4ckowUmNpRnFrSGgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsImlkIjoiNzdTVzlCbnhMWThySjBSY2lGcWtIaCIsIm5hbWUiOiJUaGUgTmVpZ2hib3VyaG9vZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3N1NXOUJueExZOHJKMFJjaUZxa0hoIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MDQwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMTMwMDg5MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMDB4WU9JVHB4NlNFaTFudGZkbEEzOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzAweFlPSVRweDZTRWkxbnRmZGxBMzkiLCJpZCI6IjAweFlPSVRweDZTRWkxbnRmZGxBMzkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3dlYXRlciBXZWF0aGVyIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjAweFlPSVRweDZTRWkxbnRmZGxBMzkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cg==", + "bHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yYzNMQkRObnB0dldxdXB0bGxVdXlxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMmMzTEJETm5wdHZXcXVwdGxsVXV5cSIsImlkIjoiMmMzTEJETm5wdHZXcXVwdGxsVXV5cSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2NTliYTFjZTEyN2RmNjEyODZmYTI2ZTEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNjU5YmExY2UxMjdkZjYxMjg2ZmEyNmUxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2NTliYTFjZTEyN2RmNjEyODZmYTI2ZTEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3Bvb2t5IEhhbGxvd2VlbiBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0xMC0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjM0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJjM0xCRE5ucHR2V3F1cHRsbFV1eXEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83N1NXOUJueExZOHJKMFJjaUZxa0hoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzc3U1c5Qm54TFk4ckowUmNpRnFrSGgiLCJpZCI6Ijc3U1c5Qm54TFk4ckowUmNpRnFrSGgiLCJuYW1lIjoiVGhlIE5laWdoYm91cmhvb2QiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDA0MDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1NNMTEzMDAwODAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBNSEpwcWZTZVVJdDVYdGpxYnpzc20ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wTUhKcHFmU2VVSXQ1WHRqcWJ6c3NtIiwiaWQiOiIwTUhKcHFmU2VVSXQ1WHRqcWJ6c3NtIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN3ZWF0ZXIgV2VhdGhlciIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowTUhKcHFmU2VVSXQ1WHRqcWJ6c3NtIn0seyJhbGJ1bSI6eyJhbGJ1bQ==", + "X3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN2dFclpnN1hSdVhHS3V0SEN4TEFMRyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdnRXJaZzdYUnVYR0t1dEhDeExBTEciLCJpZCI6IjdnRXJaZzdYUnVYR0t1dEhDeExBTEciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjFjZWY3OTU2ZDQzNjNmMGMzMjU0ZjM4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmIxY2VmNzk1NmQ0MzYzZjBjMzI1NGYzOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYjFjZWY3OTU2ZDQzNjNmMGMzMjU0ZjM4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRpa1RvayBQb3AgSGl0cyAyMDIyIHwgMjAyMyIsInJlbGVhc2VfZGF0ZSI6IjIwMjItMTItMTYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3Z0VyWmc3WFJ1WEdLdXRIQ3hMQUxHIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzdTVzlCbnhMWThySjBSY2lGcWtIaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83N1NXOUJueExZOHJKMFJjaUZxa0hoIiwiaWQiOiI3N1NXOUJueExZOHJKMFJjaUZxa0hoIiwibmFtZSI6IlRoZSBOZWlnaGJvdXJob29kIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Ojc3U1c5Qm54TFk4ckowUmNpRnFrSGgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjM5ODEzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTTTExMzAwMDgwIn0sImV4dGVybmFsX3VybA==", + "cyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzI3SjRoeTBwMDVWUWQ4RHI2YWpHZjUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yN0o0aHkwcDA1VlFkOERyNmFqR2Y1IiwiaWQiOiIyN0o0aHkwcDA1VlFkOERyNmFqR2Y1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN3ZWF0ZXIgV2VhdGhlciIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyN0o0aHkwcDA1VlFkOERyNmFqR2Y1In1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Sweater+Weather%22+artist%3A%22The+Neighbourhood%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Coffee%22%20artist%3A%22beabadoobee%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"external_urls":{"spotify":"https://open.spotify.com/album/5wQU9QESgj4rLyLECGTJGn"},"href":"https://api.spotify.com/v1/albums/5wQU9QESgj4rLyLECGTJGn","id":"5wQU9QESgj4rLyLECGTJGn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad2c1e1bcbc8d7415636691b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad2c1e1bcbc8d7415636691b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad2c1e1bcbc8d7415636691b"}],"is_playable":true,"name":"Coffee","release_date":"2017-11-04","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5wQU9QESgj4rLyLECGTJGn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":126824,"explicit":false,"external_ids":{"isrc":"GBK3W1800819"},"external_urls":{"spotify":"https://open.spotify.com/track/429NtPmr12aypzFH3FkN9l"},"href":"https://api.spotify.com/v1/tracks/429NtPmr12aypzFH3FkN9l","id":"429NtPmr12aypzFH3FkN9l","is_local":false,"is_playable":true,"name":"Coffee","track_number":1,"type":"track","uri":"spotify:track:429NtPmr12aypzFH3FkN9l"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2p9gK2BcdrloHNJwarc9gc"},"href":"https://api.spotify.com/v1/albums/2p9gK2BcdrloHNJwarc9gc","id":"2p9gK2BcdrloHNJwarc9gc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bf01fd0986a195d485922167"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bf01fd0986a195d485922167"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bf01fd0986a195d485922167"}],"is_playable":true,"name":"death bed (coffee for your head)","release_date":"2020-02-08","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2p9gK2BcdrloHNJwarc9gc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/7eJMfftS33KTjuF7lTsMCx"},"href":"https://api.spotify.com/v1/tracks/7eJMfftS33KTjuF7lTsMCx","id":"7eJMfftS33KTjuF7lTsMCx","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":1,"type":"track","uri":"spotify:track:7eJMfftS33KTjuF7lTsMCx"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"}],"external_urls":{"spotify":"https://open.spotify.com/album/4VUCwdM2v9WfRR8mwZuVq4"},"href":"https://api.spotify.com/v1/albums/4VUCwdM2v9WfRR8mwZuVq4","id":"4VUCwdM2v9WfRR8mwZuVq4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739549aab58d86eb39fe930f43"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029549aab58d86eb39fe930f43"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519549aab58d86eb39fe930f43"}],"is_playable":true,"name":"poems of the past","release_date":"2020-05-29","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:4VUCwdM2v9WfRR8mwZuVq4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/5TEH4r5OBFcKZJBjF4qOxL"},"href":"https://api.spotify.com/v1/tracks/5TEH4r5OBFcKZJBjF4qOxL","id":"5TEH4r5OBFcKZJBjF4qOxL","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":1,"type":"track","uri":"spotify:track:5TEH4r5OBFcKZJBjF4qOxL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"external_urls":{"spotify":"https://open.spotify.com/album/4qcEea4YvyhdKxCgqFWg8S"},"href":"https://api.spotify.com/v1/albums/4qcEea4YvyhdKxCgqFWg8S","id":"4qcEea4YvyhdKxCgqFWg8S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731cbe99d74667bc5bcfa5bf7a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021cbe99d74667bc5bcfa5bf7a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511cbe99d74667bc5bcfa5bf7a"}],"is_playable":true,"name":"Live in LA","release_date":"2023-12-06","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4qcEea4YvyhdKxCgqFWg8S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":133686,"explicit":false,"external_ids":{"isrc":"GBK3W2302871"},"external_urls":{"spotify":"https://open.spotify.com/track/1oYIt1Ds4pfFxha3ujD4AI"},"href":"https://api.spotify.com/v1/tracks/1oYIt1Ds4pfFxha3ujD4AI","id":"1oYIt1Ds4pfFxha3ujD4AI","is_local":false,"is_playable":true,"name":"Coffee (Live in LA)","track_number":20,"type":"track","uri":"spotify:track:1oYIt1Ds4pfFxha3ujD4AI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"external_urls":{"spotify":"https://open.spotify.com/album/15WgupwZANjowvpazNIvf0"},"href":"https://api.spotify.com/v1/albums/15WgupwZANjowvpazNIvf0","id":"15WgupwZANjowvpazNIvf0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c34229f87c7f43126c623d7b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c34229f87c7f43126c623d7b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c34229f87c7f43126c623d7b"}],"is_playable":true,"name":"Live in London","release_date":"2023-09-29","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:15WgupwZANjowvpazNIvf0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":207629,"explicit":true,"external_ids":{"isrc":"GBK3W2302782"},"external_urls":{"spotify":"https://open.spotify.com/track/1bmRAbf103jkG8O31kARzp"},"href":"https://api.spotify.com/v1/tracks/1bmRAbf103jkG8O31kARzp","id":"1bmRAbf103jkG8O31kARzp","is_local":false,"is_playable":true,"name":"Coffee (Live in London)","track_number":20,"type":"track","uri":"spotify:track:1bmRAbf103jkG8O31kARzp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5CduLXvJDQbFtlDyjzMGuz"},"href":"https://api.spotify.com/v1/albums/5CduLXvJDQbFtlDyjzMGuz","id":"5CduLXvJDQbFtlDyjzMGuz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273847d45f324b48959fb14c23a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02847d45f324b48959fb14c23a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851847d45f324b48959fb14c23a"}],"is_playable":true,"name":"Sad Bops","release_date":"2022-03-23","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:5CduLXvJDQbFtlDyjzMGuz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/6yezS44bP3czDMBwt53L6d"},"href":"https://api.spotify.com/v1/tracks/6yezS44bP3czDMBwt53L6d","id":"6yezS44bP3czDMBwt53L6d","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":2,"type":"track","uri":"spotify:track:6yezS44bP3czDMBwt53L6d"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"}],"external_urls":{"spotify":"https://open.spotify.com/album/5pAEEkvjNXOVFUazjKJgps"},"href":"https://api.spotify.com/v1/albums/5pAEEkvjNXOVFUazjKJgps","id":"5pAEEkvjNXOVFUazjKJgps","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273553c99143b9d685c5a88c716"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02553c99143b9d685c5a88c716"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851553c99143b9d685c5a88c716"}],"is_playable":true,"name":"poems of the past","release_date":"2020-05-29","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:5pAEEkvjNXOVFUazjKJgps"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/29inEgNVWMPjxsnZiTbwVe"},"href":"https://api.spotify.com/v1/tracks/29inEgNVWMPjxsnZiTbwVe","id":"29inEgNVWMPjxsnZiTbwVe","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":1,"type":"track","uri":"spotify:track:29inEgNVWMPjxsnZiTbwVe"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QHcMgHxTM4vNdhyK6MmaU"},"href":"https://api.spotify.com/v1/albums/3QHcMgHxTM4vNdhyK6MmaU","id":"3QHcMgHxTM4vNdhyK6MmaU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273278cff111ee817e32ac889e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02278cff111ee817e32ac889e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851278cff111ee817e32ac889e7"}],"is_playable":true,"name":"Hip-Hop das Antigas - de 2000 at\u00e9 2010","release_date":"2024-12-22","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:3QHcMgHxTM4vNdhyK6MmaU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/4D3qbcq1ezK9a0hkDJVMNp"},"href":"https://api.spotify.com/v1/tracks/4D3qbcq1ezK9a0hkDJVMNp","id":"4D3qbcq1ezK9a0hkDJVMNp","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":33,"type":"track","uri":"spotify:track:4D3qbcq1ezK9a0hkDJVMNp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6PcCKMhDp6fLkt3yCl2DBD"},"href":"https://api.spotify.com/v1/albums/6PcCKMhDp6fLkt3yCl2DBD","id":"6PcCKMhDp6fLkt3yCl2DBD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731ce98afb4205edde33110472"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021ce98afb4205edde33110472"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511ce98afb4205edde33110472"}],"is_playable":true,"name":"Break Up Vibes 2022","release_date":"2022-03-23","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:6PcCKMhDp6fLkt3yCl2DBD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/3WiCMPvtItBbhABSKCQtua"},"href":"https://api.spotify.com/v1/tracks/3WiCMPvtItBbhABSKCQtua","id":"3WiCMPvtItBbhABSKCQtua","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":2,"type":"track","uri":"spotify:track:3WiCMPvtItBbhABSKCQtua"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Coffee%22%20artist%3A%22beabadoobee%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"external_urls":{"spotify":"https://open.spotify.com/album/5wQU9QESgj4rLyLECGTJGn"},"href":"https://api.spotify.com/v1/albums/5wQU9QESgj4rLyLECGTJGn","id":"5wQU9QESgj4rLyLECGTJGn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ad2c1e1bcbc8d7415636691b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ad2c1e1bcbc8d7415636691b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ad2c1e1bcbc8d7415636691b"}],"is_playable":true,"name":"Coffee","release_date":"2017-11-04","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5wQU9QESgj4rLyLECGTJGn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":126824,"explicit":false,"external_ids":{"isrc":"GBK3W1800819"},"external_urls":{"spotify":"https://open.spotify.com/track/429NtPmr12aypzFH3FkN9l"},"href":"https://api.spotify.com/v1/tracks/429NtPmr12aypzFH3FkN9l","id":"429NtPmr12aypzFH3FkN9l","is_local":false,"is_playable":true,"name":"Coffee","track_number":1,"type":"track","uri":"spotify:track:429NtPmr12aypzFH3FkN9l"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2p9gK2BcdrloHNJwarc9gc"},"href":"https://api.spotify.com/v1/albums/2p9gK2BcdrloHNJwarc9gc","id":"2p9gK2BcdrloHNJwarc9gc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bf01fd0986a195d485922167"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bf01fd0986a195d485922167"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bf01fd0986a195d485922167"}],"is_playable":true,"name":"death bed (coffee for your head)","release_date":"2020-02-08","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2p9gK2BcdrloHNJwarc9gc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/7eJMfftS33KTjuF7lTsMCx"},"href":"https://api.spotify.com/v1/tracks/7eJMfftS33KTjuF7lTsMCx","id":"7eJMfftS33KTjuF7lTsMCx","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":1,"type":"track","uri":"spotify:track:7eJMfftS33KTjuF7lTsMCx"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"}],"external_urls":{"spotify":"https://open.spotify.com/album/4VUCwdM2v9WfRR8mwZuVq4"},"href":"https://api.spotify.com/v1/albums/4VUCwdM2v9WfRR8mwZuVq4","id":"4VUCwdM2v9WfRR8mwZuVq4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739549aab58d86eb39fe930f43"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029549aab58d86eb39fe930f43"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519549aab58d86eb39fe930f43"}],"is_playable":true,"name":"poems of the past","release_date":"2020-05-29","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:4VUCwdM2v9WfRR8mwZuVq4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/5TEH4r5OBFcKZJBjF4qOxL"},"href":"https://api.spotify.com/v1/tracks/5TEH4r5OBFcKZJBjF4qOxL","id":"5TEH4r5OBFcKZJBjF4qOxL","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":1,"type":"track","uri":"spotify:track:5TEH4r5OBFcKZJBjF4qOxL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"external_urls":{"spotify":"https://open.spotify.com/album/4qcEea4YvyhdKxCgqFWg8S"},"href":"https://api.spotify.com/v1/albums/4qcEea4YvyhdKxCgqFWg8S","id":"4qcEea4YvyhdKxCgqFWg8S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731cbe99d74667bc5bcfa5bf7a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021cbe99d74667bc5bcfa5bf7a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511cbe99d74667bc5bcfa5bf7a"}],"is_playable":true,"name":"Live in LA","release_date":"2023-12-06","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:4qcEea4YvyhdKxCgqFWg8S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":133686,"explicit":false,"external_ids":{"isrc":"GBK3W2302871"},"external_urls":{"spotify":"https://open.spotify.com/track/1oYIt1Ds4pfFxha3ujD4AI"},"href":"https://api.spotify.com/v1/tracks/1oYIt1Ds4pfFxha3ujD4AI","id":"1oYIt1Ds4pfFxha3ujD4AI","is_local":false,"is_playable":true,"name":"Coffee (Live in LA)","track_number":20,"type":"track","uri":"spotify:track:1oYIt1Ds4pfFxha3ujD4AI"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"external_urls":{"spotify":"https://open.spotify.com/album/15WgupwZANjowvpazNIvf0"},"href":"https://api.spotify.com/v1/albums/15WgupwZANjowvpazNIvf0","id":"15WgupwZANjowvpazNIvf0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c34229f87c7f43126c623d7b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c34229f87c7f43126c623d7b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c34229f87c7f43126c623d7b"}],"is_playable":true,"name":"Live in London","release_date":"2023-09-29","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:15WgupwZANjowvpazNIvf0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":207629,"explicit":true,"external_ids":{"isrc":"GBK3W2302782"},"external_urls":{"spotify":"https://open.spotify.com/track/1bmRAbf103jkG8O31kARzp"},"href":"https://api.spotify.com/v1/tracks/1bmRAbf103jkG8O31kARzp","id":"1bmRAbf103jkG8O31kARzp","is_local":false,"is_playable":true,"name":"Coffee (Live in London)","track_number":20,"type":"track","uri":"spotify:track:1bmRAbf103jkG8O31kARzp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5CduLXvJDQbFtlDyjzMGuz"},"href":"https://api.spotify.com/v1/albums/5CduLXvJDQbFtlDyjzMGuz","id":"5CduLXvJDQbFtlDyjzMGuz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273847d45f324b48959fb14c23a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02847d45f324b48959fb14c23a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851847d45f324b48959fb14c23a"}],"is_playable":true,"name":"Sad Bops","release_date":"2022-03-23","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:5CduLXvJDQbFtlDyjzMGuz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/6yezS44bP3czDMBwt53L6d"},"href":"https://api.spotify.com/v1/tracks/6yezS44bP3czDMBwt53L6d","id":"6yezS44bP3czDMBwt53L6d","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":2,"type":"track","uri":"spotify:track:6yezS44bP3czDMBwt53L6d"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"}],"external_urls":{"spotify":"https://open.spotify.com/album/5pAEEkvjNXOVFUazjKJgps"},"href":"https://api.spotify.com/v1/albums/5pAEEkvjNXOVFUazjKJgps","id":"5pAEEkvjNXOVFUazjKJgps","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273553c99143b9d685c5a88c716"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02553c99143b9d685c5a88c716"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851553c99143b9d685c5a88c716"}],"is_playable":true,"name":"poems of the past","release_date":"2020-05-29","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:5pAEEkvjNXOVFUazjKJgps"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/29inEgNVWMPjxsnZiTbwVe"},"href":"https://api.spotify.com/v1/tracks/29inEgNVWMPjxsnZiTbwVe","id":"29inEgNVWMPjxsnZiTbwVe","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":1,"type":"track","uri":"spotify:track:29inEgNVWMPjxsnZiTbwVe"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QHcMgHxTM4vNdhyK6MmaU"},"href":"https://api.spotify.com/v1/albums/3QHcMgHxTM4vNdhyK6MmaU","id":"3QHcMgHxTM4vNdhyK6MmaU","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273278cff111ee817e32ac889e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02278cff111ee817e32ac889e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851278cff111ee817e32ac889e7"}],"is_playable":true,"name":"Hip-Hop das Antigas - de 2000 at\u00e9 2010","release_date":"2024-12-22","release_date_precision":"day","total_tracks":48,"type":"album","uri":"spotify:album:3QHcMgHxTM4vNdhyK6MmaU"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/4D3qbcq1ezK9a0hkDJVMNp"},"href":"https://api.spotify.com/v1/tracks/4D3qbcq1ezK9a0hkDJVMNp","id":"4D3qbcq1ezK9a0hkDJVMNp","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":33,"type":"track","uri":"spotify:track:4D3qbcq1ezK9a0hkDJVMNp"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6PcCKMhDp6fLkt3yCl2DBD"},"href":"https://api.spotify.com/v1/albums/6PcCKMhDp6fLkt3yCl2DBD","id":"6PcCKMhDp6fLkt3yCl2DBD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731ce98afb4205edde33110472"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021ce98afb4205edde33110472"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511ce98afb4205edde33110472"}],"is_playable":true,"name":"Break Up Vibes 2022","release_date":"2022-03-23","release_date_precision":"day","total_tracks":43,"type":"album","uri":"spotify:album:6PcCKMhDp6fLkt3yCl2DBD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6bmlMHgSheBauioMgKv2tn"},"href":"https://api.spotify.com/v1/artists/6bmlMHgSheBauioMgKv2tn","id":"6bmlMHgSheBauioMgKv2tn","name":"Powfu","type":"artist","uri":"spotify:artist:6bmlMHgSheBauioMgKv2tn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/35l9BRT7MXmM8bv2WDQiyB"},"href":"https://api.spotify.com/v1/artists/35l9BRT7MXmM8bv2WDQiyB","id":"35l9BRT7MXmM8bv2WDQiyB","name":"beabadoobee","type":"artist","uri":"spotify:artist:35l9BRT7MXmM8bv2WDQiyB"}],"disc_number":1,"duration_ms":173333,"explicit":false,"external_ids":{"isrc":"USSM12000925"},"external_urls":{"spotify":"https://open.spotify.com/track/3WiCMPvtItBbhABSKCQtua"},"href":"https://api.spotify.com/v1/tracks/3WiCMPvtItBbhABSKCQtua","id":"3WiCMPvtItBbhABSKCQtua","is_local":false,"is_playable":true,"name":"death bed (coffee for your head)","track_number":2,"type":"track","uri":"spotify:track:3WiCMPvtItBbhABSKCQtua"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Coffee%22+artist%3A%22beabadoobee%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNwYWNlJTIwU29uZyUyMiUyMGFydGlzdCUzQSUyMkJlYWNoJTIwSG91c2UlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU2WlRnelBCRGdlME92Q0dnTU8zT1kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSIsImlkIjoiNTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSIsIm5hbWUiOiJCZWFjaCBIb3VzZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1NlpUZ3pQQkRnZTBPdkNHZ01PM09ZIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFNrWlRTWGRQcHpUYmY2QzBtMVVLdiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRTa1pUU1hkUHB6VGJmNkMwbTFVS3YiLCJpZCI6IjRTa1pUU1hkUHB6VGJmNkMwbTFVS3YiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jbw==", + "L2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkMTQzMDIyNGQ2MzFlYWE1OTU0ZjEzYzkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZDE0MzAyMjRkNjMxZWFhNTk1NGYxM2M5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkMTQzMDIyNGQ2MzFlYWE1OTU0ZjEzYzkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRGVwcmVzc2lvbiBDaGVycnkiLCJyZWxlYXNlX2RhdGUiOiIyMDE1LTA4LTI4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0U2taVFNYZFBwelRiZjZDMG0xVUt2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81NlpUZ3pQQkRnZTBPdkNHZ01PM09ZIiwiaWQiOiI1NlpUZ3pQQkRnZTBPdkNHZ01PM09ZIiwibmFtZSI6IkJlYWNoIEhvdXNlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU2WlRnelBCRGdlME92Q0dnTU8zT1kifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzIwNDY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNTVUIxNTEyMjAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xWmdNc0E1NUdJWTdJQ2tRaDVNSUxBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMVpnTXNBNTVHSVk3SUNrUWg1TUlMQSIsImlkIjoiMVpnTXNBNTVHSVk3SUNrUWg1TUlMQSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTcGFjZSBTb25nIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFaZ01zQTU1R0lZN0lDa1FoNU1JTEEifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Space+Song%22+artist%3A%22Beach+House%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Slow%20Show%22%20artist%3A%22The%20National%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":5,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Td1c2eAXaFzU4F8QCbFbp"},"href":"https://api.spotify.com/v1/albums/3Td1c2eAXaFzU4F8QCbFbp","id":"3Td1c2eAXaFzU4F8QCbFbp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c7a2d8675f75bc64fbf137d2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c7a2d8675f75bc64fbf137d2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c7a2d8675f75bc64fbf137d2"}],"is_playable":true,"name":"Boxer","release_date":"2007-05-21","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3Td1c2eAXaFzU4F8QCbFbp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":248266,"explicit":true,"external_ids":{"isrc":"GBAZP0700008"},"external_urls":{"spotify":"https://open.spotify.com/track/3roye2IJK1EWshYzqtbFHs"},"href":"https://api.spotify.com/v1/tracks/3roye2IJK1EWshYzqtbFHs","id":"3roye2IJK1EWshYzqtbFHs","is_local":false,"is_playable":true,"name":"Slow Show","track_number":6,"type":"track","uri":"spotify:track:3roye2IJK1EWshYzqtbFHs"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2qkziMtty89VX13g27aIFL"},"href":"https://api.spotify.com/v1/albums/2qkziMtty89VX13g27aIFL","id":"2qkziMtty89VX13g27aIFL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273091f826e35525a92b4d6f1e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02091f826e35525a92b4d6f1e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851091f826e35525a92b4d6f1e8"}],"is_playable":true,"name":"Boxer (Live in Brussels)","release_date":"2018-07-13","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:2qkziMtty89VX13g27aIFL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":288573,"explicit":true,"external_ids":{"isrc":"GBAFL1800007"},"external_urls":{"spotify":"https://open.spotify.com/track/3KDIidi9rNQqUJU9tIFGwk"},"href":"https://api.spotify.com/v1/tracks/3KDIidi9rNQqUJU9tIFGwk","id":"3KDIidi9rNQqUJU9tIFGwk","is_local":false,"is_playable":true,"name":"Slow Show - Live in Brussels","track_number":6,"type":"track","uri":"spotify:track:3KDIidi9rNQqUJU9tIFGwk"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/09E7wcrEyqU2n1rnhzVT0h"},"href":"https://api.spotify.com/v1/artists/09E7wcrEyqU2n1rnhzVT0h","id":"09E7wcrEyqU2n1rnhzVT0h","name":"Jerome Kern","type":"artist","uri":"spotify:artist:09E7wcrEyqU2n1rnhzVT0h"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0KtJn1KFFyBlpq8M69QTC8"},"href":"https://api.spotify.com/v1/artists/0KtJn1KFFyBlpq8M69QTC8","id":"0KtJn1KFFyBlpq8M69QTC8","name":"John McGlinn/London Sinfonietta","type":"artist","uri":"spotify:artist:0KtJn1KFFyBlpq8M69QTC8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7MLdWFrAVzSOm150RT4KFK"},"href":"https://api.spotify.com/v1/artists/7MLdWFrAVzSOm150RT4KFK","id":"7MLdWFrAVzSOm150RT4KFK","name":"John McGlinn","type":"artist","uri":"spotify:artist:7MLdWFrAVzSOm150RT4KFK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/68kuKZp7yrgzZpoh5m6dWA"},"href":"https://api.spotify.com/v1/artists/68kuKZp7yrgzZpoh5m6dWA","id":"68kuKZp7yrgzZpoh5m6dWA","name":"London Sinfonietta","type":"artist","uri":"spotify:artist:68kuKZp7yrgzZpoh5m6dWA"}],"external_urls":{"spotify":"https://open.spotify.com/album/0coy1cSZRqkP2kCGPeHwzd"},"href":"https://api.spotify.com/v1/albums/0coy1cSZRqkP2kCGPeHwzd","id":"0coy1cSZRqkP2kCGPeHwzd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273068d32b83f14ba3af732c30d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02068d32b83f14ba3af732c30d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851068d32b83f14ba3af732c30d"}],"is_playable":true,"name":"Kern: Show Boat","release_date":"2006-08-07","release_date_precision":"day","total_tracks":54,"type":"album","uri":"spotify:album:0coy1cSZRqkP2kCGPeHwzd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/09E7wcrEyqU2n1rnhzVT0h"},"href":"https://api.spotify.com/v1/artists/09E7wcrEyqU2n1rnhzVT0h","id":"09E7wcrEyqU2n1rnhzVT0h","name":"Jerome Kern","type":"artist","uri":"spotify:artist:09E7wcrEyqU2n1rnhzVT0h"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7MLdWFrAVzSOm150RT4KFK"},"href":"https://api.spotify.com/v1/artists/7MLdWFrAVzSOm150RT4KFK","id":"7MLdWFrAVzSOm150RT4KFK","name":"John McGlinn","type":"artist","uri":"spotify:artist:7MLdWFrAVzSOm150RT4KFK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/68kuKZp7yrgzZpoh5m6dWA"},"href":"https://api.spotify.com/v1/artists/68kuKZp7yrgzZpoh5m6dWA","id":"68kuKZp7yrgzZpoh5m6dWA","name":"London Sinfonietta","type":"artist","uri":"spotify:artist:68kuKZp7yrgzZpoh5m6dWA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5LUjwmTidlIffhKkvXZo8k"},"href":"https://api.spotify.com/v1/artists/5LUjwmTidlIffhKkvXZo8k","id":"5LUjwmTidlIffhKkvXZo8k","name":"Frederica von Stade","type":"artist","uri":"spotify:artist:5LUjwmTidlIffhKkvXZo8k"}],"disc_number":3,"duration_ms":221333,"explicit":false,"external_ids":{"isrc":"GBAYC8704720"},"external_urls":{"spotify":"https://open.spotify.com/track/0Cu0RT4MbeKYSDXJfyLbzy"},"href":"https://api.spotify.com/v1/tracks/0Cu0RT4MbeKYSDXJfyLbzy","id":"0Cu0RT4MbeKYSDXJfyLbzy","is_local":false,"is_playable":true,"name":"Kern: Show Boat, Appendix: \"There Was a Sun Sinking Slowly in the West\" (Julie)","track_number":12,"type":"track","uri":"spotify:track:0Cu0RT4MbeKYSDXJfyLbzy"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/7zoPW334cQNfQyWWteTwMj"},"href":"https://api.spotify.com/v1/albums/7zoPW334cQNfQyWWteTwMj","id":"7zoPW334cQNfQyWWteTwMj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e044188d0c236d8fd2e02e20"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e044188d0c236d8fd2e02e20"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e044188d0c236d8fd2e02e20"}],"is_playable":true,"name":"A Skin, A Night + The Virginia EP","release_date":"2008-05-19","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:7zoPW334cQNfQyWWteTwMj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":255386,"explicit":false,"external_ids":{"isrc":"GBAZP0700122"},"external_urls":{"spotify":"https://open.spotify.com/track/4yAJ3PpACq284eGQCnttNW"},"href":"https://api.spotify.com/v1/tracks/4yAJ3PpACq284eGQCnttNW","id":"4yAJ3PpACq284eGQCnttNW","is_local":false,"is_playable":true,"name":"Slow Show - Live","track_number":8,"type":"track","uri":"spotify:track:4yAJ3PpACq284eGQCnttNW"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4NJhFmfw43RLBLjQvxDuRS"},"href":"https://api.spotify.com/v1/artists/4NJhFmfw43RLBLjQvxDuRS","id":"4NJhFmfw43RLBLjQvxDuRS","name":"Wolfgang Amadeus Mozart","type":"artist","uri":"spotify:artist:4NJhFmfw43RLBLjQvxDuRS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7y97mc3bZRFXzT2szRM4L4"},"href":"https://api.spotify.com/v1/artists/7y97mc3bZRFXzT2szRM4L4","id":"7y97mc3bZRFXzT2szRM4L4","name":"Fr\u00e9d\u00e9ric Chopin","type":"artist","uri":"spotify:artist:7y97mc3bZRFXzT2szRM4L4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5aIqB5nVVvmFsvSdExz408"},"href":"https://api.spotify.com/v1/artists/5aIqB5nVVvmFsvSdExz408","id":"5aIqB5nVVvmFsvSdExz408","name":"Johann Sebastian Bach","type":"artist","uri":"spotify:artist:5aIqB5nVVvmFsvSdExz408"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2wOqMjp9TyABvtHdOSOTUS"},"href":"https://api.spotify.com/v1/artists/2wOqMjp9TyABvtHdOSOTUS","id":"2wOqMjp9TyABvtHdOSOTUS","name":"Ludwig van Beethoven","type":"artist","uri":"spotify:artist:2wOqMjp9TyABvtHdOSOTUS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Uff91EOsvd99rtAupatMP"},"href":"https://api.spotify.com/v1/artists/1Uff91EOsvd99rtAupatMP","id":"1Uff91EOsvd99rtAupatMP","name":"Claude Debussy","type":"artist","uri":"spotify:artist:1Uff91EOsvd99rtAupatMP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0nJvyjVTb8sAULPYyA1bqU"},"href":"https://api.spotify.com/v1/artists/0nJvyjVTb8sAULPYyA1bqU","id":"0nJvyjVTb8sAULPYyA1bqU","name":"Aaron Copland","type":"artist","uri":"spotify:artist:0nJvyjVTb8sAULPYyA1bqU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5HGksnSVY91s4g1SOHHACw"},"href":"https://api.spotify.com/v1/artists/5HGksnSVY91s4g1SOHHACw","id":"5HGksnSVY91s4g1SOHHACw","name":"Alessandro Scarlatti","type":"artist","uri":"spotify:artist:5HGksnSVY91s4g1SOHHACw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/088fpww3Ae4U9cMZv5O6m8"},"href":"https://api.spotify.com/v1/artists/088fpww3Ae4U9cMZv5O6m8","id":"088fpww3Ae4U9cMZv5O6m8","name":"Amilcare Ponchielli","type":"artist","uri":"spotify:artist:088fpww3Ae4U9cMZv5O6m8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2D1iW3XCQlyJsSY5nXlIQm"},"href":"https://api.spotify.com/v1/artists/2D1iW3XCQlyJsSY5nXlIQm","id":"2D1iW3XCQlyJsSY5nXlIQm","name":"Andr\u00e9 Messager","type":"artist","uri":"spotify:artist:2D1iW3XCQlyJsSY5nXlIQm"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5K2RzBcPJRkr7qrYwSQdH8"},"href":"https://api.spotify.com/v1/artists/5K2RzBcPJRkr7qrYwSQdH8","id":"5K2RzBcPJRkr7qrYwSQdH8","name":"Antonio Caldara","type":"artist","uri":"spotify:artist:5K2RzBcPJRkr7qrYwSQdH8"}],"external_urls":{"spotify":"https://open.spotify.com/album/2wiDmTpRvcXqMIm962HXut"},"href":"https://api.spotify.com/v1/albums/2wiDmTpRvcXqMIm962HXut","id":"2wiDmTpRvcXqMIm962HXut","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e25ef97d2a67278bd4d5686f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e25ef97d2a67278bd4d5686f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e25ef97d2a67278bd4d5686f"}],"is_playable":true,"name":"Hymn to the Sun","release_date":"2026-07-24","release_date_precision":"day","total_tracks":108,"type":"album","uri":"spotify:album:2wiDmTpRvcXqMIm962HXut"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/09E7wcrEyqU2n1rnhzVT0h"},"href":"https://api.spotify.com/v1/artists/09E7wcrEyqU2n1rnhzVT0h","id":"09E7wcrEyqU2n1rnhzVT0h","name":"Jerome Kern","type":"artist","uri":"spotify:artist:09E7wcrEyqU2n1rnhzVT0h"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7MLdWFrAVzSOm150RT4KFK"},"href":"https://api.spotify.com/v1/artists/7MLdWFrAVzSOm150RT4KFK","id":"7MLdWFrAVzSOm150RT4KFK","name":"John McGlinn","type":"artist","uri":"spotify:artist:7MLdWFrAVzSOm150RT4KFK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/68kuKZp7yrgzZpoh5m6dWA"},"href":"https://api.spotify.com/v1/artists/68kuKZp7yrgzZpoh5m6dWA","id":"68kuKZp7yrgzZpoh5m6dWA","name":"London Sinfonietta","type":"artist","uri":"spotify:artist:68kuKZp7yrgzZpoh5m6dWA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5LUjwmTidlIffhKkvXZo8k"},"href":"https://api.spotify.com/v1/artists/5LUjwmTidlIffhKkvXZo8k","id":"5LUjwmTidlIffhKkvXZo8k","name":"Frederica von Stade","type":"artist","uri":"spotify:artist:5LUjwmTidlIffhKkvXZo8k"}],"disc_number":1,"duration_ms":221333,"explicit":false,"external_ids":{"isrc":"GBAYC8704720"},"external_urls":{"spotify":"https://open.spotify.com/track/5mGuNeeMXDmNMXpT8lvk1p"},"href":"https://api.spotify.com/v1/tracks/5mGuNeeMXDmNMXpT8lvk1p","id":"5mGuNeeMXDmNMXpT8lvk1p","is_local":false,"is_playable":true,"name":"Kern: Show Boat, Appendix: \"There Was a Sun Sinking Slowly in the West\" (Julie)","track_number":61,"type":"track","uri":"spotify:track:5mGuNeeMXDmNMXpT8lvk1p"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Slow%20Show%22%20artist%3A%22The%20National%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":5,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Td1c2eAXaFzU4F8QCbFbp"},"href":"https://api.spotify.com/v1/albums/3Td1c2eAXaFzU4F8QCbFbp","id":"3Td1c2eAXaFzU4F8QCbFbp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c7a2d8675f75bc64fbf137d2"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c7a2d8675f75bc64fbf137d2"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c7a2d8675f75bc64fbf137d2"}],"is_playable":true,"name":"Boxer","release_date":"2007-05-21","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:3Td1c2eAXaFzU4F8QCbFbp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":248266,"explicit":true,"external_ids":{"isrc":"GBAZP0700008"},"external_urls":{"spotify":"https://open.spotify.com/track/3roye2IJK1EWshYzqtbFHs"},"href":"https://api.spotify.com/v1/tracks/3roye2IJK1EWshYzqtbFHs","id":"3roye2IJK1EWshYzqtbFHs","is_local":false,"is_playable":true,"name":"Slow Show","track_number":6,"type":"track","uri":"spotify:track:3roye2IJK1EWshYzqtbFHs"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/2qkziMtty89VX13g27aIFL"},"href":"https://api.spotify.com/v1/albums/2qkziMtty89VX13g27aIFL","id":"2qkziMtty89VX13g27aIFL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273091f826e35525a92b4d6f1e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02091f826e35525a92b4d6f1e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851091f826e35525a92b4d6f1e8"}],"is_playable":true,"name":"Boxer (Live in Brussels)","release_date":"2018-07-13","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:2qkziMtty89VX13g27aIFL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":288573,"explicit":true,"external_ids":{"isrc":"GBAFL1800007"},"external_urls":{"spotify":"https://open.spotify.com/track/3KDIidi9rNQqUJU9tIFGwk"},"href":"https://api.spotify.com/v1/tracks/3KDIidi9rNQqUJU9tIFGwk","id":"3KDIidi9rNQqUJU9tIFGwk","is_local":false,"is_playable":true,"name":"Slow Show - Live in Brussels","track_number":6,"type":"track","uri":"spotify:track:3KDIidi9rNQqUJU9tIFGwk"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/09E7wcrEyqU2n1rnhzVT0h"},"href":"https://api.spotify.com/v1/artists/09E7wcrEyqU2n1rnhzVT0h","id":"09E7wcrEyqU2n1rnhzVT0h","name":"Jerome Kern","type":"artist","uri":"spotify:artist:09E7wcrEyqU2n1rnhzVT0h"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0KtJn1KFFyBlpq8M69QTC8"},"href":"https://api.spotify.com/v1/artists/0KtJn1KFFyBlpq8M69QTC8","id":"0KtJn1KFFyBlpq8M69QTC8","name":"John McGlinn/London Sinfonietta","type":"artist","uri":"spotify:artist:0KtJn1KFFyBlpq8M69QTC8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7MLdWFrAVzSOm150RT4KFK"},"href":"https://api.spotify.com/v1/artists/7MLdWFrAVzSOm150RT4KFK","id":"7MLdWFrAVzSOm150RT4KFK","name":"John McGlinn","type":"artist","uri":"spotify:artist:7MLdWFrAVzSOm150RT4KFK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/68kuKZp7yrgzZpoh5m6dWA"},"href":"https://api.spotify.com/v1/artists/68kuKZp7yrgzZpoh5m6dWA","id":"68kuKZp7yrgzZpoh5m6dWA","name":"London Sinfonietta","type":"artist","uri":"spotify:artist:68kuKZp7yrgzZpoh5m6dWA"}],"external_urls":{"spotify":"https://open.spotify.com/album/0coy1cSZRqkP2kCGPeHwzd"},"href":"https://api.spotify.com/v1/albums/0coy1cSZRqkP2kCGPeHwzd","id":"0coy1cSZRqkP2kCGPeHwzd","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273068d32b83f14ba3af732c30d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02068d32b83f14ba3af732c30d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851068d32b83f14ba3af732c30d"}],"is_playable":true,"name":"Kern: Show Boat","release_date":"2006-08-07","release_date_precision":"day","total_tracks":54,"type":"album","uri":"spotify:album:0coy1cSZRqkP2kCGPeHwzd"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/09E7wcrEyqU2n1rnhzVT0h"},"href":"https://api.spotify.com/v1/artists/09E7wcrEyqU2n1rnhzVT0h","id":"09E7wcrEyqU2n1rnhzVT0h","name":"Jerome Kern","type":"artist","uri":"spotify:artist:09E7wcrEyqU2n1rnhzVT0h"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7MLdWFrAVzSOm150RT4KFK"},"href":"https://api.spotify.com/v1/artists/7MLdWFrAVzSOm150RT4KFK","id":"7MLdWFrAVzSOm150RT4KFK","name":"John McGlinn","type":"artist","uri":"spotify:artist:7MLdWFrAVzSOm150RT4KFK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/68kuKZp7yrgzZpoh5m6dWA"},"href":"https://api.spotify.com/v1/artists/68kuKZp7yrgzZpoh5m6dWA","id":"68kuKZp7yrgzZpoh5m6dWA","name":"London Sinfonietta","type":"artist","uri":"spotify:artist:68kuKZp7yrgzZpoh5m6dWA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5LUjwmTidlIffhKkvXZo8k"},"href":"https://api.spotify.com/v1/artists/5LUjwmTidlIffhKkvXZo8k","id":"5LUjwmTidlIffhKkvXZo8k","name":"Frederica von Stade","type":"artist","uri":"spotify:artist:5LUjwmTidlIffhKkvXZo8k"}],"disc_number":3,"duration_ms":221333,"explicit":false,"external_ids":{"isrc":"GBAYC8704720"},"external_urls":{"spotify":"https://open.spotify.com/track/0Cu0RT4MbeKYSDXJfyLbzy"},"href":"https://api.spotify.com/v1/tracks/0Cu0RT4MbeKYSDXJfyLbzy","id":"0Cu0RT4MbeKYSDXJfyLbzy","is_local":false,"is_playable":true,"name":"Kern: Show Boat, Appendix: \"There Was a Sun Sinking Slowly in the West\" (Julie)","track_number":12,"type":"track","uri":"spotify:track:0Cu0RT4MbeKYSDXJfyLbzy"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"external_urls":{"spotify":"https://open.spotify.com/album/7zoPW334cQNfQyWWteTwMj"},"href":"https://api.spotify.com/v1/albums/7zoPW334cQNfQyWWteTwMj","id":"7zoPW334cQNfQyWWteTwMj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e044188d0c236d8fd2e02e20"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e044188d0c236d8fd2e02e20"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e044188d0c236d8fd2e02e20"}],"is_playable":true,"name":"A Skin, A Night + The Virginia EP","release_date":"2008-05-19","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:7zoPW334cQNfQyWWteTwMj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2cCUtGK9sDU2EoElnk0GNB"},"href":"https://api.spotify.com/v1/artists/2cCUtGK9sDU2EoElnk0GNB","id":"2cCUtGK9sDU2EoElnk0GNB","name":"The National","type":"artist","uri":"spotify:artist:2cCUtGK9sDU2EoElnk0GNB"}],"disc_number":1,"duration_ms":255386,"explicit":false,"external_ids":{"isrc":"GBAZP0700122"},"external_urls":{"spotify":"https://open.spotify.com/track/4yAJ3PpACq284eGQCnttNW"},"href":"https://api.spotify.com/v1/tracks/4yAJ3PpACq284eGQCnttNW","id":"4yAJ3PpACq284eGQCnttNW","is_local":false,"is_playable":true,"name":"Slow Show - Live","track_number":8,"type":"track","uri":"spotify:track:4yAJ3PpACq284eGQCnttNW"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4NJhFmfw43RLBLjQvxDuRS"},"href":"https://api.spotify.com/v1/artists/4NJhFmfw43RLBLjQvxDuRS","id":"4NJhFmfw43RLBLjQvxDuRS","name":"Wolfgang Amadeus Mozart","type":"artist","uri":"spotify:artist:4NJhFmfw43RLBLjQvxDuRS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7y97mc3bZRFXzT2szRM4L4"},"href":"https://api.spotify.com/v1/artists/7y97mc3bZRFXzT2szRM4L4","id":"7y97mc3bZRFXzT2szRM4L4","name":"Fr\u00e9d\u00e9ric Chopin","type":"artist","uri":"spotify:artist:7y97mc3bZRFXzT2szRM4L4"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5aIqB5nVVvmFsvSdExz408"},"href":"https://api.spotify.com/v1/artists/5aIqB5nVVvmFsvSdExz408","id":"5aIqB5nVVvmFsvSdExz408","name":"Johann Sebastian Bach","type":"artist","uri":"spotify:artist:5aIqB5nVVvmFsvSdExz408"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2wOqMjp9TyABvtHdOSOTUS"},"href":"https://api.spotify.com/v1/artists/2wOqMjp9TyABvtHdOSOTUS","id":"2wOqMjp9TyABvtHdOSOTUS","name":"Ludwig van Beethoven","type":"artist","uri":"spotify:artist:2wOqMjp9TyABvtHdOSOTUS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Uff91EOsvd99rtAupatMP"},"href":"https://api.spotify.com/v1/artists/1Uff91EOsvd99rtAupatMP","id":"1Uff91EOsvd99rtAupatMP","name":"Claude Debussy","type":"artist","uri":"spotify:artist:1Uff91EOsvd99rtAupatMP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0nJvyjVTb8sAULPYyA1bqU"},"href":"https://api.spotify.com/v1/artists/0nJvyjVTb8sAULPYyA1bqU","id":"0nJvyjVTb8sAULPYyA1bqU","name":"Aaron Copland","type":"artist","uri":"spotify:artist:0nJvyjVTb8sAULPYyA1bqU"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5HGksnSVY91s4g1SOHHACw"},"href":"https://api.spotify.com/v1/artists/5HGksnSVY91s4g1SOHHACw","id":"5HGksnSVY91s4g1SOHHACw","name":"Alessandro Scarlatti","type":"artist","uri":"spotify:artist:5HGksnSVY91s4g1SOHHACw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/088fpww3Ae4U9cMZv5O6m8"},"href":"https://api.spotify.com/v1/artists/088fpww3Ae4U9cMZv5O6m8","id":"088fpww3Ae4U9cMZv5O6m8","name":"Amilcare Ponchielli","type":"artist","uri":"spotify:artist:088fpww3Ae4U9cMZv5O6m8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2D1iW3XCQlyJsSY5nXlIQm"},"href":"https://api.spotify.com/v1/artists/2D1iW3XCQlyJsSY5nXlIQm","id":"2D1iW3XCQlyJsSY5nXlIQm","name":"Andr\u00e9 Messager","type":"artist","uri":"spotify:artist:2D1iW3XCQlyJsSY5nXlIQm"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5K2RzBcPJRkr7qrYwSQdH8"},"href":"https://api.spotify.com/v1/artists/5K2RzBcPJRkr7qrYwSQdH8","id":"5K2RzBcPJRkr7qrYwSQdH8","name":"Antonio Caldara","type":"artist","uri":"spotify:artist:5K2RzBcPJRkr7qrYwSQdH8"}],"external_urls":{"spotify":"https://open.spotify.com/album/2wiDmTpRvcXqMIm962HXut"},"href":"https://api.spotify.com/v1/albums/2wiDmTpRvcXqMIm962HXut","id":"2wiDmTpRvcXqMIm962HXut","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e25ef97d2a67278bd4d5686f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e25ef97d2a67278bd4d5686f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e25ef97d2a67278bd4d5686f"}],"is_playable":true,"name":"Hymn to the Sun","release_date":"2026-07-24","release_date_precision":"day","total_tracks":108,"type":"album","uri":"spotify:album:2wiDmTpRvcXqMIm962HXut"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/09E7wcrEyqU2n1rnhzVT0h"},"href":"https://api.spotify.com/v1/artists/09E7wcrEyqU2n1rnhzVT0h","id":"09E7wcrEyqU2n1rnhzVT0h","name":"Jerome Kern","type":"artist","uri":"spotify:artist:09E7wcrEyqU2n1rnhzVT0h"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7MLdWFrAVzSOm150RT4KFK"},"href":"https://api.spotify.com/v1/artists/7MLdWFrAVzSOm150RT4KFK","id":"7MLdWFrAVzSOm150RT4KFK","name":"John McGlinn","type":"artist","uri":"spotify:artist:7MLdWFrAVzSOm150RT4KFK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/68kuKZp7yrgzZpoh5m6dWA"},"href":"https://api.spotify.com/v1/artists/68kuKZp7yrgzZpoh5m6dWA","id":"68kuKZp7yrgzZpoh5m6dWA","name":"London Sinfonietta","type":"artist","uri":"spotify:artist:68kuKZp7yrgzZpoh5m6dWA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5LUjwmTidlIffhKkvXZo8k"},"href":"https://api.spotify.com/v1/artists/5LUjwmTidlIffhKkvXZo8k","id":"5LUjwmTidlIffhKkvXZo8k","name":"Frederica von Stade","type":"artist","uri":"spotify:artist:5LUjwmTidlIffhKkvXZo8k"}],"disc_number":1,"duration_ms":221333,"explicit":false,"external_ids":{"isrc":"GBAYC8704720"},"external_urls":{"spotify":"https://open.spotify.com/track/5mGuNeeMXDmNMXpT8lvk1p"},"href":"https://api.spotify.com/v1/tracks/5mGuNeeMXDmNMXpT8lvk1p","id":"5mGuNeeMXDmNMXpT8lvk1p","is_local":false,"is_playable":true,"name":"Kern: Show Boat, Appendix: \"There Was a Sun Sinking Slowly in the West\" (Julie)","track_number":61,"type":"track","uri":"spotify:track:5mGuNeeMXDmNMXpT8lvk1p"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Slow+Show%22+artist%3A%22The+National%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZlZWwlMjBJdCUyMEFsbCUyMEFyb3VuZCUyMiUyMGFydGlzdCUzQSUyMldhc2hlZCUyME91dCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVqdU9rSUl5MThzRnc5TDMwc3l0MVoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNWp1T2tJSXkxOHNGdzlMMzBzeXQxWiIsImlkIjoiNWp1T2tJSXkxOHNGdzlMMzBzeXQxWiIsIm5hbWUiOiJXYXNoZWQgT3V0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVqdU9rSUl5MThzRnc5TDMwc3l0MVoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xak1UUFdUSEpoc1pldjA0SWJteUNDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMWpNVFBXVEhKaHNaZXYwNElibXlDQyIsImlkIjoiMWpNVFBXVEhKaHNaZXYwNElibXlDQyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOg==", + "Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2NkNDg5NmQ1MTUxNTgxZDM1YWExZTVjMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJjZDQ4OTZkNTE1MTU4MWQzNWFhMWU1YzAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWNkNDg5NmQ1MTUxNTgxZDM1YWExZTVjMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMaWZlIG9mIExlaXN1cmUiLCJyZWxlYXNlX2RhdGUiOiIyMDA5LTA5LTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxak1UUFdUSEpoc1pldjA0SWJteUNDIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNWp1T2tJSXkxOHNGdzlMMzBzeXQxWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81anVPa0lJeTE4c0Z3OUwzMHN5dDFaIiwiaWQiOiI1anVPa0lJeTE4c0Z3OUwzMHN5dDFaIiwibmFtZSI6Ildhc2hlZCBPdXQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWp1T2tJSXkxOHNGdzlMMzBzeXQxWiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTIwODAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU01FWDA4MDAwOTkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRWMHg5MFFjTWg0Wnh3SHpFV09kdEsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80VjB4OTBRY01oNFp4d0h6RVdPZHRLIiwiaWQiOiI0VjB4OTBRY01oNFp4d0h6RVdPZHRLIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZlZWwgSXQgQWxsIEFyb3VuZCIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0VjB4OTBRY01oNFp4d0h6RVdPZHRLIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Feel+It+All+Around%22+artist%3A%22Washed+Out%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Landslide%22%20artist%3A%22Fleetwood%20Mac%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/5VIQ3VaAoRKOEpJ0fewdvo"},"href":"https://api.spotify.com/v1/albums/5VIQ3VaAoRKOEpJ0fewdvo","id":"5VIQ3VaAoRKOEpJ0fewdvo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734fb043195e8d07e72edc7226"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024fb043195e8d07e72edc7226"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514fb043195e8d07e72edc7226"}],"is_playable":true,"name":"Fleetwood Mac","release_date":"1975-07-11","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:5VIQ3VaAoRKOEpJ0fewdvo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":199493,"explicit":false,"external_ids":{"isrc":"USWB19903197"},"external_urls":{"spotify":"https://open.spotify.com/track/5ihS6UUlyQAfmp48eSkxuQ"},"href":"https://api.spotify.com/v1/tracks/5ihS6UUlyQAfmp48eSkxuQ","id":"5ihS6UUlyQAfmp48eSkxuQ","is_local":false,"is_playable":true,"name":"Landslide","track_number":8,"type":"track","uri":"spotify:track:5ihS6UUlyQAfmp48eSkxuQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/70MrKoi2AdCFBxKqeXDPHZ"},"href":"https://api.spotify.com/v1/albums/70MrKoi2AdCFBxKqeXDPHZ","id":"70MrKoi2AdCFBxKqeXDPHZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730b8de3e1eb45d3b13bdb7057"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020b8de3e1eb45d3b13bdb7057"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510b8de3e1eb45d3b13bdb7057"}],"is_playable":true,"name":"The Dance","release_date":"1997","release_date_precision":"year","total_tracks":17,"type":"album","uri":"spotify:album:70MrKoi2AdCFBxKqeXDPHZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":268200,"explicit":false,"external_ids":{"isrc":"USRE19700413"},"external_urls":{"spotify":"https://open.spotify.com/track/06h9kk12VjJ2bqcBc6IScR"},"href":"https://api.spotify.com/v1/tracks/06h9kk12VjJ2bqcBc6IScR","id":"06h9kk12VjJ2bqcBc6IScR","is_local":false,"is_playable":true,"name":"Landslide - Live at Warner Brothers Studios in Burbank, CA 5/23/97","track_number":9,"type":"track","uri":"spotify:track:06h9kk12VjJ2bqcBc6IScR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/06JqOkwwy91OxrApXclzYf"},"href":"https://api.spotify.com/v1/albums/06JqOkwwy91OxrApXclzYf","id":"06JqOkwwy91OxrApXclzYf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273470a57c2dc8710171d4783df"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02470a57c2dc8710171d4783df"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851470a57c2dc8710171d4783df"}],"is_playable":true,"name":"50 Years - Don't Stop","release_date":"2018-11-16","release_date_precision":"day","total_tracks":50,"type":"album","uri":"spotify:album:06JqOkwwy91OxrApXclzYf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":200413,"explicit":false,"external_ids":{"isrc":"USRH11802578"},"external_urls":{"spotify":"https://open.spotify.com/track/5WLyTdKPldPGy25lTpmURT"},"href":"https://api.spotify.com/v1/tracks/5WLyTdKPldPGy25lTpmURT","id":"5WLyTdKPldPGy25lTpmURT","is_local":false,"is_playable":true,"name":"Landslide - 2018 Remaster","track_number":5,"type":"track","uri":"spotify:track:5WLyTdKPldPGy25lTpmURT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/6jTUmLtY779ZNYsyugOq2q"},"href":"https://api.spotify.com/v1/albums/6jTUmLtY779ZNYsyugOq2q","id":"6jTUmLtY779ZNYsyugOq2q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273152f87dab60dcbd929169daa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02152f87dab60dcbd929169daa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851152f87dab60dcbd929169daa"}],"is_playable":true,"name":"Fleetwood Mac (2017 Remaster)","release_date":"1975-07-11","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6jTUmLtY779ZNYsyugOq2q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":199213,"explicit":false,"external_ids":{"isrc":"USRH11700078"},"external_urls":{"spotify":"https://open.spotify.com/track/7lir0j0yV5XM06AgKyAlIX"},"href":"https://api.spotify.com/v1/tracks/7lir0j0yV5XM06AgKyAlIX","id":"7lir0j0yV5XM06AgKyAlIX","is_local":false,"is_playable":true,"name":"Landslide - 2017 Remaster","track_number":8,"type":"track","uri":"spotify:track:7lir0j0yV5XM06AgKyAlIX"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/5YzOUVdLMrItgSP3lMxReH"},"href":"https://api.spotify.com/v1/albums/5YzOUVdLMrItgSP3lMxReH","id":"5YzOUVdLMrItgSP3lMxReH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27318c0cb6bcd7bfecee189242f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0218c0cb6bcd7bfecee189242f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485118c0cb6bcd7bfecee189242f"}],"is_playable":true,"name":"Greatest Hits (Deluxe Edition)","release_date":"1988-11-22","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:5YzOUVdLMrItgSP3lMxReH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":2,"duration_ms":197285,"explicit":false,"external_ids":{"isrc":"USWB22600021"},"external_urls":{"spotify":"https://open.spotify.com/track/2WcgrgzNAp64kNoOvHhof6"},"href":"https://api.spotify.com/v1/tracks/2WcgrgzNAp64kNoOvHhof6","id":"2WcgrgzNAp64kNoOvHhof6","is_local":false,"is_playable":true,"name":"Landslide","track_number":1,"type":"track","uri":"spotify:track:2WcgrgzNAp64kNoOvHhof6"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OQxaj2MqTb9nEtoTPfN4P"},"href":"https://api.spotify.com/v1/albums/0OQxaj2MqTb9nEtoTPfN4P","id":"0OQxaj2MqTb9nEtoTPfN4P","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27346c433f89c341ad1f3b9fcae"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0246c433f89c341ad1f3b9fcae"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485146c433f89c341ad1f3b9fcae"}],"is_playable":true,"name":"Fleetwood Mac (Deluxe Edition)","release_date":"1975-07-11","release_date_precision":"day","total_tracks":46,"type":"album","uri":"spotify:album:0OQxaj2MqTb9nEtoTPfN4P"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":199213,"explicit":false,"external_ids":{"isrc":"USRH11700078"},"external_urls":{"spotify":"https://open.spotify.com/track/5rlSIiIp5zmRKml0UY1Tnl"},"href":"https://api.spotify.com/v1/tracks/5rlSIiIp5zmRKml0UY1Tnl","id":"5rlSIiIp5zmRKml0UY1Tnl","is_local":false,"is_playable":true,"name":"Landslide - 2017 Remaster","track_number":8,"type":"track","uri":"spotify:track:5rlSIiIp5zmRKml0UY1Tnl"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6JawUiFBWyaC4kxIcXZ3PA"},"href":"https://api.spotify.com/v1/albums/6JawUiFBWyaC4kxIcXZ3PA","id":"6JawUiFBWyaC4kxIcXZ3PA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273513c07a344f05e25396dc208"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02513c07a344f05e25396dc208"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851513c07a344f05e25396dc208"}],"is_playable":true,"name":"Acoustic 70's","release_date":"2021-06-25","release_date_precision":"day","total_tracks":39,"type":"album","uri":"spotify:album:6JawUiFBWyaC4kxIcXZ3PA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":200413,"explicit":false,"external_ids":{"isrc":"USRH11802578"},"external_urls":{"spotify":"https://open.spotify.com/track/57uQSJFteNfAxTJpPkt89T"},"href":"https://api.spotify.com/v1/tracks/57uQSJFteNfAxTJpPkt89T","id":"57uQSJFteNfAxTJpPkt89T","is_local":false,"is_playable":true,"name":"Landslide - 2018 Remaster","track_number":1,"type":"track","uri":"spotify:track:57uQSJFteNfAxTJpPkt89T"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7v9jwgXBdJQhhX44lGiviL"},"href":"https://api.spotify.com/v1/albums/7v9jwgXBdJQhhX44lGiviL","id":"7v9jwgXBdJQhhX44lGiviL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f841f86daccc02e3e26d6add"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f841f86daccc02e3e26d6add"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f841f86daccc02e3e26d6add"}],"is_playable":true,"name":"70s Ballads","release_date":"2024-12-26","release_date_precision":"day","total_tracks":70,"type":"album","uri":"spotify:album:7v9jwgXBdJQhhX44lGiviL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/08GQAI4eElDnROBrJRGE0X"},"href":"https://api.spotify.com/v1/artists/08GQAI4eElDnROBrJRGE0X","id":"08GQAI4eElDnROBrJRGE0X","name":"Fleetwood Mac","type":"artist","uri":"spotify:artist:08GQAI4eElDnROBrJRGE0X"}],"disc_number":1,"duration_ms":200413,"explicit":false,"external_ids":{"isrc":"USRH11802578"},"external_urls":{"spotify":"https://open.spotify.com/track/4tTzDFgNL3FElpL8xDMNSW"},"href":"https://api.spotify.com/v1/tracks/4tTzDFgNL3FElpL8xDMNSW","id":"4tTzDFgNL3FElpL8xDMNSW","is_local":false,"is_playable":true,"name":"Landslide - 2018 Remaster","track_number":3,"type":"track","uri":"spotify:track:4tTzDFgNL3FElpL8xDMNSW"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkxhbmRzbGlkZSUyMiUyMGFydGlzdCUzQSUyMkZsZWV0d29vZCUyME1hYyUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVWSVEzVmFBb1JLT0VwSjBmZXdkdm8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81VklRM1ZhQW9SS09FcEowZmV3ZHZvIiwiaWQiOiI1VklRM1ZhQW9SS09FcEowZmV3ZHZvIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4u", + "Y28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRmYjA0MzE5NWU4ZDA3ZTcyZWRjNzIyNiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0ZmIwNDMxOTVlOGQwN2U3MmVkYzcyMjYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRmYjA0MzE5NWU4ZDA3ZTcyZWRjNzIyNiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwicmVsZWFzZV9kYXRlIjoiMTk3NS0wNy0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVWSVEzVmFBb1JLT0VwSjBmZXdkdm8ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5OTQ5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTV0IxOTkwMzE5NyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWloUzZVVWx5UUFmbXA0OGVTa3h1USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVpaFM2VVVseVFBZm1wNDhlU2t4dVEiLCJpZCI6IjVpaFM2VVVseVFBZm1wNDhlU2t4dVEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGFuZHNsaWRlIiwidHJhY2tfbnVtYmVyIjo4LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVpaFM2VVVseVFBZm1wNDhlU2t4dVEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aQ==", + "c3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzBNcktvaTJBZENGQnhLcWVYRFBIWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzcwTXJLb2kyQWRDRkJ4S3FlWERQSFoiLCJpZCI6IjcwTXJLb2kyQWRDRkJ4S3FlWERQSFoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMGI4ZGUzZTFlYjQ1ZDNiMTNiZGI3MDU3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjBiOGRlM2UxZWI0NWQzYjEzYmRiNzA1NyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMGI4ZGUzZTFlYjQ1ZDNiMTNiZGI3MDU3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBEYW5jZSIsInJlbGVhc2VfZGF0ZSI6IjE5OTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzBNcktvaTJBZENGQnhLcWVYRFBIWiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY4MjAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSRTE5NzAwNDEzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wNmg5a2sxMlZqSjJicWNCYzZJU2NSIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDZoOWtrMTJWakoyYnFjQmM2SVNjUiIsImlkIjoiMDZoOWtrMTJWakoyYnFjQmM2SVNjUiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMYW5kc2xpZGUgLSBMaXZlIGF0IFdhcm5lciBCcm90aGVycyBTdHVkaW9zIGluIEJ1cmJhbmssIENBIDUvMjMvOTciLA==", + "InRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowNmg5a2sxMlZqSjJicWNCYzZJU2NSIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wNkpxT2t3d3k5MU94ckFwWGNsellmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDZKcU9rd3d5OTFPeHJBcFhjbHpZZiIsImlkIjoiMDZKcU9rd3d5OTFPeHJBcFhjbHpZZiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0NzBhNTdjMmRjODcxMDE3MWQ0NzgzZGYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDcwYTU3YzJkYzg3MTAxNzFkNDc4M2RmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0NzBhNTdjMmRjODcxMDE3MWQ0NzgzZGYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiNTAgWWVhcnMgLSBEb24ndCBTdG9wIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0xMS0xNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjA2SnFPa3d3eTkxT3hyQXBYY2x6WWYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpbw==", + "bl9tcyI6MjAwNDEzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDExODAyNTc4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81V0x5VGRLUGxkUEd5MjVsVHBtVVJUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNVdMeVRkS1BsZFBHeTI1bFRwbVVSVCIsImlkIjoiNVdMeVRkS1BsZFBHeTI1bFRwbVVSVCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMYW5kc2xpZGUgLSAyMDE4IFJlbWFzdGVyIiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVXTHlUZEtQbGRQR3kyNWxUcG1VUlQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZqVFVtTHRZNzc5Wk5Zc3l1Z09xMnEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82alRVbUx0WTc3OVpOWXN5dWdPcTJxIiwiaWQiOiI2alRVbUx0WTc3OVpOWXN5dWdPcTJxIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE1MmY4N2RhYjYwZGNiZDkyOTE2OWRhYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNTJmODdkYWI2MGRjYmQ5MjkxNjlkYWEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE1MmY4N2RhYjYwZGNiZDkyOTE2OWRhYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGbGVldHdvb2QgTWFjICgyMDE3IFJlbWFzdGVyKSIsInJlbGVhc2VfZGF0ZSI6IjE5NzUtMDctMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2alRVbUx0WQ==", + "Nzc5Wk5Zc3l1Z09xMnEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5OTIxMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMTcwMDA3OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2xpcjBqMHlWNVhNMDZBZ0t5QWxJWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdsaXIwajB5VjVYTTA2QWdLeUFsSVgiLCJpZCI6IjdsaXIwajB5VjVYTTA2QWdLeUFsSVgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGFuZHNsaWRlIC0gMjAxNyBSZW1hc3RlciIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3bGlyMGoweVY1WE0wNkFnS3lBbElYIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81WXpPVVZkTE1ySXRnU1AzbE14UmVIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNVl6T1VWZExNckl0Z1NQM2xNeFJlSCIsImlkIjoiNVl6T1VWZExNckl0Z1NQM2xNeFJlSCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxOGMwY2I2YmNkN2JmZWNlZTE4OTI0MmYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jbw==", + "L2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxOGMwY2I2YmNkN2JmZWNlZTE4OTI0MmYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE4YzBjYjZiY2Q3YmZlY2VlMTg5MjQyZiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHcmVhdGVzdCBIaXRzIChEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIxOTg4LTExLTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVl6T1VWZExNckl0Z1NQM2xNeFJlSCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoyLCJkdXJhdGlvbl9tcyI6MTk3Mjg1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNXQjIyNjAwMDIxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yV2Nncmd6TkFwNjRrTm9Pdkhob2Y2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMldjZ3Jnek5BcDY0a05vT3ZIaG9mNiIsImlkIjoiMldjZ3Jnek5BcDY0a05vT3ZIaG9mNiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJMYW5kc2xpZGUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MldjZ3Jnek5BcDY0a05vT3ZIaG9mNiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwcw==", + "Oi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wT1F4YWoyTXFUYjluRXRvVFBmTjRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvME9ReGFqMk1xVGI5bkV0b1RQZk40UCIsImlkIjoiME9ReGFqMk1xVGI5bkV0b1RQZk40UCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0NmM0MzNmODljMzQxYWQxZjNiOWZjYWUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNDZjNDMzZjg5YzM0MWFkMWYzYjlmY2FlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0NmM0MzNmODljMzQxYWQxZjNiOWZjYWUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmxlZXR3b29kIE1hYyAoRGVsdXhlIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMTk3NS0wNy0xMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQ2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBPUXhhajJNcVRiOW5FdG9UUGZONFAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJpZCI6IjA4R1FBSTRlRWxEblJPQnJKUkdFMFgiLCJuYW1lIjoiRmxlZXR3b29kIE1hYyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowOEdRQUk0ZUVsRG5ST0JySlJHRTBYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE5OTIxMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkgxMTcwMDA3OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNXJsU0lpSXA1em1SS21sMFVZMVRubCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVybFNJaUlwNXptUkttbDBVWTFUbmwiLCJpZCI6IjVybFNJaUlwNXptUkttbDBVWTFUbmwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGFuZHNsaWRlIC0gMjAxNyBSZW1hc3RlciIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1cmxTSWlJcDV6bVJLbWwwVVkxVG5sIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIg==", + "OiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkphd1VpRkJXeWFDNGt4SWNYWjNQQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZKYXdVaUZCV3lhQzRreEljWFozUEEiLCJpZCI6IjZKYXdVaUZCV3lhQzRreEljWFozUEEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTEzYzA3YTM0NGYwNWUyNTM5NmRjMjA4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUxM2MwN2EzNDRmMDVlMjUzOTZkYzIwOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTEzYzA3YTM0NGYwNWUyNTM5NmRjMjA4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFjb3VzdGljIDcwJ3MiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTA2LTI1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzksInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nkphd1VpRkJXeWFDNGt4SWNYWjNQQSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsImlkIjoiMDhHUUFJNGVFbERuUk9CckpSR0UwWCIsIm5hbWUiOiJGbGVldHdvb2QgTWFjIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjA4R1FBSTRlRWxEblJPQnJKUkdFMFgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjAwNDEzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNSSDExODAyNTc4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vbw==", + "cGVuLnNwb3RpZnkuY29tL3RyYWNrLzU3dVFTSkZ0ZU5mQXhUSnBQa3Q4OVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81N3VRU0pGdGVOZkF4VEpwUGt0ODlUIiwiaWQiOiI1N3VRU0pGdGVOZkF4VEpwUGt0ODlUIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxhbmRzbGlkZSAtIDIwMTggUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NTd1UVNKRnRlTmZBeFRKcFBrdDg5VCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83djlqd2dYQmRKUWhoWDQ0bEdpdmlMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3Y5andnWEJkSlFoaFg0NGxHaXZpTCIsImlkIjoiN3Y5andnWEJkSlFoaFg0NGxHaXZpTCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNmODQxZjg2ZGFjY2MwMmUzZTI2ZDZhZGQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZjg0MWY4NmRhY2NjMDJlM2UyNmQ2YWRkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFmODQxZjg2ZGFjY2MwMmUzZTI2ZDZhZGQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiNzBzIEJhbGxhZHMiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTEyLTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NzAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N3Y5andnWEJkSlFoaFg0NGxHaXZpTCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA4R1FBSTRlRWxEblJPQnJKUkdFMFgifSwiaA==", + "cmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwiaWQiOiIwOEdRQUk0ZUVsRG5ST0JySlJHRTBYIiwibmFtZSI6IkZsZWV0d29vZCBNYWMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDhHUUFJNGVFbERuUk9CckpSR0UwWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDA0MTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1JIMTE4MDI1NzgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzR0VHpERmdOTDNGRWxwTDh4RE1OU1cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80dFR6REZnTkwzRkVscEw4eERNTlNXIiwiaWQiOiI0dFR6REZnTkwzRkVscEw4eERNTlNXIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkxhbmRzbGlkZSAtIDIwMTggUmVtYXN0ZXIiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NHRUekRGZ05MM0ZFbHBMOHhETU5TVyJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Landslide%22+artist%3A%22Fleetwood+Mac%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Myth%22%20artist%3A%22Beach%20House%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/56ZTgzPBDge0OvCGgMO3OY"},"href":"https://api.spotify.com/v1/artists/56ZTgzPBDge0OvCGgMO3OY","id":"56ZTgzPBDge0OvCGgMO3OY","name":"Beach House","type":"artist","uri":"spotify:artist:56ZTgzPBDge0OvCGgMO3OY"}],"external_urls":{"spotify":"https://open.spotify.com/album/600BVck2XflTAsEo0KhIfm"},"href":"https://api.spotify.com/v1/albums/600BVck2XflTAsEo0KhIfm","id":"600BVck2XflTAsEo0KhIfm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fab2fadd4f2b3e54f8bfbc26"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fab2fadd4f2b3e54f8bfbc26"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fab2fadd4f2b3e54f8bfbc26"}],"is_playable":true,"name":"Bloom","release_date":"2012-05-14","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:600BVck2XflTAsEo0KhIfm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/56ZTgzPBDge0OvCGgMO3OY"},"href":"https://api.spotify.com/v1/artists/56ZTgzPBDge0OvCGgMO3OY","id":"56ZTgzPBDge0OvCGgMO3OY","name":"Beach House","type":"artist","uri":"spotify:artist:56ZTgzPBDge0OvCGgMO3OY"}],"disc_number":1,"duration_ms":258653,"explicit":false,"external_ids":{"isrc":"GBBRP1233401"},"external_urls":{"spotify":"https://open.spotify.com/track/2Zw3HNjaNV42LnQ2uY5JQs"},"href":"https://api.spotify.com/v1/tracks/2Zw3HNjaNV42LnQ2uY5JQs","id":"2Zw3HNjaNV42LnQ2uY5JQs","is_local":false,"is_playable":true,"name":"Myth","track_number":1,"type":"track","uri":"spotify:track:2Zw3HNjaNV42LnQ2uY5JQs"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/56ZTgzPBDge0OvCGgMO3OY"},"href":"https://api.spotify.com/v1/artists/56ZTgzPBDge0OvCGgMO3OY","id":"56ZTgzPBDge0OvCGgMO3OY","name":"Beach House","type":"artist","uri":"spotify:artist:56ZTgzPBDge0OvCGgMO3OY"}],"external_urls":{"spotify":"https://open.spotify.com/album/6nTi5SnJQXKBxrwBb4Xxva"},"href":"https://api.spotify.com/v1/albums/6nTi5SnJQXKBxrwBb4Xxva","id":"6nTi5SnJQXKBxrwBb4Xxva","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273615e6a2b2381a7da419ce2e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02615e6a2b2381a7da419ce2e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851615e6a2b2381a7da419ce2e7"}],"is_playable":true,"name":"Myth","release_date":"2012-03-26","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6nTi5SnJQXKBxrwBb4Xxva"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/56ZTgzPBDge0OvCGgMO3OY"},"href":"https://api.spotify.com/v1/artists/56ZTgzPBDge0OvCGgMO3OY","id":"56ZTgzPBDge0OvCGgMO3OY","name":"Beach House","type":"artist","uri":"spotify:artist:56ZTgzPBDge0OvCGgMO3OY"}],"disc_number":1,"duration_ms":258653,"explicit":false,"external_ids":{"isrc":"GBBRP1233401"},"external_urls":{"spotify":"https://open.spotify.com/track/4BQ3z1VjmQtqk5rweh3NpD"},"href":"https://api.spotify.com/v1/tracks/4BQ3z1VjmQtqk5rweh3NpD","id":"4BQ3z1VjmQtqk5rweh3NpD","is_local":false,"is_playable":true,"name":"Myth","track_number":1,"type":"track","uri":"spotify:track:4BQ3z1VjmQtqk5rweh3NpD"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2dVys2WKYOxwwF3id45pl5"},"href":"https://api.spotify.com/v1/albums/2dVys2WKYOxwwF3id45pl5","id":"2dVys2WKYOxwwF3id45pl5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737f43535a05f9e667ad586011"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027f43535a05f9e667ad586011"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517f43535a05f9e667ad586011"}],"is_playable":true,"name":"Festival","release_date":"2015-08-21","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:2dVys2WKYOxwwF3id45pl5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/56ZTgzPBDge0OvCGgMO3OY"},"href":"https://api.spotify.com/v1/artists/56ZTgzPBDge0OvCGgMO3OY","id":"56ZTgzPBDge0OvCGgMO3OY","name":"Beach House","type":"artist","uri":"spotify:artist:56ZTgzPBDge0OvCGgMO3OY"}],"disc_number":1,"duration_ms":254333,"explicit":false,"external_ids":{"isrc":"GBBRP1233401"},"external_urls":{"spotify":"https://open.spotify.com/track/3BXHtKq2kcl2ogcw4oKJjO"},"href":"https://api.spotify.com/v1/tracks/3BXHtKq2kcl2ogcw4oKJjO","id":"3BXHtKq2kcl2ogcw4oKJjO","is_local":false,"is_playable":true,"name":"Myth","track_number":18,"type":"track","uri":"spotify:track:3BXHtKq2kcl2ogcw4oKJjO"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4xCijbyyphcTKbjUlAbqQv"},"href":"https://api.spotify.com/v1/artists/4xCijbyyphcTKbjUlAbqQv","id":"4xCijbyyphcTKbjUlAbqQv","name":"Greek House Beach Club","type":"artist","uri":"spotify:artist:4xCijbyyphcTKbjUlAbqQv"}],"external_urls":{"spotify":"https://open.spotify.com/album/6SATrIWoh13TNHphAxMClV"},"href":"https://api.spotify.com/v1/albums/6SATrIWoh13TNHphAxMClV","id":"6SATrIWoh13TNHphAxMClV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d2296d5a6d0df75ec193d32a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d2296d5a6d0df75ec193d32a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d2296d5a6d0df75ec193d32a"}],"is_playable":true,"name":"Deep House in Greece","release_date":"2025-10-24","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6SATrIWoh13TNHphAxMClV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4xCijbyyphcTKbjUlAbqQv"},"href":"https://api.spotify.com/v1/artists/4xCijbyyphcTKbjUlAbqQv","id":"4xCijbyyphcTKbjUlAbqQv","name":"Greek House Beach Club","type":"artist","uri":"spotify:artist:4xCijbyyphcTKbjUlAbqQv"}],"disc_number":1,"duration_ms":228079,"explicit":false,"external_ids":{"isrc":"ATR981352025"},"external_urls":{"spotify":"https://open.spotify.com/track/7alKU0Z8W1K9icbXlC0fmx"},"href":"https://api.spotify.com/v1/tracks/7alKU0Z8W1K9icbXlC0fmx","id":"7alKU0Z8W1K9icbXlC0fmx","is_local":false,"is_playable":true,"name":"Mythological Frequencies","track_number":11,"type":"track","uri":"spotify:track:7alKU0Z8W1K9icbXlC0fmx"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk15dGglMjIlMjBhcnRpc3QlM0ElMjJCZWFjaCUyMEhvdXNlJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81NlpUZ3pQQkRnZTBPdkNHZ01PM09ZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU2WlRnelBCRGdlME92Q0dnTU8zT1kiLCJpZCI6IjU2WlRnelBCRGdlME92Q0dnTU8zT1kiLCJuYW1lIjoiQmVhY2ggSG91c2UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzYwMEJWY2syWGZsVEFzRW8wS2hJZm0ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82MDBCVmNrMlhmbFRBc0VvMEtoSWZtIiwiaWQiOiI2MDBCVmNrMlhmbFRBc0VvMEtoSWZtIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYQ==", + "YjY3NjE2ZDAwMDBiMjczZmFiMmZhZGQ0ZjJiM2U1NGY4YmZiYzI2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZhYjJmYWRkNGYyYjNlNTRmOGJmYmMyNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmFiMmZhZGQ0ZjJiM2U1NGY4YmZiYzI2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJsb29tIiwicmVsZWFzZV9kYXRlIjoiMjAxMi0wNS0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjYwMEJWY2syWGZsVEFzRW8wS2hJZm0ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81NlpUZ3pQQkRnZTBPdkNHZ01PM09ZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU2WlRnelBCRGdlME92Q0dnTU8zT1kiLCJpZCI6IjU2WlRnelBCRGdlME92Q0dnTU8zT1kiLCJuYW1lIjoiQmVhY2ggSG91c2UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTg2NTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkJSUDEyMzM0MDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJadzNITmphTlY0MkxuUTJ1WTVKUXMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yWnczSE5qYU5WNDJMblEydVk1SlFzIiwiaWQiOiIyWnczSE5qYU5WNDJMblEydVk1SlFzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik15dGgiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mlp3M0hOamFOVjQyTG5RMnVZNUpRcyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81NlpUZ3pQQkRnZTBPdkNHZ01PM09ZIiwiaWQiOiI1NlpUZ3pQQkRnZTBPdkNHZ01PM09ZIiwibmFtZSI6IkJlYWNoIEhvdXNlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0Og==", + "NTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZuVGk1U25KUVhLQnhyd0JiNFh4dmEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82blRpNVNuSlFYS0J4cndCYjRYeHZhIiwiaWQiOiI2blRpNVNuSlFYS0J4cndCYjRYeHZhIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzYxNWU2YTJiMjM4MWE3ZGE0MTljZTJlNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2MTVlNmEyYjIzODFhN2RhNDE5Y2UyZTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTYxNWU2YTJiMjM4MWE3ZGE0MTljZTJlNyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNeXRoIiwicmVsZWFzZV9kYXRlIjoiMjAxMi0wMy0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nm5UaTVTbkpRWEtCeHJ3QmI0WHh2YSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU2WlRnelBCRGdlME92Q0dnTU8zT1kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSIsImlkIjoiNTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSIsIm5hbWUiOiJCZWFjaCBIb3VzZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1NlpUZ3pQQkRnZTBPdkNHZ01PM09ZIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1ODY1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQlJQMTIzMzQwMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNEJRM3oxVmptUXRxazVyd2VoM05wRCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRCUTN6MVZqbVF0cWs1cndlaDNOcEQiLCJpZCI6IjRCUTN6MVZqbVF0cWs1cndlaDNOcEQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTXl0aCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0QlEzejFWam1RdHFrNXJ3ZWgzTnBEIn0seyJhbGJ1bSI6eyJhbA==", + "YnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMmRWeXMyV0tZT3h3d0YzaWQ0NXBsNSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJkVnlzMldLWU94d3dGM2lkNDVwbDUiLCJpZCI6IjJkVnlzMldLWU94d3dGM2lkNDVwbDUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczN2Y0MzUzNWEwNWY5ZTY2N2FkNTg2MDExIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjdmNDM1MzVhMDVmOWU2NjdhZDU4NjAxMSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2Y0MzUzNWEwNWY5ZTY2N2FkNTg2MDExIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZlc3RpdmFsIiwicmVsZWFzZV9kYXRlIjoiMjAxNS0wOC0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJkVnlzMldLWU94d3dGM2lkNDVwbDUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81NlpUZ3pQQkRnZTBPdkNHZ01PM09ZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU2WlRnelBCRGdlME92Q0dnTU8zT1kiLCJpZCI6IjU2WlRnelBCRGdlME92Q0dnTU8zT1kiLCJuYW1lIjoiQmVhY2ggSG91c2UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NTZaVGd6UEJEZ2UwT3ZDR2dNTzNPWSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTQzMzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkJSUDEyMzM0MDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Lw==", + "L29wZW4uc3BvdGlmeS5jb20vdHJhY2svM0JYSHRLcTJrY2wyb2djdzRvS0pqTyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNCWEh0S3Eya2NsMm9nY3c0b0tKak8iLCJpZCI6IjNCWEh0S3Eya2NsMm9nY3c0b0tKak8iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTXl0aCIsInRyYWNrX251bWJlciI6MTgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M0JYSHRLcTJrY2wyb2djdzRvS0pqTyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80eENpamJ5eXBoY1RLYmpVbEFicVF2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzR4Q2lqYnl5cGhjVEtialVsQWJxUXYiLCJpZCI6IjR4Q2lqYnl5cGhjVEtialVsQWJxUXYiLCJuYW1lIjoiR3JlZWsgSG91c2UgQmVhY2ggQ2x1YiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0eENpamJ5eXBoY1RLYmpVbEFicVF2In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNlNBVHJJV29oMTNUTkhwaEF4TUNsViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZTQVRySVdvaDEzVE5IcGhBeE1DbFYiLCJpZCI6IjZTQVRySVdvaDEzVE5IcGhBeE1DbFYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDIyOTZkNWE2ZDBkZjc1ZWMxOTNkMzJhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQyMjk2ZDVhNmQwZGY3NWVjMTkzZDMyYSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDIyOTZkNWE2ZDBkZjc1ZWMxOTNkMzJhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlZXAgSG91c2UgaW4gR3JlZWNlIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0xMC0yNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZTQVRySVdvaDEzVE5IcGhBeE1DbFYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80eENpamJ5eXBoY1RLYmpVbEFicVF2In0sImhyZWYiOiJodA==", + "dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHhDaWpieXlwaGNUS2JqVWxBYnFRdiIsImlkIjoiNHhDaWpieXlwaGNUS2JqVWxBYnFRdiIsIm5hbWUiOiJHcmVlayBIb3VzZSBCZWFjaCBDbHViIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjR4Q2lqYnl5cGhjVEtialVsQWJxUXYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI4MDc5LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiQVRSOTgxMzUyMDI1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83YWxLVTBaOFcxSzlpY2JYbEMwZm14In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2FsS1UwWjhXMUs5aWNiWGxDMGZteCIsImlkIjoiN2FsS1UwWjhXMUs5aWNiWGxDMGZteCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNeXRob2xvZ2ljYWwgRnJlcXVlbmNpZXMiLCJ0cmFja19udW1iZXIiOjExLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdhbEtVMFo4VzFLOWljYlhsQzBmbXgifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Myth%22+artist%3A%22Beach+House%22&type=track&limit=10" + } +] diff --git a/eval/fixtures/workout-energy/anthropic.json b/eval/fixtures/workout-energy/anthropic.json new file mode 100644 index 0000000..52acc8b --- /dev/null +++ b/eval/fixtures/workout-energy/anthropic.json @@ -0,0 +1,64 @@ +[ + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"query\":\"high-energy music for a heavy workout\",\"history\":[],\"prior_recommendations\":[],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"required_candidate_count\":35}"}],"model":"claude-sonnet-5","output_config":{"effort":"low","format":{"schema":{"$defs":{"CandidateOutput":{"type":"object","description":"One bounded candidate in the intent response.","title":"CandidateOutput","properties":{"title":{"type":"string","title":"Title","description":"{maxLength: 200, minLength: 1}"},"artist":{"type":"string","title":"Artist","description":"{maxLength: 200, minLength: 1}"}},"additionalProperties":false,"required":["title","artist"]},"Familiarity":{"type":"string","enum":["familiar","mix","new"],"description":"How strongly a request should favor known or unknown music.","title":"Familiarity"}},"type":"object","description":"Bounded structured output for the intent call.","title":"IntentOutput","properties":{"mood":{"type":"array","title":"Mood","items":{"type":"string"},"description":"{maxItems: 6}"},"activity":{"anyOf":[{"type":"string","description":"{maxLength: 100}"},{"type":"null"}],"title":"Activity","description":"{default: None}"},"era":{"type":"array","title":"Era","items":{"type":"string"},"description":"{maxItems: 5}"},"languages":{"type":"array","title":"Languages","items":{"type":"string"},"description":"{maxItems: 8}"},"genres":{"type":"array","title":"Genres","items":{"type":"string"},"description":"{maxItems: 8}"},"familiarity":{"$ref":"#/$defs/Familiarity"},"is_refinement":{"type":"boolean","title":"Is Refinement"},"intent_summary":{"type":"string","title":"Intent Summary","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"},"candidates":{"type":"array","title":"Candidates","items":{"$ref":"#/$defs/CandidateOutput"},"description":"{maxItems: 50, minItems: 10}"}},"additionalProperties":false,"required":["familiarity","is_refinement","intent_summary","candidates"]},"type":"json_schema"}},"system":[{"type":"text","text":"You are the intent interpreter and candidate generator for a music discovery system. Your job is to understand one listener request, use the supplied taste evidence carefully, and propose real recordings that another service can resolve against Spotify. Return only data that conforms to the provided output schema. Do not add prose before or after the structured response.\n\nInterpret the request in context. The variable input can contain a current query, a bounded conversation history, recommendations from an earlier response, and a compact taste profile. Treat the current query as authoritative. Use history only to resolve references, continuity, or explicit changes such as \"more like the third one\" or \"less energetic.\" Prior recommendations are evidence about what the listener has just seen, not proof that the listener likes every item. The Spotify taste profile is evidence of listening behavior, not a complete identity and not permission to stereotype the listener.\n\nPopulate every schema field honestly. Mood is a short bounded list of useful musical or emotional qualities. Activity is a concise listening context when one is stated or strongly implied, otherwise null. Era contains only time periods that matter to the request. Languages contains requested or strongly implied vocal languages; use an empty list when language is irrelevant or the music can be instrumental. Genres should be specific enough to guide selection without inventing a false precision. Familiarity must be familiar, mix, or new. Use familiar when the listener asks for comfort, favorites, known songs, or reliable crowd recognition. Use new when the listener asks for discovery, obscurity, unfamiliar music, or a departure from their habits. Use mix for a balanced bridge or when the request does not justify either extreme.\n\nSet is_refinement to true only when the listener is revising, narrowing, extending, or referring to an earlier recommendation result in the supplied conversation. A standalone request is not a refinement merely because history exists. The intent summary must be one plain-English sentence that tells the listener how the request was understood. It must not mention internal models, candidate generation, schemas, retrieval, or Spotify search behavior.\n\nGenerate the exact candidate count requested in the variable input. Each candidate contains only a track title and the credited artist name most likely to identify the recording. Choose recordings that plausibly exist in Spotify's catalog. Use canonical spellings. Do not fabricate tracks, mash up titles and artists, translate titles, or use descriptive placeholders. Avoid remixes, live versions, remasters, edits, sped-up versions, slowed versions, karaoke versions, covers, and tribute recordings unless the user explicitly asks for them. When several recordings share a title, choose the artist credit that makes the intended recording unambiguous.\n\nCandidate quality matters more than superficial variety. Every candidate should fit the interpreted mood, activity, era, language, genre, and familiarity. Still, spread the set across artists. Do not let one artist dominate the candidate list, even when that artist appears prominently in the taste profile. Avoid duplicate titles by the same artist and avoid multiple editions of the same recording. Use a range of strong fits so a later ranking step has meaningful choices rather than thirty near-identical songs.\n\nWhen familiarity leans new, propose music the listener plausibly does not know. Move beyond the named top artists and tracks while retaining understandable bridges through genre, scene, production style, instrumentation, energy, era, or songwriting. Do not simply select deep cuts from every familiar artist. Prefer adjacent artists, overlooked catalogs, regional scenes, and credible cross-genre connections. The profile is not exhaustive, so never claim that a candidate is definitely unknown. When familiarity is familiar, candidates may include supplied top or saved tracks, but remain responsive to the current request. When familiarity is mix, combine recognizable anchors with adjacent discoveries rather than splitting into unrelated halves.\n\nUse musical knowledge conservatively. Base selection on durable, commonly knowable attributes of recordings. Do not invent listening statistics, personal memories, release stories, chart facts, cultural identities, lyrical meanings, or audio features. Do not infer sensitive traits from taste. Explicit safety or content constraints in the request are binding. If a request is broad, create a coherent interpretation instead of asking a question. If constraints conflict, prioritize explicit exclusions, then the current query, then history, then taste evidence.\n\nThe downstream resolver first tries an exact field-filtered search and then a fuzzy bare-text search. Help it succeed with correct title and artist spelling. It will reject weak title or artist matches, so substituting a vaguely related track wastes a candidate. Prefer a confidently identifiable recording over an obscure item whose title or credit you cannot state accurately. Do not include Spotify identifiers, album names, explanations, scores, or justifications in candidate objects.\n\nBefore returning, silently check that the response matches the schema, the candidate list has exactly the requested size, familiarity uses the allowed value, is_refinement reflects conversation continuity, the intent summary is one line, spellings are credible, artist distribution is broad, and no candidate violates an explicit exclusion. Return strictly the structured response and nothing else.\n","cache_control":{"type":"ephemeral"}}]}", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJtb2RlbCI6ImNsYXVkZS1zb25uZXQtNSIsImlkIjoibXNnXzAxMUNkdHVMZFlRSmFYVWszR2VUNHd4ZSIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsIg==", + "Y29udGVudCI6W3sidHlwZSI6InRleHQiLCJ0ZXh0Ijoie1wibW9vZFwiOltcImVuZXJnZXRpY1wiLFwiaW50ZW5zZVwiLFwiZHJpdmluZ1wiLFwiYWdncmVzc2l2ZVwiLFwicHVtcGVkXCJdLFwiYWN0aXZpdHlcIjpcImhlYXZ5IHdvcmtvdXRcIixcImVyYVwiOltdLFwibGFuZ3VhZ2VzXCI6W10sXCJnZW5yZXNcIjpbXCJkcnVtIGFuZCBiYXNzXCIsXCJsaXF1aWQgZG5iXCIsXCJicmVha2JlYXRcIixcImR1YnN0ZXBcIixcInVrIGdhcmFnZVwiXSxcImZhbWlsaWFyaXR5XCI6XCJtaXhcIixcImlzX3JlZmluZW1lbnRcIjpmYWxzZSxcImludGVudF9zdW1tYXJ5XCI6XCJBIGhpZ2gtZW5lcmd5IGRydW0gYW5kIGJhc3MgYW5kIGJyZWFrYmVhdCBtaXggZGVzaWduZWQgdG8gcG93ZXIgYW4gaW50ZW5zZSB3b3Jrb3V0LCBibGVuZGluZyBmYW1pbGlhciBmYXZvcml0ZXMgd2l0aCBmcmVzaCBkaXNjb3Zlcmllcy5cIixcImNhbmRpZGF0ZXNcIjpbe1widGl0bGVcIjpcIkJhc2ljIEluc3RpbmN0XCIsXCJhcnRpc3RcIjpcIk5ldHNreVwifSx7XCJ0aXRsZVwiOlwiU29sYXIgU3lzdGVtXCIsXCJhcnRpc3RcIjpcIlN1YiBGb2N1c1wifSx7XCJ0aXRsZVwiOlwiQkFDS0JPTkVcIixcImFydGlzdFwiOlwiQ2hhc2UgJiBTdGF0dXNcIn0se1widGl0bGVcIjpcIkRKIFR1cm4gSXQgVXBcIixcImFydGlzdFwiOlwiRGltZW5zaW9uXCJ9LHtcInRpdGxlXCI6XCJWaW5vIEJhbmRpdFwiLFwiYXJ0aXN0XCI6XCJLIE1vdGlvbnpcIn0se1widGl0bGVcIjpcIlRyb2dsb2R5dGVcIixcImFydGlzdFwiOlwiQ3VsdHVyZSBTaG9ja1wifSx7XCJ0aXRsZVwiOlwiRmFsbCBUbyBUaGUgRHVzdFwiLFwiYXJ0aXN0XCI6XCJNZXRyaWtcIn0se1widGl0bGVcIjpcIkhhY2tlcnNcIixcImFydGlzdFwiOlwiTWV0cmlrXCJ9LHtcInRpdGxlXCI6XCJHdW5zaG90XCIsXCJhcnRpc3RcIjpcIksgTW90aW9uelwifSx7XCJ0aXRsZVwiOlwiQ2hhc2UgVGhlIFN1blwiLFwiYXJ0aXN0XCI6XCJLb3ZlblwifSx7XCJ0aXRsZVwiOlwiU2V0IE1lIEZyZWVcIixcImFydGlzdFwiOlwiRnJpY3Rpb25cIn0se1widGl0bGVcIjpcIlJlYWR5IFRvIEdvXCIsXCJhcnRpc3RcIjpcIlNob2NrT25lXCJ9LHtcInRpdGxlXCI6XCJCb2R5IExvb3NlXCIsXCJhcnRpc3RcIjpcIldpbGtpbnNvblwifSx7XCJ0aXRsZVwiOlwiQWZ0ZXJtYXRoXCIsXCJhcnRpc3RcIjpcIkNhbW8gJiBLcm9va2VkXCJ9LHtcInRpdGxlXCI6XCJUcnVlIENvbG91clwiLFwiYXJ0aXN0XCI6XCJDYW1vICYgS3Jvb2tlZFwifSx7XCJ0aXRsZVwiOlwiQW50aGVtXCIsXCJhcnRpc3RcIjpcIkRpbWVuc2lvblwifSx7XCJ0aXRsZVwiOlwiVHVyYnVsZW5jZVwiLFwiYXJ0aXN0XCI6XCJSdWRpbWVudA==", + "YWxcIn0se1widGl0bGVcIjpcIlN0YXkgQ2xvc2VcIixcImFydGlzdFwiOlwiRGVsdGEgSGVhdnlcIn0se1widGl0bGVcIjpcIlZvZGthICYgQ29rZVwiLFwiYXJ0aXN0XCI6XCJEZWx0YSBIZWF2eVwifSx7XCJ0aXRsZVwiOlwiQ2FzY2FkZVwiLFwiYXJ0aXN0XCI6XCJDYW1vICYgS3Jvb2tlZFwifSx7XCJ0aXRsZVwiOlwiQmVsb25nXCIsXCJhcnRpc3RcIjpcIlh0cmFoXCJ9LHtcInRpdGxlXCI6XCJPbiBNeSBNaW5kXCIsXCJhcnRpc3RcIjpcIlN1YiBGb2N1c1wifSx7XCJ0aXRsZVwiOlwiQmFkIENvbXBhbnlcIixcImFydGlzdFwiOlwiQmFkIENvbXBhbnkgVUtcIn0se1widGl0bGVcIjpcIlRpbWV3YXJwXCIsXCJhcnRpc3RcIjpcIkJhZCBDb21wYW55IFVLXCJ9LHtcInRpdGxlXCI6XCJXYXJoZWFkXCIsXCJhcnRpc3RcIjpcIlBlbmR1bHVtXCJ9LHtcInRpdGxlXCI6XCJQcm9wYW5lIE5pZ2h0bWFyZXNcIixcImFydGlzdFwiOlwiUGVuZHVsdW1cIn0se1widGl0bGVcIjpcIldhdGVyY29sb3VyXCIsXCJhcnRpc3RcIjpcIlBlbmR1bHVtXCJ9LHtcInRpdGxlXCI6XCJCZWxpZXZlIE1lXCIsXCJhcnRpc3RcIjpcIkFuZHkgQ1wifSx7XCJ0aXRsZVwiOlwiU3dlZXQgVGFsa2VyXCIsXCJhcnRpc3RcIjpcIlNpZ21hXCJ9LHtcInRpdGxlXCI6XCJGZWVsIFRoZSBMb3ZlXCIsXCJhcnRpc3RcIjpcIlJ1ZGltZW50YWxcIn0se1widGl0bGVcIjpcIkJvZHkgTW92ZVwiLFwiYXJ0aXN0XCI6XCJLb3ZlXCJ9LHtcInRpdGxlXCI6XCJBaW4ndCBOb2JvZHlcIixcImFydGlzdFwiOlwiS292ZVwifSx7XCJ0aXRsZVwiOlwiQnJpbmcgWW91IERvd25cIixcImFydGlzdFwiOlwiV2lsa2luc29uXCJ9LHtcInRpdGxlXCI6XCJSb2NrIEl0XCIsXCJhcnRpc3RcIjpcIlN1YiBGb2N1c1wifSx7XCJ0aXRsZVwiOlwiSGlnaCBOb3RlXCIsXCJhcnRpc3RcIjpcIksgTW90aW9uelwifV19In1dLCJzdG9wX3JlYXNvbiI6ImVuZF90dXJuIiwic3RvcF9zZXF1ZW5jZSI6bnVsbCwic3RvcF9kZXRhaWxzIjpudWxsLCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjQ5ODcsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjI3ODMsImNhY2hlX2NyZWF0aW9uIjp7ImVwaGVtZXJhbF81bV9pbnB1dF90b2tlbnMiOjAsImVwaGVtZXJhbF8xaF9pbnB1dF90b2tlbnMiOjB9LCJvdXRwdXRfdG9rZW5zIjo5NjAsIm91dHB1dF90b2tlbnNfZGV0YWlscyI6eyJ0aGlua2luZ190b2tlbnMiOjB9LCJzZXJ2aWNlX3RpZXIiOiJzdGFuZGFyZCIsImluZmVyZW5jZV9nZW8iOiJnbG9iYWwifX0=" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + }, + { + "method": "POST", + "request_body_base64": "{"max_tokens":16384,"messages":[{"role":"user","content":"{\"intent\":{\"mood\":[\"energetic\",\"intense\",\"driving\",\"aggressive\",\"pumped\"],\"activity\":\"heavy workout\",\"era\":[],\"languages\":[],\"genres\":[\"drum and bass\",\"liquid dnb\",\"breakbeat\",\"dubstep\",\"uk garage\"],\"familiarity\":\"mix\",\"intent_summary\":\"A high-energy drum and bass and breakbeat mix designed to power an intense workout, blending familiar favorites with fresh discoveries.\"},\"grounded_pool\":[{\"track_id\":\"2KEazEci1K13NlKUVZjKSa\",\"title\":\"Basic Instinct\",\"artists\":[\"Netsky\"]},{\"track_id\":\"5cRDn5aGMLvWsldoRmOOz0\",\"title\":\"Solar System\",\"artists\":[\"Sub Focus\"]},{\"track_id\":\"3HrHhTWonBqF4mDasi8xvC\",\"title\":\"BACKBONE\",\"artists\":[\"Chase & Status\",\"Stormzy\"]},{\"track_id\":\"28r1xYNakXXwcQKIXu9Wjw\",\"title\":\"DJ Turn It Up\",\"artists\":[\"Dimension\"]},{\"track_id\":\"00c6JYguKlfq5yOlLoITlH\",\"title\":\"Vino Bandit\",\"artists\":[\"K Motionz\",\"Songer\"]},{\"track_id\":\"6wotas1A8sN6oTTqmBzbIS\",\"title\":\"Troglodyte\",\"artists\":[\"Culture Shock\"]},{\"track_id\":\"0JLBuskZoaMd1pYHXezoFI\",\"title\":\"Fall To The Dust\",\"artists\":[\"Metrik\"]},{\"track_id\":\"40SPQDLYs5OAjnEErkpC43\",\"title\":\"Hackers\",\"artists\":[\"Metrik\"]},{\"track_id\":\"5YHVD9UqucHIp9qqPTRhJW\",\"title\":\"Gunshot\",\"artists\":[\"K Motionz\"]},{\"track_id\":\"7kE5SGVpogBX5VXiTgYiRg\",\"title\":\"Chase The Sun\",\"artists\":[\"Koven\"]},{\"track_id\":\"3q2uX1BAjCiKmhEQiqWZTD\",\"title\":\"Set Me Free\",\"artists\":[\"Friction\"]},{\"track_id\":\"3el7utwP0JhA5tObUeXBI8\",\"title\":\"Ready To Go (feat. Bright Sparks)\",\"artists\":[\"ShockOne\",\"Bright Sparks\"]},{\"track_id\":\"7IioKuBQpLIuILPzdXRKlq\",\"title\":\"Anthem - Original Mix\",\"artists\":[\"Dimension\"]},{\"track_id\":\"6tC2iHfUlzB2W4ntXXL2BH\",\"title\":\"Propane Nightmares\",\"artists\":[\"Pendulum\"]},{\"track_id\":\"5ami95W9OOWQPwrBb5tud5\",\"title\":\"Watercolour - Full Version; Single\",\"artists\":[\"Pendulum\"]},{\"track_id\":\"0k73nWaD6RPx2sHFEkGPcn\",\"title\":\"Feel the Love (feat. John Newman)\",\"artists\":[\"Rudimental\",\"John Newman\"]},{\"track_id\":\"69PmbaybVYoxErPtJ5v7Th\",\"title\":\"Rock It\",\"artists\":[\"Sub Focus\"]},{\"track_id\":\"28f5cHOahtA3JhbIBt9q9Y\",\"title\":\"High Note\",\"artists\":[\"K Motionz\",\"Emily Makis\"]}],\"taste_profile\":\"Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist\",\"history\":[],\"requested_selection_count\":15,\"correction\":null}"}],"model":"claude-sonnet-5","output_config":{"effort":"medium","format":{"type":"json_schema","schema":{"$defs":{"RerankSelectionOutput":{"type":"object","description":"One validated object extracted from the rerank stream.","title":"RerankSelectionOutput","properties":{"track_id":{"type":"string","title":"Track Id","description":"{maxLength: 200, minLength: 1}"},"justification":{"type":"string","title":"Justification","description":"{maxLength: 300, minLength: 1, pattern: ^[^\\r\\n]+$}"}},"additionalProperties":false,"required":["track_id","justification"]}},"type":"object","description":"Complete bounded rerank output used for final validation.","title":"RerankOutput","properties":{"recommendations":{"type":"array","title":"Recommendations","items":{"$ref":"#/$defs/RerankSelectionOutput"},"minItems":1,"description":"{maxItems: 50}"}},"additionalProperties":false,"required":["recommendations"]}}},"system":[{"type":"text","text":"You are the final ranking component of a music discovery system. Select and order tracks only from the grounded Spotify pool supplied in the variable input. Return only data that conforms to the provided JSON schema. Output strictly the JSON object required by that schema, with no markdown, no code fence, no introductory sentence, and no trailing commentary.\n\nThe variable input contains the interpreted intent, a compact listener taste summary, bounded conversation history, and a grounded pool. Every pool entry includes a Spotify track id, title, and artist names. The pool is the complete set of allowed choices. Copy track_id values exactly. Never create, alter, guess, shorten, or normalize an id. Never select a title that is absent from the pool, even if it would be a better recommendation. Never return the same track id twice.\n\nChoose up to the requested selection count, ordered from strongest to weakest recommendation. Prefer a shorter set of honest strong fits over padding with clearly unsuitable material, but normally fill the requested count when the pool contains enough relevant choices. Ranking should respond to the current intent first. Use the taste summary to personalize among plausible fits, not to override an explicit request. Use history to understand refinements and references. Treat prior assistant statements as conversation context rather than verified facts about a recording.\n\nRespect the interpreted mood, activity, era, languages, genres, and familiarity together. A track need not satisfy every soft descriptor equally, but the ordering should form a coherent listening path. Put the clearest overall matches early. Consider transitions in energy, texture, and familiarity when that creates a more useful sequence, while avoiding a mechanical pattern. Spread selections across artists where the grounded pool permits it. Do not rank several editions of the same recording merely to fill space.\n\nFamiliarity affects ordering, but it does not grant access to information outside the input. For familiar requests, favor grounded tracks that visibly connect to the supplied taste evidence or prior recommendations. For new requests, favor credible adjacent discoveries and avoid leaning entirely on artists named in the taste summary. For mix requests, use recognizable anchors and exploratory choices in a coherent balance. The application may already have filtered known tracks, so do not claim that any selection is definitely new or previously unheard.\n\nWrite one concise, plain-English justification for each selection. It should connect the track to the stated intent and, only when supported, to an explicit item or pattern in the supplied taste summary. Keep it to one line. Make the reason useful to the listener rather than describing internal ranking operations. Good reasons identify a grounded connection such as pacing for the activity, a genre bridge, a requested era, a compatible vocal language, a mood transition, or continuity with a named preference.\n\nBe exact and modest. Do not invent audio measurements, tempo values, key signatures, instrumentation, lyrical subjects, release dates, artist biographies, chart history, cultural significance, collaborations, popularity, or claims about what the listener has heard. A title and artist name alone do not prove detailed sonic or lyrical facts. You may use stable general musical knowledge when confident, but phrase the justification around the supplied intent and visible evidence. If the inputs do not support a specific fact, use a restrained reason such as \"A focused fit for the requested late-night electronic mood\" rather than manufacturing detail.\n\nDo not mention Spotify search, grounding, the candidate generator, language models, schemas, hidden scores, safety filters, cache state, or missing data in a justification. Do not tell the listener that a track was selected because it was available in the pool. Do not compare a selection with tracks that are not in the pool. Do not repeat the same generic sentence for every item. Avoid promotional language and absolute claims such as \"perfect,\" \"guaranteed,\" or \"the best.\"\n\nWhen the variable input says this is a correction attempt, treat the stated validation failure as a strict constraint. Return a fresh complete JSON object, not a patch or explanation. Correct invalid ids, duplicates, malformed fields, count problems, and formatting errors using only the supplied pool. The correction instruction never allows an out-of-pool id.\n\nThe response must be one JSON object with the exact top-level field required by the schema. Each array item must contain exactly a track_id and justification in the required types. Preserve the requested ranking order in the array. Use valid JSON quoting and escaping. Do not emit comments, dangling commas, alternate keys, null justifications, numeric ids, or additional properties.\n\nBefore returning, silently verify every track_id against the supplied pool, ensure all ids are unique, ensure the number of items does not exceed the requested count, confirm each justification is honest and one line, confirm the ranking follows the current intent, and confirm the entire response is valid against the provided JSON schema. Return only the JSON object.\n","cache_control":{"type":"ephemeral"}}],"stream":true}", + "response_body_base64": "event: message_start
data: {"type":"message_start","message":{"model":"claude-sonnet-5","id":"msg_011CdtuMiSMohycp4KRGZbwa","type":"message","role":"assistant","content":[],"stop_reason":null,"stop_sequence":null,"stop_details":null,"usage":{"input_tokens":6087,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"cache_creation":{"ephemeral_5m_input_tokens":0,"ephemeral_1h_input_tokens":0},"output_tokens":1,"service_tier":"standard","inference_geo":"global"}}               }

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}           }

event: ping
data: {"type": "ping"}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"{"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"recommendations\":[{\"track_id\":\"6tC2iHfUlz"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"B2W4ntXXL2BH\",\"justification\":"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\"A high-intensity drum and bass anthem that sets an aggressive tone for a workout opener.\"},{\"track_id\":\"3HrHh"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"TWonBqF4mDasi8"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"xvC\",\"justification\":\"Chase & Status is a strong presence in your listening, and this driving track br"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ings that same explosive energy.\"},{\"track_id\":\"2KEazEci1K"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"13NlKUVZjKSa\",\"justification\":\"A"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" Netsky favorite from your top tracks that keeps the pace pumped and relentless.\"},{\"track_id\":\"5c"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"RDn5aGMLvWsld"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"oRmOOz0\",\"justification\":\"Sub Focus delivers a punchy, driving energ"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"y that fits the intense workout mood well.\"},{\"track_id\":\"69PmbaybVYo"}        }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"xErPtJ5v7Th\",\"justification\":\"Another Sub Focus cut with a"}          }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" hard-hitting drive suited to sustained physical effort.\"},{\"track_id\":\"28r1xYNakXXw"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"cQKIXu9Wjw\",\"justification\":\"Dimension's breakbeat energ"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"y offers a familiar anchor while keeping intensity high.\"},{\"track_id\":\"7IioKuBQp"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"LIuILPzdXRKlq"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"A second Dimension selection continues the aggressive breakbeat momentum without repeating the same track.\"},{\"track_id\":\"5YHVD"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"9UqucHIp9qqPT"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"RhJW\",\"justification\":\"K Motionz appears often in your saved tracks, and this aggressive dub"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"step-leaning cut fits the intense mood.\"},{\"track_id\":\"00c6JYguKlf"}   }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"q5yOlLoITlH\",\"justification\":\"Another K Motionz track that"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" keeps the pumped, driving feel going mid-set.\"},{\"track_id\":\"28f5cHOahtA"}      }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"3JhbIBt9q9Y\",\"justification\":\"A"}     }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" slightly melodic K Motionz collaboration that offers a brief energy shift while staying intense.\"},{\"track_id\":\"6wot"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"as1A8sN6oTTqmB"}             }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"zbIS\",\"justification\":\"Culture Shock brings a familiar, driving liqu"}         }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"id dnb energy that connects to your top artists.\"},{\"track_id\":\"0JLBuskZoa"}              }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Md1pYHXezoFI\",\"justification\":\"Metr"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ik's aggressive production style keeps the workout pace elevated and focused.\"},{\"track_id\":\"40SPQDLY"}            }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"s5OAjnEErkpC43"}       }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"\",\"justification\":\"A second Metrik cut continues the high-energy drive without losing intensity.\"},{\"track_id\":\"3q2uX1B"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"AjCiKmhEQiqW"}    }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ZTD\",\"justification\":\"Friction, a recurring favorite, delivers a strong, driving liquid dnb energy for s"}  }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ustained effort.\"},{\"track_id\":\"7kE5SGVpogBX5VX"} }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"iTgYiRg\",\"justification\":\"Koven's intense, anthemic s"}           }

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ound offers a fitting high-energy close to the workout mix.\"}]}"}    }

event: content_block_stop
data: {"type":"content_block_stop","index":0          }

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null,"stop_details":null},"usage":{"input_tokens":6087,"cache_creation_input_tokens":0,"cache_read_input_tokens":2113,"output_tokens":975,"output_tokens_details":{"thinking_tokens":0}}   }

event: message_stop
data: {"type":"message_stop" }

", + "response_chunks_base64": [ + "ZXZlbnQ6IG1lc3NhZ2Vfc3RhcnQKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9zdGFydCIsIm1lc3NhZ2U=", + "Ijp7Im1vZGVsIjoiY2xhdWRlLXNvbm5ldC01IiwiaWQiOiJtc2dfMDExQ2R0dU1pU01vaHljcDRLUkdaYndhIiwidHlwZSI6Im1lc3NhZ2UiLCJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6W10sInN0b3BfcmVhc29uIjpudWxsLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6NjA4NywiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MjExMywiY2FjaGVfY3JlYXRpb24iOnsiZXBoZW1lcmFsXzVtX2lucHV0X3Rva2VucyI6MCwiZXBoZW1lcmFsXzFoX2lucHV0X3Rva2VucyI6MH0sIm91dHB1dF90b2tlbnMiOjEsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Imdsb2JhbCJ9fSAgICAgICAgICAgICAgIH0KCmV2ZW50OiBjb250ZW50X2Jsb2NrX3N0YXJ0CmRhdGE6IHsidHlwZSI6ImNvbnRlbnRfYmxvY2tfc3RhcnQiLCJpbmRleCI6MCwiY29udGVudF9ibG9jayI6eyJ0eXBlIjoidGV4dCIsInRleHQiOiIifSAgICAgICAgICAgfQoKZXZlbnQ6IHBpbmcKZGF0YTogeyJ0eXBlIjogInBpbmcifQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ7In0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcInJlY29tbWVuZGF0aW9uc1wiOlt7XCJ0cmFja19pZFwiOlwiNnRDMmlIZlVseiJ9ICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJCMlc0bnRYWEwyQkhcIixcImp1c3RpZmljYXRpb25cIjoifSAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIkEgaGlnaC1pbnRlbnNpdHkgZHJ1bSBhbmQgYmFzcyBhbnRoZW0gdGhhdCBzZXRzIGFuIGFnZ3Jlc3NpdmUgdG9uZSBmb3IgYSB3b3Jrb3V0IG9wZW5lci5cIn0se1widHJhY2tfaWRcIjpcIjNIckhoIn0gICAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJUV29uQnFGNG1EYXNpOCJ9ICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ4dkNcIixcImp1c3RpZmljYXRpb25cIjpcIkNoYXNlICYgU3RhdHVzIGlzIGEgc3Ryb25nIHByZXNlbmNlIGluIHlvdXIgbGlzdGVuaW5nLCBhbmQgdGhpcyBkcml2aW5nIHRyYWNrIGJyIn0gICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpbmdzIHRoYXQgc2FtZSBleHBsb3NpdmUgZW5lcmd5LlwifSx7XCJ0cmFja19pZFwiOlwiMktFYXpFY2kxSyJ9ICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIxM05sS1VWWmpLU2FcIixcImp1c3RpZmljYXRpb25cIjpcIkEifSAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgTmV0c2t5IGZhdm9yaXRlIGZyb20geW91ciB0b3AgdHJhY2tzIHRoYXQga2VlcHMgdGhlIHBhY2UgcHVtcGVkIGFuZCByZWxlbnRsZXNzLlwifSx7XCJ0cmFja19pZFwiOlwiNWMifSAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJSRG41YUdNTHZXc2xkIn0gICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvUm1PT3owXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJTdWIgRm9jdXMgZGVsaXZlcnMgYSBwdW5jaHksIGRyaXZpbmcgZW5lcmcifSB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ5IHRoYXQgZml0cyB0aGUgaW50ZW5zZSB3b3Jrb3V0IG1vb2Qgd2VsbC5cIn0se1widHJhY2tfaWRcIjpcIjY5UG1iYXliVllvIn0gICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ4RXJQdEo1djdUaFwiLFwianVzdGlmaWNhdGlvblwiOlwiQW5vdGhlciBTdWIgRm9jdXMgY3V0IHdpdGggYSJ9ICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgaGFyZC1oaXR0aW5nIGRyaXZlIHN1aXRlZCB0byBzdXN0YWluZWQgcGh5c2ljYWwgZWZmb3J0LlwifSx7XCJ0cmFja19pZFwiOlwiMjhyMXhZTmFrWFh3In0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJjUUtJWHU5V2p3XCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJEaW1lbnNpb24ncyBicmVha2JlYXQgZW5lcmcifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ5IG9mZmVycyBhIGZhbWlsaWFyIGFuY2hvciB3aGlsZSBrZWVwaW5nIGludGVuc2l0eSBoaWdoLlwifSx7XCJ0cmFja19pZFwiOlwiN0lpb0t1QlFwIn0gICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJMSXVJTFB6ZFhSS2xxIn0gICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIkEgc2Vjb25kIERpbWVuc2lvbiBzZWxlY3Rpb24gY29udGludWVzIHRoZSBhZ2dyZXNzaXZlIGJyZWFrYmVhdCBtb21lbnR1bSB3aXRob3V0IHJlcGVhdGluZyB0aGUgc2FtZSB0cmFjay5cIn0se1widHJhY2tfaWRcIjpcIjVZSFZEIn0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiI5VXF1Y0hJcDlxcVBUIn0gICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJSaEpXXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJLIE1vdGlvbnogYXBwZWFycyBvZnRlbiBpbiB5b3VyIHNhdmVkIHRyYWNrcywgYW5kIHRoaXMgYWdncmVzc2l2ZSBkdWIifSAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJzdGVwLWxlYW5pbmcgY3V0IGZpdHMgdGhlIGludGVuc2UgbW9vZC5cIn0se1widHJhY2tfaWRcIjpcIjAwYzZKWWd1S2xmIn0gICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJxNXlPbExvSVRsSFwiLFwianVzdGlmaWNhdGlvblwiOlwiQW5vdGhlciBLIE1vdGlvbnogdHJhY2sgdGhhdCJ9ICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIga2VlcHMgdGhlIHB1bXBlZCwgZHJpdmluZyBmZWVsIGdvaW5nIG1pZC1zZXQuXCJ9LHtcInRyYWNrX2lkXCI6XCIyOGY1Y0hPYWh0QSJ9ICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIzSmhiSUJ0OXE5WVwiLFwianVzdGlmaWNhdGlvblwiOlwiQSJ9ICAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiIgc2xpZ2h0bHkgbWVsb2RpYyBLIE1vdGlvbnogY29sbGFib3JhdGlvbiB0aGF0IG9mZmVycyBhIGJyaWVmIGVuZXJneSBzaGlmdCB3aGlsZSBzdGF5aW5nIGludGVuc2UuXCJ9LHtcInRyYWNrX2lkXCI6XCI2d290In0gICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJhczFBOHNONm9UVHFtQiJ9ICAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ6YklTXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJDdWx0dXJlIFNob2NrIGJyaW5ncyBhIGZhbWlsaWFyLCBkcml2aW5nIGxpcXUifSAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpZCBkbmIgZW5lcmd5IHRoYXQgY29ubmVjdHMgdG8geW91ciB0b3AgYXJ0aXN0cy5cIn0se1widHJhY2tfaWRcIjpcIjBKTEJ1c2tab2EifSAgICAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJNZDFwWUhYZXpvRklcIixcImp1c3RpZmljYXRpb25cIjpcIk1ldHIifSAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpaydzIGFnZ3Jlc3NpdmUgcHJvZHVjdGlvbiBzdHlsZSBrZWVwcyB0aGUgd29ya291dCBwYWNlIGVsZXZhdGVkIGFuZCBmb2N1c2VkLlwifSx7XCJ0cmFja19pZFwiOlwiNDBTUFFETFkifSAgICAgICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJzNU9Bam5FRXJrcEM0MyJ9ICAgICAgIH0KCg==", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJcIixcImp1c3RpZmljYXRpb25cIjpcIkEgc2Vjb25kIE1ldHJpayBjdXQgY29udGludWVzIHRoZSBoaWdoLWVuZXJneSBkcml2ZSB3aXRob3V0IGxvc2luZyBpbnRlbnNpdHkuXCJ9LHtcInRyYWNrX2lkXCI6XCIzcTJ1WDFCIn19Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJBakNpS21oRVFpcVcifSAgICB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJaVERcIixcImp1c3RpZmljYXRpb25cIjpcIkZyaWN0aW9uLCBhIHJlY3VycmluZyBmYXZvcml0ZSwgZGVsaXZlcnMgYSBzdHJvbmcsIGRyaXZpbmcgbGlxdWlkIGRuYiBlbmVyZ3kgZm9yIHMifSAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJ1c3RhaW5lZCBlZmZvcnQuXCJ9LHtcInRyYWNrX2lkXCI6XCI3a0U1U0dWcG9nQlg1VlgifSB9Cgo=", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJpVGdZaVJnXCIsXCJqdXN0aWZpY2F0aW9uXCI6XCJLb3ZlbidzIGludGVuc2UsIGFudGhlbWljIHMifSAgICAgICAgICAgfQoK", + "ZXZlbnQ6IGNvbnRlbnRfYmxvY2tfZGVsdGEKZGF0YTogeyJ0eXBlIjoiY29udGVudF9ibG9ja19kZWx0YSIsImluZGV4IjowLCJkZWx0YSI6eyJ0eXBlIjoidGV4dF9kZWx0YSIsInRleHQiOiJvdW5kIG9mZmVycyBhIGZpdHRpbmcgaGlnaC1lbmVyZ3kgY2xvc2UgdG8gdGhlIHdvcmtvdXQgbWl4LlwifV19In0gICAgfQoKZXZlbnQ6IGNvbnRlbnRfYmxvY2tfc3RvcApkYXRhOiB7InR5cGUiOiJjb250ZW50X2Jsb2NrX3N0b3AiLCJpbmRleCI6MCAgICAgICAgICB9Cgo=", + "ZXZlbnQ6IG1lc3NhZ2VfZGVsdGEKZGF0YTogeyJ0eXBlIjoibWVzc2FnZV9kZWx0YSIsImRlbHRhIjp7InN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGx9LCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjYwODcsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjIxMTMsIm91dHB1dF90b2tlbnMiOjk3NSwib3V0cHV0X3Rva2Vuc19kZXRhaWxzIjp7InRoaW5raW5nX3Rva2VucyI6MH19ICAgfQoK", + "ZXZlbnQ6IG1lc3NhZ2Vfc3RvcApkYXRhOiB7InR5cGUiOiJtZXNzYWdlX3N0b3AiIH0KCg==" + ], + "status": 200, + "url": "https://api.anthropic.com/v1/messages" + } +] diff --git a/eval/fixtures/workout-energy/spotify.json b/eval/fixtures/workout-energy/spotify.json new file mode 100644 index 0000000..220e4ee --- /dev/null +++ b/eval/fixtures/workout-energy/spotify.json @@ -0,0 +1,773 @@ +[ + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=", + "response_chunks_base64": [ + "eyJhY2NvdW50X2lkIjoic3ludGhldGljLWFjY291bnQiLCJkaXNwbGF5X25hbWUiOiJTeW50aGV0aWMgTGlzdGVuZXIiLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdXNlci9zeW50aGV0aWMtYWNjb3VudCJ9LCJmb2xsb3dlcnMiOnsiaHJlZiI6bnVsbCwidG90YWwiOjI0fSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3VzZXJzL3N5bnRoZXRpYy1hY2NvdW50IiwiaWQiOiJzeW50aGV0aWMtYWNjb3VudCIsImltYWdlcyI6W10sInR5cGUiOiJ1c2VyIiwidXJpIjoic3BvdGlmeTp1c2VyOnN5bnRoZXRpYy1hY2NvdW50In0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=0" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=long_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL2FydGlzdHMiLCJpdGVtcyI6W3siaWQiOiJzeW50aGV0aWMtZm9jdXMtYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBBcnRpc3QifSx7ImlkIjoic3ludGhldGljLWphenotYXJ0aXN0IiwibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6Mn0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/artists?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdG9wL3RyYWNrcyIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEZvY3VzIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgRm9jdXMgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLWZvY3VzLXRyYWNrIn0sImlkIjoic3ludGhldGljLWZvY3VzLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBGb2N1cyBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLWZvY3VzLXRyYWNrIn0seyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIEphenogQWxidW0ifSwiYXJ0aXN0cyI6W3sibmFtZSI6IlN5bnRoZXRpYyBKYXp6IEFydGlzdCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrL3N5bnRoZXRpYy1qYXp6LXRyYWNrIn0sImlkIjoic3ludGhldGljLWphenotdHJhY2siLCJuYW1lIjoiU3ludGhldGljIEphenogVHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOnN5bnRoZXRpYy1qYXp6LXRyYWNrIn1dLCJsaW1pdCI6NTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyfQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/top/tracks?time_range=short_term&limit=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=", + "response_chunks_base64": [ + "eyJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvbWUvdHJhY2tzIiwiaXRlbXMiOlt7ImFkZGVkX2F0IjoiMjAyNi0wMS0wMVQwMDowMDowMFoiLCJ0cmFjayI6eyJhbGJ1bSI6eyJpbWFnZXMiOltdLCJuYW1lIjoiU3ludGhldGljIFNhdmVkIEFsYnVtIn0sImFydGlzdHMiOlt7Im5hbWUiOiJTeW50aGV0aWMgU2F2ZWQgQXJ0aXN0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svc3ludGhldGljLXNhdmVkLXRyYWNrIn0sImlkIjoic3ludGhldGljLXNhdmVkLXRyYWNrIiwibmFtZSI6IlN5bnRoZXRpYyBTYXZlZCBUcmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6c3ludGhldGljLXNhdmVkLXRyYWNrIn19XSwibGltaXQiOjUwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/me/tracks?limit=50&offset=50" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJhc2ljJTIwSW5zdGluY3QlMjIlMjBhcnRpc3QlM0ElMjJOZXRza3klMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVUZ1E2Nld1V2tvUTJ4WXhhU1RuVlAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVRnUTY2V3VXa29RMnhZeGFTVG5WUCIsImlkIjoiNVRnUTY2V3VXa29RMnhZeGFTVG5WUCIsIm5hbWUiOiJOZXRza3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVRnUTY2V3VXa29RMnhZeGFTVG5WUCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBTVWZLSDgwR2p1S2JBNWRUV1N3a2gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wU1VmS0g4MEdqdUtiQTVkVFdTd2toIiwiaWQiOiIwU1VmS0g4MEdqdUtiQTVkVFdTd2toIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYQ==", + "YjY3NjE2ZDAwMDBiMjczYTNlMzA4MTRiMmY5MGFhYzZlZDIwZDlhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmEzZTMwODE0YjJmOTBhYWM2ZWQyMGQ5YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYTNlMzA4MTRiMmY5MGFhYzZlZDIwZDlhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNlY29uZCBOYXR1cmUiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTEwLTMwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MFNVZktIODBHanVLYkE1ZFRXU3draCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVUZ1E2Nld1V2tvUTJ4WXhhU1RuVlAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNVRnUTY2V3VXa29RMnhZeGFTVG5WUCIsImlkIjoiNVRnUTY2V3VXa29RMnhZeGFTVG5WUCIsIm5hbWUiOiJOZXRza3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NVRnUTY2V3VXa29RMnhZeGFTVG5WUCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzcyNDEsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkNKWTIwMDA0ODUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJLRWF6RWNpMUsxM05sS1VWWmpLU2EifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yS0VhekVjaTFLMTNObEtVVlpqS1NhIiwiaWQiOiIyS0VhekVjaTFLMTNObEtVVlpqS1NhIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhc2ljIEluc3RpbmN0IiwidHJhY2tfbnVtYmVyIjoxOCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyS0VhekVjaTFLMTNObEtVVlpqS1NhIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Basic+Instinct%22+artist%3A%22Netsky%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22DJ%20Turn%20It%20Up%22%20artist%3A%22Dimension%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":8,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"external_urls":{"spotify":"https://open.spotify.com/album/1POsjSFSyqW21AEn71tdJn"},"href":"https://api.spotify.com/v1/albums/1POsjSFSyqW21AEn71tdJn","id":"1POsjSFSyqW21AEn71tdJn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c4f5dd40794d687f273a6d9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c4f5dd40794d687f273a6d9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c4f5dd40794d687f273a6d9"}],"is_playable":true,"name":"DJ Turn It Up","release_date":"2023-05-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1POsjSFSyqW21AEn71tdJn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"disc_number":1,"duration_ms":177931,"explicit":false,"external_ids":{"isrc":"UKFTL1600270"},"external_urls":{"spotify":"https://open.spotify.com/track/28r1xYNakXXwcQKIXu9Wjw"},"href":"https://api.spotify.com/v1/tracks/28r1xYNakXXwcQKIXu9Wjw","id":"28r1xYNakXXwcQKIXu9Wjw","is_local":false,"is_playable":true,"name":"DJ Turn It Up","track_number":1,"type":"track","uri":"spotify:track:28r1xYNakXXwcQKIXu9Wjw"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Bd1phrOZJuCev9U0bzdtA"},"href":"https://api.spotify.com/v1/artists/3Bd1phrOZJuCev9U0bzdtA","id":"3Bd1phrOZJuCev9U0bzdtA","name":"Ben Nicky","type":"artist","uri":"spotify:artist:3Bd1phrOZJuCev9U0bzdtA"}],"external_urls":{"spotify":"https://open.spotify.com/album/2X5Q84NtVSBrSAKuyXrnGh"},"href":"https://api.spotify.com/v1/albums/2X5Q84NtVSBrSAKuyXrnGh","id":"2X5Q84NtVSBrSAKuyXrnGh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f994600cf3832705ae56622"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f994600cf3832705ae56622"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f994600cf3832705ae56622"}],"is_playable":true,"name":"DJ Turn It Up (Ben Nicky Remix)","release_date":"2023-08-11","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:2X5Q84NtVSBrSAKuyXrnGh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Bd1phrOZJuCev9U0bzdtA"},"href":"https://api.spotify.com/v1/artists/3Bd1phrOZJuCev9U0bzdtA","id":"3Bd1phrOZJuCev9U0bzdtA","name":"Ben Nicky","type":"artist","uri":"spotify:artist:3Bd1phrOZJuCev9U0bzdtA"}],"disc_number":1,"duration_ms":138088,"explicit":false,"external_ids":{"isrc":"US39N2309608"},"external_urls":{"spotify":"https://open.spotify.com/track/5nqW6RAWDBynvve3TDXH9r"},"href":"https://api.spotify.com/v1/tracks/5nqW6RAWDBynvve3TDXH9r","id":"5nqW6RAWDBynvve3TDXH9r","is_local":false,"is_playable":true,"name":"DJ Turn It Up - Ben Nicky Remix","track_number":1,"type":"track","uri":"spotify:track:5nqW6RAWDBynvve3TDXH9r"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"external_urls":{"spotify":"https://open.spotify.com/album/4iddjX0NEsSXOWVOBfL7qN"},"href":"https://api.spotify.com/v1/albums/4iddjX0NEsSXOWVOBfL7qN","id":"4iddjX0NEsSXOWVOBfL7qN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731a252c656e480c4a2decdfdd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021a252c656e480c4a2decdfdd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511a252c656e480c4a2decdfdd"}],"is_playable":true,"name":"DJ Turn It Up (Dimension House Remix)","release_date":"2023-08-04","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:4iddjX0NEsSXOWVOBfL7qN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"disc_number":1,"duration_ms":240000,"explicit":false,"external_ids":{"isrc":"US39N2310109"},"external_urls":{"spotify":"https://open.spotify.com/track/6cjc5HJjJ9dRJLCAN9ZNU8"},"href":"https://api.spotify.com/v1/tracks/6cjc5HJjJ9dRJLCAN9ZNU8","id":"6cjc5HJjJ9dRJLCAN9ZNU8","is_local":false,"is_playable":true,"name":"DJ Turn It Up - Dimension House Remix","track_number":1,"type":"track","uri":"spotify:track:6cjc5HJjJ9dRJLCAN9ZNU8"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Bd1phrOZJuCev9U0bzdtA"},"href":"https://api.spotify.com/v1/artists/3Bd1phrOZJuCev9U0bzdtA","id":"3Bd1phrOZJuCev9U0bzdtA","name":"Ben Nicky","type":"artist","uri":"spotify:artist:3Bd1phrOZJuCev9U0bzdtA"}],"external_urls":{"spotify":"https://open.spotify.com/album/2n77wrvUX2ILJIufz4kqjK"},"href":"https://api.spotify.com/v1/albums/2n77wrvUX2ILJIufz4kqjK","id":"2n77wrvUX2ILJIufz4kqjK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739b7212538bbe812b99a262bb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029b7212538bbe812b99a262bb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519b7212538bbe812b99a262bb"}],"is_playable":true,"name":"DJ Turn It Up (Remixes)","release_date":"2023-08-18","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:2n77wrvUX2ILJIufz4kqjK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Bd1phrOZJuCev9U0bzdtA"},"href":"https://api.spotify.com/v1/artists/3Bd1phrOZJuCev9U0bzdtA","id":"3Bd1phrOZJuCev9U0bzdtA","name":"Ben Nicky","type":"artist","uri":"spotify:artist:3Bd1phrOZJuCev9U0bzdtA"}],"disc_number":1,"duration_ms":138088,"explicit":false,"external_ids":{"isrc":"US39N2309608"},"external_urls":{"spotify":"https://open.spotify.com/track/2XlYgMRe1GDmppXPCOt4gx"},"href":"https://api.spotify.com/v1/tracks/2XlYgMRe1GDmppXPCOt4gx","id":"2XlYgMRe1GDmppXPCOt4gx","is_local":false,"is_playable":true,"name":"DJ Turn It Up - Ben Nicky Remix","track_number":3,"type":"track","uri":"spotify:track:2XlYgMRe1GDmppXPCOt4gx"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Bd1phrOZJuCev9U0bzdtA"},"href":"https://api.spotify.com/v1/artists/3Bd1phrOZJuCev9U0bzdtA","id":"3Bd1phrOZJuCev9U0bzdtA","name":"Ben Nicky","type":"artist","uri":"spotify:artist:3Bd1phrOZJuCev9U0bzdtA"}],"external_urls":{"spotify":"https://open.spotify.com/album/2n77wrvUX2ILJIufz4kqjK"},"href":"https://api.spotify.com/v1/albums/2n77wrvUX2ILJIufz4kqjK","id":"2n77wrvUX2ILJIufz4kqjK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739b7212538bbe812b99a262bb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029b7212538bbe812b99a262bb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519b7212538bbe812b99a262bb"}],"is_playable":true,"name":"DJ Turn It Up (Remixes)","release_date":"2023-08-18","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:2n77wrvUX2ILJIufz4kqjK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"disc_number":1,"duration_ms":240000,"explicit":false,"external_ids":{"isrc":"US39N2310109"},"external_urls":{"spotify":"https://open.spotify.com/track/1jtg6r6U3OKDohYNyRgKoy"},"href":"https://api.spotify.com/v1/tracks/1jtg6r6U3OKDohYNyRgKoy","id":"1jtg6r6U3OKDohYNyRgKoy","is_local":false,"is_playable":true,"name":"DJ Turn It Up - Dimension House Remix","track_number":2,"type":"track","uri":"spotify:track:1jtg6r6U3OKDohYNyRgKoy"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Bd1phrOZJuCev9U0bzdtA"},"href":"https://api.spotify.com/v1/artists/3Bd1phrOZJuCev9U0bzdtA","id":"3Bd1phrOZJuCev9U0bzdtA","name":"Ben Nicky","type":"artist","uri":"spotify:artist:3Bd1phrOZJuCev9U0bzdtA"}],"external_urls":{"spotify":"https://open.spotify.com/album/2n77wrvUX2ILJIufz4kqjK"},"href":"https://api.spotify.com/v1/albums/2n77wrvUX2ILJIufz4kqjK","id":"2n77wrvUX2ILJIufz4kqjK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739b7212538bbe812b99a262bb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029b7212538bbe812b99a262bb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519b7212538bbe812b99a262bb"}],"is_playable":true,"name":"DJ Turn It Up (Remixes)","release_date":"2023-08-18","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:2n77wrvUX2ILJIufz4kqjK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"disc_number":1,"duration_ms":177931,"explicit":false,"external_ids":{"isrc":"UKFTL1600270"},"external_urls":{"spotify":"https://open.spotify.com/track/2dzJ4phItmcTsAlIxLmUQF"},"href":"https://api.spotify.com/v1/tracks/2dzJ4phItmcTsAlIxLmUQF","id":"2dzJ4phItmcTsAlIxLmUQF","is_local":false,"is_playable":true,"name":"DJ Turn It Up","track_number":1,"type":"track","uri":"spotify:track:2dzJ4phItmcTsAlIxLmUQF"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3Bd1phrOZJuCev9U0bzdtA"},"href":"https://api.spotify.com/v1/artists/3Bd1phrOZJuCev9U0bzdtA","id":"3Bd1phrOZJuCev9U0bzdtA","name":"Ben Nicky","type":"artist","uri":"spotify:artist:3Bd1phrOZJuCev9U0bzdtA"}],"external_urls":{"spotify":"https://open.spotify.com/album/2X5Q84NtVSBrSAKuyXrnGh"},"href":"https://api.spotify.com/v1/albums/2X5Q84NtVSBrSAKuyXrnGh","id":"2X5Q84NtVSBrSAKuyXrnGh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f994600cf3832705ae56622"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f994600cf3832705ae56622"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f994600cf3832705ae56622"}],"is_playable":true,"name":"DJ Turn It Up (Ben Nicky Remix)","release_date":"2023-08-11","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:2X5Q84NtVSBrSAKuyXrnGh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"disc_number":1,"duration_ms":177931,"explicit":false,"external_ids":{"isrc":"UKFTL1600270"},"external_urls":{"spotify":"https://open.spotify.com/track/7ag9IQ7wXEEMyHYgfC3K9d"},"href":"https://api.spotify.com/v1/tracks/7ag9IQ7wXEEMyHYgfC3K9d","id":"7ag9IQ7wXEEMyHYgfC3K9d","is_local":false,"is_playable":true,"name":"DJ Turn It Up","track_number":2,"type":"track","uri":"spotify:track:7ag9IQ7wXEEMyHYgfC3K9d"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"external_urls":{"spotify":"https://open.spotify.com/album/4iddjX0NEsSXOWVOBfL7qN"},"href":"https://api.spotify.com/v1/albums/4iddjX0NEsSXOWVOBfL7qN","id":"4iddjX0NEsSXOWVOBfL7qN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731a252c656e480c4a2decdfdd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021a252c656e480c4a2decdfdd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511a252c656e480c4a2decdfdd"}],"is_playable":true,"name":"DJ Turn It Up (Dimension House Remix)","release_date":"2023-08-04","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:4iddjX0NEsSXOWVOBfL7qN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1QMgre3BHX161ZHtWMUu6S"},"href":"https://api.spotify.com/v1/artists/1QMgre3BHX161ZHtWMUu6S","id":"1QMgre3BHX161ZHtWMUu6S","name":"Dimension","type":"artist","uri":"spotify:artist:1QMgre3BHX161ZHtWMUu6S"}],"disc_number":1,"duration_ms":177931,"explicit":false,"external_ids":{"isrc":"UKFTL1600270"},"external_urls":{"spotify":"https://open.spotify.com/track/5c3ICKe9NSy7YgCf3b2O2n"},"href":"https://api.spotify.com/v1/tracks/5c3ICKe9NSy7YgCf3b2O2n","id":"5c3ICKe9NSy7YgCf3b2O2n","is_local":false,"is_playable":true,"name":"DJ Turn It Up","track_number":2,"type":"track","uri":"spotify:track:5c3ICKe9NSy7YgCf3b2O2n"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkRKJTIwVHVybiUyMEl0JTIwVXAlMjIlMjBhcnRpc3QlM0ElMjJEaW1lbnNpb24lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjgsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJpZCI6IjFRTWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJuYW1lIjoiRGltZW5zaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xUE9zalNGU3lxVzIxQUVuNzF0ZEpuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVBPc2pTRlN5cVcyMUFFbjcxdGRKbiIsImlkIjoiMVBPc2pTRlN5cVcyMUFFbjcxdGRKbiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYzRmNWRkNDA3OTRkNjg3ZjI3M2E2ZDkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWM0ZjVkZDQwNzk0ZDY4N2YyNzNhNmQ5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYzRmNWRkNDA3OTRkNjg3ZjI3M2E2ZDkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiREogVHVybiBJdCBVcCIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDUtMTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFQT3NqU0ZTeXFXMjFBRW43MXRkSm4ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJpZCI6IjFRTWdyZTNCSFgxNg==", + "MVpIdFdNVXU2UyIsIm5hbWUiOiJEaW1lbnNpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzc5MzEsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVS0ZUTDE2MDAyNzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzI4cjF4WU5ha1hYd2NRS0lYdTlXancifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yOHIxeFlOYWtYWHdjUUtJWHU5V2p3IiwiaWQiOiIyOHIxeFlOYWtYWHdjUUtJWHU5V2p3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRKIFR1cm4gSXQgVXAiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MjhyMXhZTmFrWFh3Y1FLSVh1OVdqdyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwiaWQiOiIxUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwibmFtZSI6IkRpbWVuc2lvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNCZDFwaHJPWkp1Q2V2OVUwYnpkdEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0JkMXBock9aSnVDZXY5VTBiemR0QSIsImlkIjoiM0JkMXBock9aSnVDZXY5VTBiemR0QSIsIm5hbWUiOiJCZW4gTmlja3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0JkMXBock9aSnVDZXY5VTBiemR0QSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJYNVE4NE50VlNCclNBS3V5WHJuR2gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yWDVRODROdFZTQnJTQUt1eVhybkdoIiwiaWQiOiIyWDVRODROdFZTQnJTQUt1eVhybkdoIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzBmOTk0NjAwY2YzODMyNzA1YWU1NjYyMiJ9LHsiaGVpZ2h0Ig==", + "OjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjBmOTk0NjAwY2YzODMyNzA1YWU1NjYyMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMGY5OTQ2MDBjZjM4MzI3MDVhZTU2NjIyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRKIFR1cm4gSXQgVXAgKEJlbiBOaWNreSBSZW1peCkiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA4LTExIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyWDVRODROdFZTQnJTQUt1eVhybkdoIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwiaWQiOiIxUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwibmFtZSI6IkRpbWVuc2lvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNCZDFwaHJPWkp1Q2V2OVUwYnpkdEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0JkMXBock9aSnVDZXY5VTBiemR0QSIsImlkIjoiM0JkMXBock9aSnVDZXY5VTBiemR0QSIsIm5hbWUiOiJCZW4gTmlja3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0JkMXBock9aSnVDZXY5VTBiemR0QSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxMzgwODgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVUzM5TjIzMDk2MDgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVucVc2UkFXREJ5bnZ2ZTNURFhIOXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81bnFXNlJBV0RCeW52dmUzVERYSDlyIiwiaWQiOiI1bnFXNlJBV0RCeW52dmUzVERYSDlyIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRKIFR1cm4gSXQgVXAgLSBCZW4gTmlja3kgUmVtaXgiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NW5xVzZSQVdEQnludnZlM1REWEg5ciJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZQ==", + "Ijoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJpZCI6IjFRTWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJuYW1lIjoiRGltZW5zaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80aWRkalgwTkVzU1hPV1ZPQmZMN3FOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNGlkZGpYME5Fc1NYT1dWT0JmTDdxTiIsImlkIjoiNGlkZGpYME5Fc1NYT1dWT0JmTDdxTiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYTI1MmM2NTZlNDgwYzRhMmRlY2RmZGQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWEyNTJjNjU2ZTQ4MGM0YTJkZWNkZmRkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYTI1MmM2NTZlNDgwYzRhMmRlY2RmZGQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiREogVHVybiBJdCBVcCAoRGltZW5zaW9uIEhvdXNlIFJlbWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDgtMDQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRpZGRqWDBORXNTWE9XVk9CZkw3cU4ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJpZCI6IjFRTWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJuYW1lIjoiRGltZW5zaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQwMDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVMzOU4yMzEwMTA5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Ig==", + "aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZjamM1SEpqSjlkUkpMQ0FOOVpOVTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82Y2pjNUhKako5ZFJKTENBTjlaTlU4IiwiaWQiOiI2Y2pjNUhKako5ZFJKTENBTjlaTlU4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRKIFR1cm4gSXQgVXAgLSBEaW1lbnNpb24gSG91c2UgUmVtaXgiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NmNqYzVISmpKOWRSSkxDQU45Wk5VOCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwiaWQiOiIxUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwibmFtZSI6IkRpbWVuc2lvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNCZDFwaHJPWkp1Q2V2OVUwYnpkdEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0JkMXBock9aSnVDZXY5VTBiemR0QSIsImlkIjoiM0JkMXBock9aSnVDZXY5VTBiemR0QSIsIm5hbWUiOiJCZW4gTmlja3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0JkMXBock9aSnVDZXY5VTBiemR0QSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJuNzd3cnZVWDJJTEpJdWZ6NGtxaksifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8ybjc3d3J2VVgySUxKSXVmejRrcWpLIiwiaWQiOiIybjc3d3J2VVgySUxKSXVmejRrcWpLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzliNzIxMjUzOGJiZTgxMmI5OWEyNjJiYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5YjcyMTI1MzhiYmU4MTJiOTlhMjYyYmIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTliNzIxMjUzOGJiZTgxMmI5OWEyNjJiYiJ9XSwiaQ==", + "c19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRKIFR1cm4gSXQgVXAgKFJlbWl4ZXMpIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wOC0xOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Mm43N3dydlVYMklMSkl1Zno0a3FqSyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyIsImlkIjoiMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyIsIm5hbWUiOiJEaW1lbnNpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zQmQxcGhyT1pKdUNldjlVMGJ6ZHRBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNCZDFwaHJPWkp1Q2V2OVUwYnpkdEEiLCJpZCI6IjNCZDFwaHJPWkp1Q2V2OVUwYnpkdEEiLCJuYW1lIjoiQmVuIE5pY2t5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNCZDFwaHJPWkp1Q2V2OVUwYnpkdEEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTM4MDg4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVMzOU4yMzA5NjA4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yWGxZZ01SZTFHRG1wcFhQQ090NGd4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMlhsWWdNUmUxR0RtcHBYUENPdDRneCIsImlkIjoiMlhsWWdNUmUxR0RtcHBYUENPdDRneCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJESiBUdXJuIEl0IFVwIC0gQmVuIE5pY2t5IFJlbWl4IiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJYbFlnTVJlMUdEbXBwWFBDT3Q0Z3gifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyIsImlkIjoiMVFNZ3JlM0JIWDE2MVpIdFdNVQ==", + "dTZTIiwibmFtZSI6IkRpbWVuc2lvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNCZDFwaHJPWkp1Q2V2OVUwYnpkdEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0JkMXBock9aSnVDZXY5VTBiemR0QSIsImlkIjoiM0JkMXBock9aSnVDZXY5VTBiemR0QSIsIm5hbWUiOiJCZW4gTmlja3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0JkMXBock9aSnVDZXY5VTBiemR0QSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJuNzd3cnZVWDJJTEpJdWZ6NGtxaksifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8ybjc3d3J2VVgySUxKSXVmejRrcWpLIiwiaWQiOiIybjc3d3J2VVgySUxKSXVmejRrcWpLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzliNzIxMjUzOGJiZTgxMmI5OWEyNjJiYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5YjcyMTI1MzhiYmU4MTJiOTlhMjYyYmIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTliNzIxMjUzOGJiZTgxMmI5OWEyNjJiYiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJESiBUdXJuIEl0IFVwIChSZW1peGVzKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDgtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJuNzd3cnZVWDJJTEpJdWZ6NGtxaksifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJpZCI6IjFRTWdyZTNCSFgxNjFaSHRXTVV1NlMiLCJuYW1lIjoiRGltZW5zaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQwMDAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6ew==", + "ImlzcmMiOiJVUzM5TjIzMTAxMDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFqdGc2cjZVM09LRG9oWU55UmdLb3kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xanRnNnI2VTNPS0RvaFlOeVJnS295IiwiaWQiOiIxanRnNnI2VTNPS0RvaFlOeVJnS295IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRKIFR1cm4gSXQgVXAgLSBEaW1lbnNpb24gSG91c2UgUmVtaXgiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MWp0ZzZyNlUzT0tEb2hZTnlSZ0tveSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwiaWQiOiIxUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwibmFtZSI6IkRpbWVuc2lvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNCZDFwaHJPWkp1Q2V2OVUwYnpkdEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0JkMXBock9aSnVDZXY5VTBiemR0QSIsImlkIjoiM0JkMXBock9aSnVDZXY5VTBiemR0QSIsIm5hbWUiOiJCZW4gTmlja3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0JkMXBock9aSnVDZXY5VTBiemR0QSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJuNzd3cnZVWDJJTEpJdWZ6NGtxaksifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8ybjc3d3J2VVgySUxKSXVmejRrcWpLIiwiaWQiOiIybjc3d3J2VVgySUxKSXVmejRrcWpLIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzliNzIxMjUzOGJiZTgxMmI5OWEyNjJiYiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5YjcyMTI1MzhiYmU4MTJiOTlhMjYyYmIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaQ==", + "bWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWI3MjEyNTM4YmJlODEyYjk5YTI2MmJiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRKIFR1cm4gSXQgVXAgKFJlbWl4ZXMpIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wOC0xOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Mm43N3dydlVYMklMSkl1Zno0a3FqSyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyIsImlkIjoiMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyIsIm5hbWUiOiJEaW1lbnNpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzc5MzEsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVS0ZUTDE2MDAyNzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJkeko0cGhJdG1jVHNBbEl4TG1VUUYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yZHpKNHBoSXRtY1RzQWxJeExtVVFGIiwiaWQiOiIyZHpKNHBoSXRtY1RzQWxJeExtVVFGIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRKIFR1cm4gSXQgVXAiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MmR6SjRwaEl0bWNUc0FsSXhMbVVRRiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwiaWQiOiIxUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwibmFtZSI6IkRpbWVuc2lvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxUU1ncmUzQkhYMTYxWkh0V01VdTZTIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNCZDFwaHJPWkp1Q2V2OVUwYnpkdEEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0JkMXBock9aSnVDZXY5VQ==", + "MGJ6ZHRBIiwiaWQiOiIzQmQxcGhyT1pKdUNldjlVMGJ6ZHRBIiwibmFtZSI6IkJlbiBOaWNreSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozQmQxcGhyT1pKdUNldjlVMGJ6ZHRBIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlg1UTg0TnRWU0JyU0FLdXlYcm5HaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJYNVE4NE50VlNCclNBS3V5WHJuR2giLCJpZCI6IjJYNVE4NE50VlNCclNBS3V5WHJuR2giLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMGY5OTQ2MDBjZjM4MzI3MDVhZTU2NjIyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjBmOTk0NjAwY2YzODMyNzA1YWU1NjYyMiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMGY5OTQ2MDBjZjM4MzI3MDVhZTU2NjIyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRKIFR1cm4gSXQgVXAgKEJlbiBOaWNreSBSZW1peCkiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA4LTExIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyWDVRODROdFZTQnJTQUt1eVhybkdoIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwiaWQiOiIxUU1ncmUzQkhYMTYxWkh0V01VdTZTIiwibmFtZSI6IkRpbWVuc2lvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxUU1ncmUzQkhYMTYxWkh0V01VdTZTIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3NzkzMSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVLRlRMMTYwMDI3MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svN2FnOUlRN3dYRUVNeUhZZ2ZDM0s5ZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzdhZzlJUTd3WEVFTXlIWWdmQzNLOWQiLCJpZCI6IjdhZzlJUTd3WEVFTXlIWWdmQzNLOWQiLCJpc19sb2NhbCI6ZmFsc2UsImlzXw==", + "cGxheWFibGUiOnRydWUsIm5hbWUiOiJESiBUdXJuIEl0IFVwIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdhZzlJUTd3WEVFTXlIWWdmQzNLOWQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyIsImlkIjoiMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyIsIm5hbWUiOiJEaW1lbnNpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRpZGRqWDBORXNTWE9XVk9CZkw3cU4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80aWRkalgwTkVzU1hPV1ZPQmZMN3FOIiwiaWQiOiI0aWRkalgwTkVzU1hPV1ZPQmZMN3FOIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzFhMjUyYzY1NmU0ODBjNGEyZGVjZGZkZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxYTI1MmM2NTZlNDgwYzRhMmRlY2RmZGQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTFhMjUyYzY1NmU0ODBjNGEyZGVjZGZkZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJESiBUdXJuIEl0IFVwIChEaW1lbnNpb24gSG91c2UgUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wOC0wNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NGlkZGpYME5Fc1NYT1dWT0JmTDdxTiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFRTWdyZTNCSFgxNjFaSHRXTVV1NlMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyIsImlkIjoiMVFNZ3JlM0JIWDE2MVpIdFdNVXU2UyIsIm5hbWUiOiJEaW1lbnNpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVFNZ3JlM0JIWA==", + "MTYxWkh0V01VdTZTIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3NzkzMSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVLRlRMMTYwMDI3MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWMzSUNLZTlOU3k3WWdDZjNiMk8ybiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVjM0lDS2U5TlN5N1lnQ2YzYjJPMm4iLCJpZCI6IjVjM0lDS2U5TlN5N1lnQ2YzYjJPMm4iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiREogVHVybiBJdCBVcCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1YzNJQ0tlOU5TeTdZZ0NmM2IyTzJuIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22DJ+Turn+It+Up%22+artist%3A%22Dimension%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZpbm8lMjBCYW5kaXQlMjIlMjBhcnRpc3QlM0ElMjJLJTIwTW90aW9ueiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZRWWRYVG9NbzRYSG5HMUFuRVZaWUoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNlFZZFhUb01vNFhIbkcxQW5FVlpZSiIsImlkIjoiNlFZZFhUb01vNFhIbkcxQW5FVlpZSiIsIm5hbWUiOiJLIE1vdGlvbnoiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlFZZFhUb01vNFhIbkcxQW5FVlpZSiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xaVczYjczWFdQUVNrbkx5SDVrRHJkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFpVzNiNzNYV1BRU2tuTHlINWtEcmQiLCJpZCI6IjFpVzNiNzNYV1BRU2tuTHlINWtEcmQiLCJuYW1lIjoiU29uZ2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFpVzNiNw==", + "M1hXUFFTa25MeUg1a0RyZCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzV3bWtDQmdsWnFkWUZLanVkeDc1SkcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81d21rQ0JnbFpxZFlGS2p1ZHg3NUpHIiwiaWQiOiI1d21rQ0JnbFpxZFlGS2p1ZHg3NUpHIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzI2MmU1OTMyOTBmYmJkY2QxODhhNzQyMCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyNjJlNTkzMjkwZmJiZGNkMTg4YTc0MjAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTI2MmU1OTMyOTBmYmJkY2QxODhhNzQyMCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWaW5vIEJhbmRpdCIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDgtMDQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjV3bWtDQmdsWnFkWUZLanVkeDc1SkcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82UVlkWFRvTW80WEhuRzFBbkVWWllKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZRWWRYVG9NbzRYSG5HMUFuRVZaWUoiLCJpZCI6IjZRWWRYVG9NbzRYSG5HMUFuRVZaWUoiLCJuYW1lIjoiSyBNb3Rpb256IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZRWWRYVG9NbzRYSG5HMUFuRVZaWUoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMWlXM2I3M1hXUFFTa25MeUg1a0RyZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xaVczYjczWFdQUVNrbkx5SDVrRHJkIiwiaWQiOiIxaVczYjczWFdQUVNrbkx5SDVrRHJkIiwibmFtZSI6IlNvbmdlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxaVczYjczWFdQUVNrbkx5SDVrRHJkIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE1MDM0NCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTMzlOMjMwOTMzNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMA==", + "MGM2SllndUtsZnE1eU9sTG9JVGxIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDBjNkpZZ3VLbGZxNXlPbExvSVRsSCIsImlkIjoiMDBjNkpZZ3VLbGZxNXlPbExvSVRsSCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWaW5vIEJhbmRpdCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowMGM2SllndUtsZnE1eU9sTG9JVGxIIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Vino+Bandit%22+artist%3A%22K+Motionz%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Troglodyte%22%20artist%3A%22Culture%20Shock%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lp2VnIRXXpC9Wz7hSX6RE"},"href":"https://api.spotify.com/v1/artists/6lp2VnIRXXpC9Wz7hSX6RE","id":"6lp2VnIRXXpC9Wz7hSX6RE","name":"Culture Shock","type":"artist","uri":"spotify:artist:6lp2VnIRXXpC9Wz7hSX6RE"}],"external_urls":{"spotify":"https://open.spotify.com/album/0rfL0EECJAxoPY1HGVaH0v"},"href":"https://api.spotify.com/v1/albums/0rfL0EECJAxoPY1HGVaH0v","id":"0rfL0EECJAxoPY1HGVaH0v","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c01e65c2de35e4031616b3ef"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c01e65c2de35e4031616b3ef"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c01e65c2de35e4031616b3ef"}],"is_playable":true,"name":"I Remember / Troglodyte","release_date":"2012-07-02","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:0rfL0EECJAxoPY1HGVaH0v"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lp2VnIRXXpC9Wz7hSX6RE"},"href":"https://api.spotify.com/v1/artists/6lp2VnIRXXpC9Wz7hSX6RE","id":"6lp2VnIRXXpC9Wz7hSX6RE","name":"Culture Shock","type":"artist","uri":"spotify:artist:6lp2VnIRXXpC9Wz7hSX6RE"}],"disc_number":1,"duration_ms":315953,"explicit":false,"external_ids":{"isrc":"GBBZH1294007"},"external_urls":{"spotify":"https://open.spotify.com/track/6wotas1A8sN6oTTqmBzbIS"},"href":"https://api.spotify.com/v1/tracks/6wotas1A8sN6oTTqmBzbIS","id":"6wotas1A8sN6oTTqmBzbIS","is_local":false,"is_playable":true,"name":"Troglodyte","track_number":2,"type":"track","uri":"spotify:track:6wotas1A8sN6oTTqmBzbIS"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lp2VnIRXXpC9Wz7hSX6RE"},"href":"https://api.spotify.com/v1/artists/6lp2VnIRXXpC9Wz7hSX6RE","id":"6lp2VnIRXXpC9Wz7hSX6RE","name":"Culture Shock","type":"artist","uri":"spotify:artist:6lp2VnIRXXpC9Wz7hSX6RE"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ATlTgwRvm7rR73Aa3KDfy"},"href":"https://api.spotify.com/v1/albums/5ATlTgwRvm7rR73Aa3KDfy","id":"5ATlTgwRvm7rR73Aa3KDfy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273087a7e049875a1ed8894c631"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02087a7e049875a1ed8894c631"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851087a7e049875a1ed8894c631"}],"is_playable":true,"name":"Raindrops / Troglodyte VIP","release_date":"2014-12-14","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:5ATlTgwRvm7rR73Aa3KDfy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lp2VnIRXXpC9Wz7hSX6RE"},"href":"https://api.spotify.com/v1/artists/6lp2VnIRXXpC9Wz7hSX6RE","id":"6lp2VnIRXXpC9Wz7hSX6RE","name":"Culture Shock","type":"artist","uri":"spotify:artist:6lp2VnIRXXpC9Wz7hSX6RE"}],"disc_number":1,"duration_ms":264827,"explicit":false,"external_ids":{"isrc":"GBBZH1400114"},"external_urls":{"spotify":"https://open.spotify.com/track/2bTdYZ28V7ad190X0kNDw8"},"href":"https://api.spotify.com/v1/tracks/2bTdYZ28V7ad190X0kNDw8","id":"2bTdYZ28V7ad190X0kNDw8","is_local":false,"is_playable":true,"name":"Troglodyte VIP","track_number":2,"type":"track","uri":"spotify:track:2bTdYZ28V7ad190X0kNDw8"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1bZGO4TZR4GvSf27zAzws6"},"href":"https://api.spotify.com/v1/albums/1bZGO4TZR4GvSf27zAzws6","id":"1bZGO4TZR4GvSf27zAzws6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736eb105bbd06c40e6a6eb6204"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026eb105bbd06c40e6a6eb6204"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516eb105bbd06c40e6a6eb6204"}],"is_playable":true,"name":"Ram Drum & Bass Annual 2012","release_date":"2012-12-09","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:1bZGO4TZR4GvSf27zAzws6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lp2VnIRXXpC9Wz7hSX6RE"},"href":"https://api.spotify.com/v1/artists/6lp2VnIRXXpC9Wz7hSX6RE","id":"6lp2VnIRXXpC9Wz7hSX6RE","name":"Culture Shock","type":"artist","uri":"spotify:artist:6lp2VnIRXXpC9Wz7hSX6RE"}],"disc_number":1,"duration_ms":315953,"explicit":false,"external_ids":{"isrc":"GBBZH1294007"},"external_urls":{"spotify":"https://open.spotify.com/track/2RmZIpaXufsah0XDe1R37G"},"href":"https://api.spotify.com/v1/tracks/2RmZIpaXufsah0XDe1R37G","id":"2RmZIpaXufsah0XDe1R37G","is_local":false,"is_playable":true,"name":"Troglodyte","track_number":7,"type":"track","uri":"spotify:track:2RmZIpaXufsah0XDe1R37G"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0umDTRGYujQH31KZq9FdrU"},"href":"https://api.spotify.com/v1/artists/0umDTRGYujQH31KZq9FdrU","id":"0umDTRGYujQH31KZq9FdrU","name":"Loadstar","type":"artist","uri":"spotify:artist:0umDTRGYujQH31KZq9FdrU"}],"external_urls":{"spotify":"https://open.spotify.com/album/4RCVf26rDSBaPF0A1NtBQ5"},"href":"https://api.spotify.com/v1/albums/4RCVf26rDSBaPF0A1NtBQ5","id":"4RCVf26rDSBaPF0A1NtBQ5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d13f3b144ba1c2d2bdad1985"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d13f3b144ba1c2d2bdad1985"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d13f3b144ba1c2d2bdad1985"}],"is_playable":true,"name":"RAMlife Loadstar","release_date":"2014-08-18","release_date_precision":"day","total_tracks":38,"type":"album","uri":"spotify:album:4RCVf26rDSBaPF0A1NtBQ5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lp2VnIRXXpC9Wz7hSX6RE"},"href":"https://api.spotify.com/v1/artists/6lp2VnIRXXpC9Wz7hSX6RE","id":"6lp2VnIRXXpC9Wz7hSX6RE","name":"Culture Shock","type":"artist","uri":"spotify:artist:6lp2VnIRXXpC9Wz7hSX6RE"}],"disc_number":1,"duration_ms":315953,"explicit":false,"external_ids":{"isrc":"GBBZH1294007"},"external_urls":{"spotify":"https://open.spotify.com/track/7MrJWV9tvFs28pCVVLXZMW"},"href":"https://api.spotify.com/v1/tracks/7MrJWV9tvFs28pCVVLXZMW","id":"7MrJWV9tvFs28pCVVLXZMW","is_local":false,"is_playable":true,"name":"Troglodyte","track_number":33,"type":"track","uri":"spotify:track:7MrJWV9tvFs28pCVVLXZMW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Saj39tbcH2t5C5hugWjGk"},"href":"https://api.spotify.com/v1/albums/0Saj39tbcH2t5C5hugWjGk","id":"0Saj39tbcH2t5C5hugWjGk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ae25236fd6e83c1b90796a6e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ae25236fd6e83c1b90796a6e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ae25236fd6e83c1b90796a6e"}],"is_playable":true,"name":"RAM 25","release_date":"2017-12-15","release_date_precision":"day","total_tracks":41,"type":"album","uri":"spotify:album:0Saj39tbcH2t5C5hugWjGk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6lp2VnIRXXpC9Wz7hSX6RE"},"href":"https://api.spotify.com/v1/artists/6lp2VnIRXXpC9Wz7hSX6RE","id":"6lp2VnIRXXpC9Wz7hSX6RE","name":"Culture Shock","type":"artist","uri":"spotify:artist:6lp2VnIRXXpC9Wz7hSX6RE"}],"disc_number":1,"duration_ms":315953,"explicit":false,"external_ids":{"isrc":"GBBZH1200025"},"external_urls":{"spotify":"https://open.spotify.com/track/0rErHJR8Jiuo4ILuUC1Fob"},"href":"https://api.spotify.com/v1/tracks/0rErHJR8Jiuo4ILuUC1Fob","id":"0rErHJR8Jiuo4ILuUC1Fob","is_local":false,"is_playable":true,"name":"Troglodyte","track_number":11,"type":"track","uri":"spotify:track:0rErHJR8Jiuo4ILuUC1Fob"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRyb2dsb2R5dGUlMjIlMjBhcnRpc3QlM0ElMjJDdWx0dXJlJTIwU2hvY2slMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHAyVm5JUlhYcEM5V3o3aFNYNlJFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZscDJWbklSWFhwQzlXejdoU1g2UkUiLCJpZCI6IjZscDJWbklSWFhwQzlXejdoU1g2UkUiLCJuYW1lIjoiQ3VsdHVyZSBTaG9jayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHAyVm5JUlhYcEM5V3o3aFNYNlJFIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMHJmTDBFRUNKQXhvUFkxSEdWYUgwdiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzByZkwwRUVDSkF4b1BZMUhHVmFIMHYiLCJpZCI6IjByZkwwRUVDSkF4b1BZMUhHVmFIMHYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbg==", + "LmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjMDFlNjVjMmRlMzVlNDAzMTYxNmIzZWYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzAxZTY1YzJkZTM1ZTQwMzE2MTZiM2VmIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjMDFlNjVjMmRlMzVlNDAzMTYxNmIzZWYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSBSZW1lbWJlciAvIFRyb2dsb2R5dGUiLCJyZWxlYXNlX2RhdGUiOiIyMDEyLTA3LTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowcmZMMEVFQ0pBeG9QWTFIR1ZhSDB2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmxwMlZuSVJYWHBDOVd6N2hTWDZSRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bHAyVm5JUlhYcEM5V3o3aFNYNlJFIiwiaWQiOiI2bHAyVm5JUlhYcEM5V3o3aFNYNlJFIiwibmFtZSI6IkN1bHR1cmUgU2hvY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NmxwMlZuSVJYWHBDOVd6N2hTWDZSRSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMTU5NTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkJaSDEyOTQwMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZ3b3RhczFBOHNONm9UVHFtQnpiSVMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82d290YXMxQThzTjZvVFRxbUJ6YklTIiwiaWQiOiI2d290YXMxQThzTjZvVFRxbUJ6YklTIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRyb2dsb2R5dGUiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NndvdGFzMUE4c042b1RUcW1CemJJUyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmxwMlZuSVJYWHBDOVd6N2hTWDZSRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bHAyVm5JUlhYcEM5V3o3aFNYNlJFIiwiaWQiOiI2bHAyVm5JUlhYcEM5V3o3aFNYNlJFIiwibmFtZSI6IkN1bHR1cmUgU2hvY2siLA==", + "InR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHAyVm5JUlhYcEM5V3o3aFNYNlJFIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUFUbFRnd1J2bTdyUjczQWEzS0RmeSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVBVGxUZ3dSdm03clI3M0FhM0tEZnkiLCJpZCI6IjVBVGxUZ3dSdm03clI3M0FhM0tEZnkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDg3YTdlMDQ5ODc1YTFlZDg4OTRjNjMxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA4N2E3ZTA0OTg3NWExZWQ4ODk0YzYzMSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDg3YTdlMDQ5ODc1YTFlZDg4OTRjNjMxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJhaW5kcm9wcyAvIFRyb2dsb2R5dGUgVklQIiwicmVsZWFzZV9kYXRlIjoiMjAxNC0xMi0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NUFUbFRnd1J2bTdyUjczQWEzS0RmeSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZscDJWbklSWFhwQzlXejdoU1g2UkUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNmxwMlZuSVJYWHBDOVd6N2hTWDZSRSIsImlkIjoiNmxwMlZuSVJYWHBDOVd6N2hTWDZSRSIsIm5hbWUiOiJDdWx0dXJlIFNob2NrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZscDJWbklSWFhwQzlXejdoU1g2UkUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjY0ODI3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JCWkgxNDAwMTE0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yYlRkWVoyOFY3YWQxOTBYMGtORHc4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMmJUZFlaMjhWN2FkMTkwWDBrTkR3OCIsImlkIjoiMmJUZFlaMjhWN2FkMTkwWDBrTkR3OCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUcm9nbG9keXRlIFZJUCIsInRyYWNrX251bWJlciI6MiwidA==", + "eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJiVGRZWjI4VjdhZDE5MFgwa05EdzgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMWJaR080VFpSNEd2U2YyN3pBendzNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFiWkdPNFRaUjRHdlNmMjd6QXp3czYiLCJpZCI6IjFiWkdPNFRaUjRHdlNmMjd6QXp3czYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmViMTA1YmJkMDZjNDBlNmE2ZWI2MjA0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZlYjEwNWJiZDA2YzQwZTZhNmViNjIwNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmViMTA1YmJkMDZjNDBlNmE2ZWI2MjA0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJhbSBEcnVtICYgQmFzcyBBbm51YWwgMjAxMiIsInJlbGVhc2VfZGF0ZSI6IjIwMTItMTItMDkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxYlpHTzRUWlI0R3ZTZjI3ekF6d3M2In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmxwMlZuSVJYWHBDOVd6N2hTWDZSRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bHAyVm5JUlhYcEM5V3o3aFNYNlJFIiwiaWQiOiI2bHAyVm5JUlhYcEM5V3o3aFNYNlJFIiwibmFtZSI6IkN1bHR1cmUgU2hvY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NmxwMlZuSVJYWHBDOVd6N2hTWDZSRSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMTU5NQ==", + "MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQlpIMTI5NDAwNyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMlJtWklwYVh1ZnNhaDBYRGUxUjM3RyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJSbVpJcGFYdWZzYWgwWERlMVIzN0ciLCJpZCI6IjJSbVpJcGFYdWZzYWgwWERlMVIzN0ciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHJvZ2xvZHl0ZSIsInRyYWNrX251bWJlciI6NywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyUm1aSXBhWHVmc2FoMFhEZTFSMzdHIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzB1bURUUkdZdWpRSDMxS1pxOUZkclUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMHVtRFRSR1l1alFIMzFLWnE5RmRyVSIsImlkIjoiMHVtRFRSR1l1alFIMzFLWnE5RmRyVSIsIm5hbWUiOiJMb2Fkc3RhciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowdW1EVFJHWXVqUUgzMUtacTlGZHJVIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFJDVmYyNnJEU0JhUEYwQTFOdEJRNSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRSQ1ZmMjZyRFNCYVBGMEExTnRCUTUiLCJpZCI6IjRSQ1ZmMjZyRFNCYVBGMEExTnRCUTUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDEzZjNiMTQ0YmExYzJkMmJkYWQxOTg1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQxM2YzYjE0NGJhMWMyZDJiZGFkMTk4NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDEzZjNiMTQ0YmExYzJkMmJkYWQxOTg1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJBTWxpZmUgTG9hZHN0YXIiLCJyZWxlYXNlX2RhdGUiOiIyMDE0LTA4LTE4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFJDVmYyNnJEU0JhUEYwQTFOdEJRNSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbA==", + "X3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmxwMlZuSVJYWHBDOVd6N2hTWDZSRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bHAyVm5JUlhYcEM5V3o3aFNYNlJFIiwiaWQiOiI2bHAyVm5JUlhYcEM5V3o3aFNYNlJFIiwibmFtZSI6IkN1bHR1cmUgU2hvY2siLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NmxwMlZuSVJYWHBDOVd6N2hTWDZSRSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMTU5NTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkJaSDEyOTQwMDcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzdNckpXVjl0dkZzMjhwQ1ZWTFhaTVcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83TXJKV1Y5dHZGczI4cENWVkxYWk1XIiwiaWQiOiI3TXJKV1Y5dHZGczI4cENWVkxYWk1XIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRyb2dsb2R5dGUiLCJ0cmFja19udW1iZXIiOjMzLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdNckpXVjl0dkZzMjhwQ1ZWTFhaTVcifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMFNhajM5dGJjSDJ0NUM1aHVnV2pHayJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBTYWozOXRiY0gydDVDNWh1Z1dqR2siLCJpZCI6IjBTYWozOXRiY0gydDVDNWh1Z1dqR2siLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYWUyNTIzNmZkNmU4M2MxYjkwNzk2YTZlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmFlMjUyMzZmZDZlODNjMWI5MDc5NmE2ZSJ9LA==", + "eyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhZTI1MjM2ZmQ2ZTgzYzFiOTA3OTZhNmUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUkFNIDI1IiwicmVsZWFzZV9kYXRlIjoiMjAxNy0xMi0xNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBTYWozOXRiY0gydDVDNWh1Z1dqR2sifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bHAyVm5JUlhYcEM5V3o3aFNYNlJFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZscDJWbklSWFhwQzlXejdoU1g2UkUiLCJpZCI6IjZscDJWbklSWFhwQzlXejdoU1g2UkUiLCJuYW1lIjoiQ3VsdHVyZSBTaG9jayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bHAyVm5JUlhYcEM5V3o3aFNYNlJFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMxNTk1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQlpIMTIwMDAyNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMHJFckhKUjhKaXVvNElMdVVDMUZvYiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzByRXJISlI4Sml1bzRJTHVVQzFGb2IiLCJpZCI6IjByRXJISlI4Sml1bzRJTHVVQzFGb2IiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHJvZ2xvZHl0ZSIsInRyYWNrX251bWJlciI6MTEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MHJFckhKUjhKaXVvNElMdVVDMUZvYiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Troglodyte%22+artist%3A%22Culture+Shock%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Solar%20System%22%20artist%3A%22Sub%20Focus%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":5,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"external_urls":{"spotify":"https://open.spotify.com/album/3b4pq3F6MCKrIr6Pug0iYG"},"href":"https://api.spotify.com/v1/albums/3b4pq3F6MCKrIr6Pug0iYG","id":"3b4pq3F6MCKrIr6Pug0iYG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e629cab6558cb496b60e2178"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e629cab6558cb496b60e2178"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e629cab6558cb496b60e2178"}],"is_playable":true,"name":"Solar System / Siren","release_date":"2019-07-26","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:3b4pq3F6MCKrIr6Pug0iYG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/5cRDn5aGMLvWsldoRmOOz0"},"href":"https://api.spotify.com/v1/tracks/5cRDn5aGMLvWsldoRmOOz0","id":"5cRDn5aGMLvWsldoRmOOz0","is_local":false,"is_playable":true,"name":"Solar System","track_number":1,"type":"track","uri":"spotify:track:5cRDn5aGMLvWsldoRmOOz0"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4SC40wRJEV5xR5pCPnP3OP"},"href":"https://api.spotify.com/v1/albums/4SC40wRJEV5xR5pCPnP3OP","id":"4SC40wRJEV5xR5pCPnP3OP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27390fa82cec5006032cd4b8b4c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0290fa82cec5006032cd4b8b4c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485190fa82cec5006032cd4b8b4c"}],"is_playable":true,"name":"Beats & Chill","release_date":"2026-07-24","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:4SC40wRJEV5xR5pCPnP3OP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/5P6EZWSW8CyjEwtnK33fcC"},"href":"https://api.spotify.com/v1/tracks/5P6EZWSW8CyjEwtnK33fcC","id":"5P6EZWSW8CyjEwtnK33fcC","is_local":false,"is_playable":true,"name":"Solar System","track_number":30,"type":"track","uri":"spotify:track:5P6EZWSW8CyjEwtnK33fcC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0VmnXAGw4QbWcj9j5UemdA"},"href":"https://api.spotify.com/v1/albums/0VmnXAGw4QbWcj9j5UemdA","id":"0VmnXAGw4QbWcj9j5UemdA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730b4a43e40199ff712ebb97da"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020b4a43e40199ff712ebb97da"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510b4a43e40199ff712ebb97da"}],"is_playable":true,"name":"Punchispun: Mix Electr\u00f3nica y Techno","release_date":"2024-06-14","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:0VmnXAGw4QbWcj9j5UemdA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/2eO2F4lY6IMEZU8MEGYgGR"},"href":"https://api.spotify.com/v1/tracks/2eO2F4lY6IMEZU8MEGYgGR","id":"2eO2F4lY6IMEZU8MEGYgGR","is_local":false,"is_playable":true,"name":"Solar System","track_number":3,"type":"track","uri":"spotify:track:2eO2F4lY6IMEZU8MEGYgGR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4i9hzDuxRVH4JAocxEPoqz"},"href":"https://api.spotify.com/v1/albums/4i9hzDuxRVH4JAocxEPoqz","id":"4i9hzDuxRVH4JAocxEPoqz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376d8a758bdd37b7587f7184a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276d8a758bdd37b7587f7184a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176d8a758bdd37b7587f7184a"}],"is_playable":true,"name":"ELECTRO DANCE 2023","release_date":"2023-10-03","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:4i9hzDuxRVH4JAocxEPoqz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/3yuw5MB0HhsxmGvhAPUp0Y"},"href":"https://api.spotify.com/v1/tracks/3yuw5MB0HhsxmGvhAPUp0Y","id":"3yuw5MB0HhsxmGvhAPUp0Y","is_local":false,"is_playable":true,"name":"Solar System","track_number":5,"type":"track","uri":"spotify:track:3yuw5MB0HhsxmGvhAPUp0Y"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5eI1MCyVvoBAihHWow8SoS"},"href":"https://api.spotify.com/v1/albums/5eI1MCyVvoBAihHWow8SoS","id":"5eI1MCyVvoBAihHWow8SoS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bc7a14670986091b0e99165e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bc7a14670986091b0e99165e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bc7a14670986091b0e99165e"}],"is_playable":true,"name":"Drum & Bass 2025","release_date":"2025-01-22","release_date_precision":"day","total_tracks":53,"type":"album","uri":"spotify:album:5eI1MCyVvoBAihHWow8SoS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/4fDkWCJgJF7W11O1AJ6k5S"},"href":"https://api.spotify.com/v1/tracks/4fDkWCJgJF7W11O1AJ6k5S","id":"4fDkWCJgJF7W11O1AJ6k5S","is_local":false,"is_playable":true,"name":"Solar System","track_number":13,"type":"track","uri":"spotify:track:4fDkWCJgJF7W11O1AJ6k5S"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Solar%20System%22%20artist%3A%22Sub%20Focus%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":5,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"external_urls":{"spotify":"https://open.spotify.com/album/3b4pq3F6MCKrIr6Pug0iYG"},"href":"https://api.spotify.com/v1/albums/3b4pq3F6MCKrIr6Pug0iYG","id":"3b4pq3F6MCKrIr6Pug0iYG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e629cab6558cb496b60e2178"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e629cab6558cb496b60e2178"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e629cab6558cb496b60e2178"}],"is_playable":true,"name":"Solar System / Siren","release_date":"2019-07-26","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:3b4pq3F6MCKrIr6Pug0iYG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/5cRDn5aGMLvWsldoRmOOz0"},"href":"https://api.spotify.com/v1/tracks/5cRDn5aGMLvWsldoRmOOz0","id":"5cRDn5aGMLvWsldoRmOOz0","is_local":false,"is_playable":true,"name":"Solar System","track_number":1,"type":"track","uri":"spotify:track:5cRDn5aGMLvWsldoRmOOz0"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4SC40wRJEV5xR5pCPnP3OP"},"href":"https://api.spotify.com/v1/albums/4SC40wRJEV5xR5pCPnP3OP","id":"4SC40wRJEV5xR5pCPnP3OP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27390fa82cec5006032cd4b8b4c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0290fa82cec5006032cd4b8b4c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485190fa82cec5006032cd4b8b4c"}],"is_playable":true,"name":"Beats & Chill","release_date":"2026-07-24","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:4SC40wRJEV5xR5pCPnP3OP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/5P6EZWSW8CyjEwtnK33fcC"},"href":"https://api.spotify.com/v1/tracks/5P6EZWSW8CyjEwtnK33fcC","id":"5P6EZWSW8CyjEwtnK33fcC","is_local":false,"is_playable":true,"name":"Solar System","track_number":30,"type":"track","uri":"spotify:track:5P6EZWSW8CyjEwtnK33fcC"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0VmnXAGw4QbWcj9j5UemdA"},"href":"https://api.spotify.com/v1/albums/0VmnXAGw4QbWcj9j5UemdA","id":"0VmnXAGw4QbWcj9j5UemdA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730b4a43e40199ff712ebb97da"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020b4a43e40199ff712ebb97da"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510b4a43e40199ff712ebb97da"}],"is_playable":true,"name":"Punchispun: Mix Electr\u00f3nica y Techno","release_date":"2024-06-14","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:0VmnXAGw4QbWcj9j5UemdA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/2eO2F4lY6IMEZU8MEGYgGR"},"href":"https://api.spotify.com/v1/tracks/2eO2F4lY6IMEZU8MEGYgGR","id":"2eO2F4lY6IMEZU8MEGYgGR","is_local":false,"is_playable":true,"name":"Solar System","track_number":3,"type":"track","uri":"spotify:track:2eO2F4lY6IMEZU8MEGYgGR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/4i9hzDuxRVH4JAocxEPoqz"},"href":"https://api.spotify.com/v1/albums/4i9hzDuxRVH4JAocxEPoqz","id":"4i9hzDuxRVH4JAocxEPoqz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27376d8a758bdd37b7587f7184a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0276d8a758bdd37b7587f7184a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485176d8a758bdd37b7587f7184a"}],"is_playable":true,"name":"ELECTRO DANCE 2023","release_date":"2023-10-03","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:4i9hzDuxRVH4JAocxEPoqz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/3yuw5MB0HhsxmGvhAPUp0Y"},"href":"https://api.spotify.com/v1/tracks/3yuw5MB0HhsxmGvhAPUp0Y","id":"3yuw5MB0HhsxmGvhAPUp0Y","is_local":false,"is_playable":true,"name":"Solar System","track_number":5,"type":"track","uri":"spotify:track:3yuw5MB0HhsxmGvhAPUp0Y"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5eI1MCyVvoBAihHWow8SoS"},"href":"https://api.spotify.com/v1/albums/5eI1MCyVvoBAihHWow8SoS","id":"5eI1MCyVvoBAihHWow8SoS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bc7a14670986091b0e99165e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bc7a14670986091b0e99165e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bc7a14670986091b0e99165e"}],"is_playable":true,"name":"Drum & Bass 2025","release_date":"2025-01-22","release_date_precision":"day","total_tracks":53,"type":"album","uri":"spotify:album:5eI1MCyVvoBAihHWow8SoS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":288000,"explicit":false,"external_ids":{"isrc":"GBUM71903244"},"external_urls":{"spotify":"https://open.spotify.com/track/4fDkWCJgJF7W11O1AJ6k5S"},"href":"https://api.spotify.com/v1/tracks/4fDkWCJgJF7W11O1AJ6k5S","id":"4fDkWCJgJF7W11O1AJ6k5S","is_local":false,"is_playable":true,"name":"Solar System","track_number":13,"type":"track","uri":"spotify:track:4fDkWCJgJF7W11O1AJ6k5S"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Solar+System%22+artist%3A%22Sub+Focus%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJBQ0tCT05FJTIyJTIwYXJ0aXN0JTNBJTIyQ2hhc2UlMjAlMjYlMjBTdGF0dXMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zak5rYU9YYXNvYzdSc3hkY2h2RVZxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNqTmthT1hhc29jN1JzeGRjaHZFVnEiLCJpZCI6IjNqTmthT1hhc29jN1JzeGRjaHZFVnEiLCJuYW1lIjoiQ2hhc2UgJiBTdGF0dXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2pOa2FPWGFzb2M3UnN4ZGNodkVWcSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZCI6IjJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydA==", + "aXN0OjJTclNkU3ZwbWlucW1TdEdFTENTTmQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zNjRSR2E4eUwyWnNJV2xMb05TeklZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMzY0UkdhOHlMMlpzSVdsTG9OU3pJWSIsImlkIjoiMzY0UkdhOHlMMlpzSVdsTG9OU3pJWSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYzdlOTMwMDFiODQ2YjEyYWUyYzdlM2IifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWM3ZTkzMDAxYjg0NmIxMmFlMmM3ZTNiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYzdlOTMwMDFiODQ2YjEyYWUyYzdlM2IifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQkFDS0JPTkUiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTA4LTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozNjRSR2E4eUwyWnNJV2xMb05TeklZIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2pOa2FPWGFzb2M3UnN4ZGNodkVWcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zak5rYU9YYXNvYzdSc3hkY2h2RVZxIiwiaWQiOiIzak5rYU9YYXNvYzdSc3hkY2h2RVZxIiwibmFtZSI6IkNoYXNlICYgU3RhdHVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNqTmthT1hhc29jN1JzeGRjaHZFVnEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjY0NDgsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MjQwNDM2OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeQ==", + "LmNvbS90cmFjay8zSHJIaFRXb25CcUY0bURhc2k4eHZDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0hySGhUV29uQnFGNG1EYXNpOHh2QyIsImlkIjoiM0hySGhUV29uQnFGNG1EYXNpOHh2QyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCQUNLQk9ORSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozSHJIaFRXb25CcUY0bURhc2k4eHZDIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zak5rYU9YYXNvYzdSc3hkY2h2RVZxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNqTmthT1hhc29jN1JzeGRjaHZFVnEiLCJpZCI6IjNqTmthT1hhc29jN1JzeGRjaHZFVnEiLCJuYW1lIjoiQ2hhc2UgJiBTdGF0dXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2pOa2FPWGFzb2M3UnN4ZGNodkVWcSJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJpZCI6IjJTclNkU3ZwbWlucW1TdEdFTENTTmQiLCJuYW1lIjoiU3Rvcm16eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyU3JTZFN2cG1pbnFtU3RHRUxDU05kIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMVZuM0VZU0hUOFpkU2pROU5oVjlMSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFWbjNFWVNIVDhaZFNqUTlOaFY5TEoiLCJpZCI6IjFWbjNFWVNIVDhaZFNqUTlOaFY5TEoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNGY1YWI1MDgyYTMxNDk1MjBiMGE0YzU0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjRmNWFiNTA4MmEzMTQ5NTIwYjBhNGM1NCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNGY1YWI1MDgyYTMxNDk1MjBiMGE0YzU0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJBQ0tCT05FIiwicmVsZWFzZV9kYQ==", + "dGUiOiIyMDI0LTA4LTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxVm4zRVlTSFQ4WmRTalE5TmhWOUxKIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2pOa2FPWGFzb2M3UnN4ZGNodkVWcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zak5rYU9YYXNvYzdSc3hkY2h2RVZxIiwiaWQiOiIzak5rYU9YYXNvYzdSc3hkY2h2RVZxIiwibmFtZSI6IkNoYXNlICYgU3RhdHVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNqTmthT1hhc29jN1JzeGRjaHZFVnEifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwiaWQiOiIyU3JTZFN2cG1pbnFtU3RHRUxDU05kIiwibmFtZSI6IlN0b3JtenkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlNyU2RTdnBtaW5xbVN0R0VMQ1NOZCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjYzNjMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlVNNzI0MDQzNjkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJOMTNMcjBkcGlpcldhSlZMY05sNGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yTjEzTHIwZHBpaXJXYUpWTGNObDRpIiwiaWQiOiIyTjEzTHIwZHBpaXJXYUpWTGNObDRpIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJBQ0tCT05FIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJOMTNMcjBkcGlpcldhSlZMY05sNGkifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22BACKBONE%22+artist%3A%22Chase+%26+Status%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZhbGwlMjBUbyUyMFRoZSUyMER1c3QlMjIlMjBhcnRpc3QlM0ElMjJNZXRyaWslMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsImlkIjoiMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsIm5hbWUiOiJNZXRyaWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk5DRXRYNDBpOWxMTnBUZzJYNTU4MyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFFQTg2d0J4dmZONGJtem56aFVSdmQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xRUE4NndCeHZmTjRibXpuemhVUnZkIiwiaWQiOiIxRUE4NndCeHZmTjRibXpuemhVUnZkIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaQ==", + "bWFnZS9hYjY3NjE2ZDAwMDBiMjczMjY4ZDMyOGNkN2ZhYTAwYTRjNjNhZmU4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI2OGQzMjhjZDdmYWEwMGE0YzYzYWZlOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjY4ZDMyOGNkN2ZhYTAwYTRjNjNhZmU4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkF3YWtlIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0xMS0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFFQTg2d0J4dmZONGJtem56aFVSdmQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTkNFdFg0MGk5bExOcFRnMlg1NTgzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMiLCJpZCI6IjJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMiLCJuYW1lIjoiTWV0cmlrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjIzNDQ4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JDSlkyMzAwNDIxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wSkxCdXNrWm9hTWQxcFlIWGV6b0ZJIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMEpMQnVza1pvYU1kMXBZSFhlem9GSSIsImlkIjoiMEpMQnVza1pvYU1kMXBZSFhlem9GSSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGYWxsIFRvIFRoZSBEdXN0IiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBKTEJ1c2tab2FNZDFwWUhYZXpvRkkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsImlkIjoiMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsIm5hbWUiOiJNZXRyaWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeQ==", + "OmFydGlzdDoyTkNFdFg0MGk5bExOcFRnMlg1NTgzIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlB3RmxJN1VXZjg4bWN4akttNXR3TCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJQd0ZsSTdVV2Y4OG1jeGpLbTV0d0wiLCJpZCI6IjJQd0ZsSTdVV2Y4OG1jeGpLbTV0d0wiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzE4OTU1YzhkOTc4NmQ3NGIyMjJlMzllIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjcxODk1NWM4ZDk3ODZkNzRiMjIyZTM5ZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzE4OTU1YzhkOTc4NmQ3NGIyMjJlMzllIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZhbGwgVG8gVGhlIER1c3QiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA2LTAyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyUHdGbEk3VVdmODhtY3hqS201dHdMIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTkNFdFg0MGk5bExOcFRnMlg1NTgzIiwiaWQiOiIyTkNFdFg0MGk5bExOcFRnMlg1NTgzIiwibmFtZSI6Ik1ldHJpayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTkNFdFg0MGk5bExOcFRnMlg1NTgzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyMzQ0OCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQ0pZMjMwMDQyMSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNzRQSHNmd0tpMTNRTEpBYkhQVmdRZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzc0UEhzZndLaTEzUUxKQWJIUFZnUWYiLCJpZCI6Ijc0UEhzZndLaTEzUUxKQWJIUFZnUWYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmFsbCBUbyBUaGUgRHVzdCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3NFBIc2Z3S2kxMw==", + "UUxKQWJIUFZnUWYifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Fall+To+The+Dust%22+artist%3A%22Metrik%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Hackers%22%20artist%3A%22Metrik%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":4,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2NCEtX40i9lLNpTg2X5583"},"href":"https://api.spotify.com/v1/artists/2NCEtX40i9lLNpTg2X5583","id":"2NCEtX40i9lLNpTg2X5583","name":"Metrik","type":"artist","uri":"spotify:artist:2NCEtX40i9lLNpTg2X5583"}],"external_urls":{"spotify":"https://open.spotify.com/album/2oBOJF0blU6mVYnKiB7wmI"},"href":"https://api.spotify.com/v1/albums/2oBOJF0blU6mVYnKiB7wmI","id":"2oBOJF0blU6mVYnKiB7wmI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733b36d224aceca0c023d15d8c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023b36d224aceca0c023d15d8c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513b36d224aceca0c023d15d8c"}],"is_playable":true,"name":"Ex Machina","release_date":"2020-06-26","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:2oBOJF0blU6mVYnKiB7wmI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2NCEtX40i9lLNpTg2X5583"},"href":"https://api.spotify.com/v1/artists/2NCEtX40i9lLNpTg2X5583","id":"2NCEtX40i9lLNpTg2X5583","name":"Metrik","type":"artist","uri":"spotify:artist:2NCEtX40i9lLNpTg2X5583"}],"disc_number":1,"duration_ms":253793,"explicit":false,"external_ids":{"isrc":"GBCJY1900061"},"external_urls":{"spotify":"https://open.spotify.com/track/40SPQDLYs5OAjnEErkpC43"},"href":"https://api.spotify.com/v1/tracks/40SPQDLYs5OAjnEErkpC43","id":"40SPQDLYs5OAjnEErkpC43","is_local":false,"is_playable":true,"name":"Hackers","track_number":5,"type":"track","uri":"spotify:track:40SPQDLYs5OAjnEErkpC43"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7pDBRy9uWy1zq5b0uXIABQ"},"href":"https://api.spotify.com/v1/artists/7pDBRy9uWy1zq5b0uXIABQ","id":"7pDBRy9uWy1zq5b0uXIABQ","name":"Nu:Tone","type":"artist","uri":"spotify:artist:7pDBRy9uWy1zq5b0uXIABQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/1mNaO5s2S2qLDyWWI8c5Y2"},"href":"https://api.spotify.com/v1/albums/1mNaO5s2S2qLDyWWI8c5Y2","id":"1mNaO5s2S2qLDyWWI8c5Y2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736113fe015a1cb751a94b9951"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026113fe015a1cb751a94b9951"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516113fe015a1cb751a94b9951"}],"is_playable":true,"name":"Hospitality On The Beach 2019 (DJ Mix)","release_date":"2019-05-31","release_date_precision":"day","total_tracks":33,"type":"album","uri":"spotify:album:1mNaO5s2S2qLDyWWI8c5Y2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2NCEtX40i9lLNpTg2X5583"},"href":"https://api.spotify.com/v1/artists/2NCEtX40i9lLNpTg2X5583","id":"2NCEtX40i9lLNpTg2X5583","name":"Metrik","type":"artist","uri":"spotify:artist:2NCEtX40i9lLNpTg2X5583"}],"disc_number":1,"duration_ms":110310,"explicit":false,"external_ids":{"isrc":"GBCJY1900146"},"external_urls":{"spotify":"https://open.spotify.com/track/5kXf9bv68JyI29AT1OBv7S"},"href":"https://api.spotify.com/v1/tracks/5kXf9bv68JyI29AT1OBv7S","id":"5kXf9bv68JyI29AT1OBv7S","is_local":false,"is_playable":true,"name":"Hackers (Mixed)","track_number":1,"type":"track","uri":"spotify:track:5kXf9bv68JyI29AT1OBv7S"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2NCEtX40i9lLNpTg2X5583"},"href":"https://api.spotify.com/v1/artists/2NCEtX40i9lLNpTg2X5583","id":"2NCEtX40i9lLNpTg2X5583","name":"Metrik","type":"artist","uri":"spotify:artist:2NCEtX40i9lLNpTg2X5583"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Sls3sJyb1IdWVBHLolhdI"},"href":"https://api.spotify.com/v1/albums/0Sls3sJyb1IdWVBHLolhdI","id":"0Sls3sJyb1IdWVBHLolhdI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273769e5ee0afc78b0ceae4fb50"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02769e5ee0afc78b0ceae4fb50"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851769e5ee0afc78b0ceae4fb50"}],"is_playable":true,"name":"Hackers","release_date":"2019-04-05","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0Sls3sJyb1IdWVBHLolhdI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2NCEtX40i9lLNpTg2X5583"},"href":"https://api.spotify.com/v1/artists/2NCEtX40i9lLNpTg2X5583","id":"2NCEtX40i9lLNpTg2X5583","name":"Metrik","type":"artist","uri":"spotify:artist:2NCEtX40i9lLNpTg2X5583"}],"disc_number":1,"duration_ms":253793,"explicit":false,"external_ids":{"isrc":"GBCJY1900061"},"external_urls":{"spotify":"https://open.spotify.com/track/3qV1XcsVQSzw0aGRhW4y5Y"},"href":"https://api.spotify.com/v1/tracks/3qV1XcsVQSzw0aGRhW4y5Y","id":"3qV1XcsVQSzw0aGRhW4y5Y","is_local":false,"is_playable":true,"name":"Hackers","track_number":1,"type":"track","uri":"spotify:track:3qV1XcsVQSzw0aGRhW4y5Y"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1TXYCtz4NjCcy02l9xYyWg"},"href":"https://api.spotify.com/v1/artists/1TXYCtz4NjCcy02l9xYyWg","id":"1TXYCtz4NjCcy02l9xYyWg","name":"Hospital Records","type":"artist","uri":"spotify:artist:1TXYCtz4NjCcy02l9xYyWg"}],"external_urls":{"spotify":"https://open.spotify.com/album/5XfIcA5PzaouroaLKPK9Zz"},"href":"https://api.spotify.com/v1/albums/5XfIcA5PzaouroaLKPK9Zz","id":"5XfIcA5PzaouroaLKPK9Zz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273663180eda10daae813c2b89b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02663180eda10daae813c2b89b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851663180eda10daae813c2b89b"}],"is_playable":true,"name":"Hospitality On The Beach 2019","release_date":"2019-05-31","release_date_precision":"day","total_tracks":34,"type":"album","uri":"spotify:album:5XfIcA5PzaouroaLKPK9Zz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2NCEtX40i9lLNpTg2X5583"},"href":"https://api.spotify.com/v1/artists/2NCEtX40i9lLNpTg2X5583","id":"2NCEtX40i9lLNpTg2X5583","name":"Metrik","type":"artist","uri":"spotify:artist:2NCEtX40i9lLNpTg2X5583"}],"disc_number":1,"duration_ms":253793,"explicit":false,"external_ids":{"isrc":"GBCJY1900061"},"external_urls":{"spotify":"https://open.spotify.com/track/1UUjR2O5TWCewxAhYus6XK"},"href":"https://api.spotify.com/v1/tracks/1UUjR2O5TWCewxAhYus6XK","id":"1UUjR2O5TWCewxAhYus6XK","is_local":false,"is_playable":true,"name":"Hackers","track_number":2,"type":"track","uri":"spotify:track:1UUjR2O5TWCewxAhYus6XK"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkhhY2tlcnMlMjIlMjBhcnRpc3QlM0ElMjJNZXRyaWslMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjQsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsImlkIjoiMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsIm5hbWUiOiJNZXRyaWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk5DRXRYNDBpOWxMTnBUZzJYNTU4MyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJvQk9KRjBibFU2bVZZbktpQjd3bUkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yb0JPSkYwYmxVNm1WWW5LaUI3d21JIiwiaWQiOiIyb0JPSkYwYmxVNm1WWW5LaUI3d21JIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMA==", + "MDBiMjczM2IzNmQyMjRhY2VjYTBjMDIzZDE1ZDhjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjNiMzZkMjI0YWNlY2EwYzAyM2QxNWQ4YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxM2IzNmQyMjRhY2VjYTBjMDIzZDE1ZDhjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkV4IE1hY2hpbmEiLCJyZWxlYXNlX2RhdGUiOiIyMDIwLTA2LTI2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Mm9CT0pGMGJsVTZtVlluS2lCN3dtSSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsImlkIjoiMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsIm5hbWUiOiJNZXRyaWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk5DRXRYNDBpOWxMTnBUZzJYNTU4MyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTM3OTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkNKWTE5MDAwNjEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzQwU1BRRExZczVPQWpuRUVya3BDNDMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80MFNQUURMWXM1T0FqbkVFcmtwQzQzIiwiaWQiOiI0MFNQUURMWXM1T0FqbkVFcmtwQzQzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhhY2tlcnMiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NDBTUFFETFlzNU9Bam5FRXJrcEM0MyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83cERCUnk5dVd5MXpxNWIwdVhJQUJRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdwREJSeTl1V3kxenE1YjB1WElBQlEiLCJpZCI6IjdwREJSeTl1V3kxenE1YjB1WElBQlEiLCJuYW1lIjoiTnU6VG9uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3cERCUnk5dVd5MQ==", + "enE1YjB1WElBQlEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xbU5hTzVzMlMycUxEeVdXSThjNVkyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMW1OYU81czJTMnFMRHlXV0k4YzVZMiIsImlkIjoiMW1OYU81czJTMnFMRHlXV0k4YzVZMiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2MTEzZmUwMTVhMWNiNzUxYTk0Yjk5NTEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNjExM2ZlMDE1YTFjYjc1MWE5NGI5OTUxIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2MTEzZmUwMTVhMWNiNzUxYTk0Yjk5NTEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9zcGl0YWxpdHkgT24gVGhlIEJlYWNoIDIwMTkgKERKIE1peCkiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA1LTMxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzMsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MW1OYU81czJTMnFMRHlXV0k4YzVZMiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsImlkIjoiMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsIm5hbWUiOiJNZXRyaWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk5DRXRYNDBpOWxMTnBUZzJYNTU4MyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxMTAzMTAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkNKWTE5MDAxNDYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVrWGY5YnY2OEp5STI5QVQxT0J2N1MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81a1hmOWJ2NjhKeUkyOUFUMU9CdjdTIiwiaWQiOiI1a1hmOWJ2NjhKeUkyOUFUMU9CdjdTIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkhhY2tlcnMgKE1peGVkKSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1a1hmOWJ2Ng==", + "OEp5STI5QVQxT0J2N1MifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsImlkIjoiMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsIm5hbWUiOiJNZXRyaWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk5DRXRYNDBpOWxMTnBUZzJYNTU4MyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBTbHMzc0p5YjFJZFdWQkhMb2xoZEkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wU2xzM3NKeWIxSWRXVkJITG9saGRJIiwiaWQiOiIwU2xzM3NKeWIxSWRXVkJITG9saGRJIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzc2OWU1ZWUwYWZjNzhiMGNlYWU0ZmI1MCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3NjllNWVlMGFmYzc4YjBjZWFlNGZiNTAifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTc2OWU1ZWUwYWZjNzhiMGNlYWU0ZmI1MCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIYWNrZXJzIiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wNC0wNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MFNsczNzSnliMUlkV1ZCSExvbGhkSSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOQ0V0WDQwaTlsTE5wVGcyWDU1ODMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsImlkIjoiMk5DRXRYNDBpOWxMTnBUZzJYNTU4MyIsIm5hbWUiOiJNZXRyaWsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Mk5DRXRYNDBpOWxMTnBUZzJYNTU4MyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNTM3OTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkNKWTE5MDAwNjEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5Ig==", + "OiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM3FWMVhjc1ZRU3p3MGFHUmhXNHk1WSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNxVjFYY3NWUVN6dzBhR1JoVzR5NVkiLCJpZCI6IjNxVjFYY3NWUVN6dzBhR1JoVzR5NVkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGFja2VycyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozcVYxWGNzVlFTencwYUdSaFc0eTVZIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFUWFlDdHo0TmpDY3kwMmw5eFl5V2cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMVRYWUN0ejROakNjeTAybDl4WXlXZyIsImlkIjoiMVRYWUN0ejROakNjeTAybDl4WXlXZyIsIm5hbWUiOiJIb3NwaXRhbCBSZWNvcmRzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFUWFlDdHo0TmpDY3kwMmw5eFl5V2cifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81WGZJY0E1UHphb3Vyb2FMS1BLOVp6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNVhmSWNBNVB6YW91cm9hTEtQSzlaeiIsImlkIjoiNVhmSWNBNVB6YW91cm9hTEtQSzlaeiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM2NjMxODBlZGExMGRhYWU4MTNjMmI4OWIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNjYzMTgwZWRhMTBkYWFlODEzYzJiODliIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE2NjMxODBlZGExMGRhYWU4MTNjMmI4OWIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9zcGl0YWxpdHkgT24gVGhlIEJlYWNoIDIwMTkiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA1LTMxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MzQsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVhmSWNBNVB6YW91cm9hTEtQSzlaeiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOQ0V0WDQwaTlsTE5wVGcyWDU1OA==", + "MyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yTkNFdFg0MGk5bExOcFRnMlg1NTgzIiwiaWQiOiIyTkNFdFg0MGk5bExOcFRnMlg1NTgzIiwibmFtZSI6Ik1ldHJpayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTkNFdFg0MGk5bExOcFRnMlg1NTgzIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1Mzc5MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQ0pZMTkwMDA2MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVVValIyTzVUV0Nld3hBaFl1czZYSyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFVVWpSMk81VFdDZXd4QWhZdXM2WEsiLCJpZCI6IjFVVWpSMk81VFdDZXd4QWhZdXM2WEsiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGFja2VycyIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxVVVqUjJPNVRXQ2V3eEFoWXVzNlhLIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Hackers%22+artist%3A%22Metrik%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJvZHklMjBMb29zZSUyMiUyMGFydGlzdCUzQSUyMldpbGtpbnNvbiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJvZHklMjBMb29zZSUyMiUyMGFydGlzdCUzQSUyMldpbGtpbnNvbiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Body+Loose%22+artist%3A%22Wilkinson%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkd1bnNob3QlMjIlMjBhcnRpc3QlM0ElMjJLJTIwTW90aW9ueiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlFZZFhUb01vNFhIbkcxQW5FVlpZSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82UVlkWFRvTW80WEhuRzFBbkVWWllKIiwiaWQiOiI2UVlkWFRvTW80WEhuRzFBbkVWWllKIiwibmFtZSI6IksgTW90aW9ueiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2UVlkWFRvTW80WEhuRzFBbkVWWllKIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzFoZnpjWW9XNDA4am5YUEFUY1JDSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzcxaGZ6Y1lvVzQwOGpuWFBBVGNSQ0kiLCJpZCI6IjcxaGZ6Y1lvVzQwOGpuWFBBVGNSQ0kiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYg==", + "Njc2MTZkMDAwMGIyNzM4ZDNlYjcwOGY0Yzk2OTgzZTczNTdhZGMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOGQzZWI3MDhmNGM5Njk4M2U3MzU3YWRjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4ZDNlYjcwOGY0Yzk2OTgzZTczNTdhZGMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEV2b2x1dGlvbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDgtMzEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3MWhmemNZb1c0MDhqblhQQVRjUkNJIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlFZZFhUb01vNFhIbkcxQW5FVlpZSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82UVlkWFRvTW80WEhuRzFBbkVWWllKIiwiaWQiOiI2UVlkWFRvTW80WEhuRzFBbkVWWllKIiwibmFtZSI6IksgTW90aW9ueiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2UVlkWFRvTW80WEhuRzFBbkVWWllKIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyNDkxNCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCOEtFMTg1NDQ0MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVlIVkQ5VXF1Y0hJcDlxcVBUUmhKVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVZSFZEOVVxdWNISXA5cXFQVFJoSlciLCJpZCI6IjVZSFZEOVVxdWNISXA5cXFQVFJoSlciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3Vuc2hvdCIsInRyYWNrX251bWJlciI6MTMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NVlIVkQ5VXF1Y0hJcDlxcVBUUmhKVyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlFZZFhUb01vNFhIbkcxQW5FVlpZSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82UVlkWFRvTW80WEhuRzFBbkVWWllKIiwiaWQiOiI2UVlkWFRvTW80WEhuRzFBbkVWWllKIiwibmFtZSI6IksgTW90aW9ueiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5Og==", + "YXJ0aXN0OjZRWWRYVG9NbzRYSG5HMUFuRVZaWUoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUR5Z3B0VVk2Y29RSHBtZ0ZmSVN6USJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81RHlncHRVWTZjb1FIcG1nRmZJU3pRIiwiaWQiOiI1RHlncHRVWTZjb1FIcG1nRmZJU3pRIiwibmFtZSI6IkEuTS5DIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVEeWdwdFVZNmNvUUhwbWdGZklTelEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wOVJOdnJ6TUMwYXUyNHB5VUJURm1CIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMDlSTnZyek1DMGF1MjRweVVCVEZtQiIsImlkIjoiMDlSTnZyek1DMGF1MjRweVVCVEZtQiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkYjExZTkxNTdkNjEwMjczY2U5MTQ2MjAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZGIxMWU5MTU3ZDYxMDI3M2NlOTE0NjIwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkYjExZTkxNTdkNjEwMjczY2U5MTQ2MjAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3Vuc2hvdCAoQS5NLkMgUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wMS0zMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MDlSTnZyek1DMGF1MjRweVVCVEZtQiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZRWWRYVG9NbzRYSG5HMUFuRVZaWUoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNlFZZFhUb01vNFhIbkcxQW5FVlpZSiIsImlkIjoiNlFZZFhUb01vNFhIbkcxQW5FVlpZSiIsIm5hbWUiOiJLIE1vdGlvbnoiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NlFZZFhUb01vNFhIbkcxQW5FVlpZSiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81RHlncHRVWTZjb1FIcG1nRmZJU3pRIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVEeQ==", + "Z3B0VVk2Y29RSHBtZ0ZmSVN6USIsImlkIjoiNUR5Z3B0VVk2Y29RSHBtZ0ZmSVN6USIsIm5hbWUiOiJBLk0uQyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1RHlncHRVWTZjb1FIcG1nRmZJU3pRIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNzI3NSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCOEtFMTk1Njg1MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNmVvVjlDUHJKS0ppalFpOVJVWVY1cCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZlb1Y5Q1BySktKaWpRaTlSVVlWNXAiLCJpZCI6IjZlb1Y5Q1BySktKaWpRaTlSVVlWNXAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiR3Vuc2hvdCAoQS5NLkMgUmVtaXgpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZlb1Y5Q1BySktKaWpRaTlSVVlWNXAifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Gunshot%22+artist%3A%22K+Motionz%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNoYXNlJTIwVGhlJTIwU3VuJTIyJTIwYXJ0aXN0JTNBJTIyS292ZW4lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVUNicDZEMWx2SUxseFJKVDlMbkZhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNVQ2JwNkQxbHZJTGx4UkpUOUxuRmEiLCJpZCI6IjNVQ2JwNkQxbHZJTGx4UkpUOUxuRmEiLCJuYW1lIjoiS292ZW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M1VDYnA2RDFsdklMbHhSSlQ5TG5GYSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzF0WGxGSmtsVDRkNEpjNVR0dVdpd2MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xdFhsRkprbFQ0ZDRKYzVUdHVXaXdjIiwiaWQiOiIxdFhsRkprbFQ0ZDRKYzVUdHVXaXdjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYQ==", + "YjY3NjE2ZDAwMDBiMjczMTA4Nzg2Nzc2ZjFlYWUyYTczOGM2ZWZjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjEwODc4Njc3NmYxZWFlMmE3MzhjNmVmYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMTA4Nzg2Nzc2ZjFlYWUyYTczOGM2ZWZjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkNoYXNlIFRoZSBTdW4iLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA3LTI3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxdFhsRkprbFQ0ZDRKYzVUdHVXaXdjIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM1VDYnA2RDFsdklMbHhSSlQ5TG5GYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zVUNicDZEMWx2SUxseFJKVDlMbkZhIiwiaWQiOiIzVUNicDZEMWx2SUxseFJKVDlMbkZhIiwibmFtZSI6IktvdmVuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNVQ2JwNkQxbHZJTGx4UkpUOUxuRmEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTg5NjU1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0IyTEQyMzEwMjI1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83a0U1U0dWcG9nQlg1VlhpVGdZaVJnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2tFNVNHVnBvZ0JYNVZYaVRnWWlSZyIsImlkIjoiN2tFNVNHVnBvZ0JYNVZYaVRnWWlSZyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDaGFzZSBUaGUgU3VuIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdrRTVTR1Zwb2dCWDVWWGlUZ1lpUmcifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Chase+The+Sun%22+artist%3A%22Koven%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Ready%20To%20Go%22%20artist%3A%22ShockOne%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1yShtQaHjChbToQboKRzgH"},"href":"https://api.spotify.com/v1/artists/1yShtQaHjChbToQboKRzgH","id":"1yShtQaHjChbToQboKRzgH","name":"ShockOne","type":"artist","uri":"spotify:artist:1yShtQaHjChbToQboKRzgH"}],"external_urls":{"spotify":"https://open.spotify.com/album/4x49gOBzMBZIIa9eYawp74"},"href":"https://api.spotify.com/v1/albums/4x49gOBzMBZIIa9eYawp74","id":"4x49gOBzMBZIIa9eYawp74","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f2eec0c024090ade51b4a489"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f2eec0c024090ade51b4a489"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f2eec0c024090ade51b4a489"}],"is_playable":true,"name":"Organism Algorithm","release_date":"2024-02-23","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:4x49gOBzMBZIIa9eYawp74"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1yShtQaHjChbToQboKRzgH"},"href":"https://api.spotify.com/v1/artists/1yShtQaHjChbToQboKRzgH","id":"1yShtQaHjChbToQboKRzgH","name":"ShockOne","type":"artist","uri":"spotify:artist:1yShtQaHjChbToQboKRzgH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Dn88PoQjnQgLTOaokePFz"},"href":"https://api.spotify.com/v1/artists/1Dn88PoQjnQgLTOaokePFz","id":"1Dn88PoQjnQgLTOaokePFz","name":"Bright Sparks","type":"artist","uri":"spotify:artist:1Dn88PoQjnQgLTOaokePFz"}],"disc_number":1,"duration_ms":212617,"explicit":false,"external_ids":{"isrc":"AUCN32300106"},"external_urls":{"spotify":"https://open.spotify.com/track/3el7utwP0JhA5tObUeXBI8"},"href":"https://api.spotify.com/v1/tracks/3el7utwP0JhA5tObUeXBI8","id":"3el7utwP0JhA5tObUeXBI8","is_local":false,"is_playable":true,"name":"Ready To Go (feat. Bright Sparks)","track_number":3,"type":"track","uri":"spotify:track:3el7utwP0JhA5tObUeXBI8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1yShtQaHjChbToQboKRzgH"},"href":"https://api.spotify.com/v1/artists/1yShtQaHjChbToQboKRzgH","id":"1yShtQaHjChbToQboKRzgH","name":"ShockOne","type":"artist","uri":"spotify:artist:1yShtQaHjChbToQboKRzgH"}],"external_urls":{"spotify":"https://open.spotify.com/album/7vKgtNd9Zc2mebwEO3Lbww"},"href":"https://api.spotify.com/v1/albums/7vKgtNd9Zc2mebwEO3Lbww","id":"7vKgtNd9Zc2mebwEO3Lbww","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bc4f607f389096178742fb4d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bc4f607f389096178742fb4d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bc4f607f389096178742fb4d"}],"is_playable":true,"name":"Organism Algorithm Permutations","release_date":"2024-11-29","release_date_precision":"day","total_tracks":22,"type":"album","uri":"spotify:album:7vKgtNd9Zc2mebwEO3Lbww"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1yShtQaHjChbToQboKRzgH"},"href":"https://api.spotify.com/v1/artists/1yShtQaHjChbToQboKRzgH","id":"1yShtQaHjChbToQboKRzgH","name":"ShockOne","type":"artist","uri":"spotify:artist:1yShtQaHjChbToQboKRzgH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Dn88PoQjnQgLTOaokePFz"},"href":"https://api.spotify.com/v1/artists/1Dn88PoQjnQgLTOaokePFz","id":"1Dn88PoQjnQgLTOaokePFz","name":"Bright Sparks","type":"artist","uri":"spotify:artist:1Dn88PoQjnQgLTOaokePFz"}],"disc_number":1,"duration_ms":212617,"explicit":false,"external_ids":{"isrc":"AUCN32300106"},"external_urls":{"spotify":"https://open.spotify.com/track/4aFAJAdGAtXhqOGlbK2HDj"},"href":"https://api.spotify.com/v1/tracks/4aFAJAdGAtXhqOGlbK2HDj","id":"4aFAJAdGAtXhqOGlbK2HDj","is_local":false,"is_playable":true,"name":"Ready To Go (feat. Bright Sparks)","track_number":3,"type":"track","uri":"spotify:track:4aFAJAdGAtXhqOGlbK2HDj"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1yShtQaHjChbToQboKRzgH"},"href":"https://api.spotify.com/v1/artists/1yShtQaHjChbToQboKRzgH","id":"1yShtQaHjChbToQboKRzgH","name":"ShockOne","type":"artist","uri":"spotify:artist:1yShtQaHjChbToQboKRzgH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Dn88PoQjnQgLTOaokePFz"},"href":"https://api.spotify.com/v1/artists/1Dn88PoQjnQgLTOaokePFz","id":"1Dn88PoQjnQgLTOaokePFz","name":"Bright Sparks","type":"artist","uri":"spotify:artist:1Dn88PoQjnQgLTOaokePFz"}],"external_urls":{"spotify":"https://open.spotify.com/album/6A3dg8xEOfWYIgLRETqprL"},"href":"https://api.spotify.com/v1/albums/6A3dg8xEOfWYIgLRETqprL","id":"6A3dg8xEOfWYIgLRETqprL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732548d3d31afc7ce45790f59e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022548d3d31afc7ce45790f59e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512548d3d31afc7ce45790f59e"}],"is_playable":true,"name":"Ready To Go (feat. Bright Sparks)","release_date":"2023-08-04","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6A3dg8xEOfWYIgLRETqprL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1yShtQaHjChbToQboKRzgH"},"href":"https://api.spotify.com/v1/artists/1yShtQaHjChbToQboKRzgH","id":"1yShtQaHjChbToQboKRzgH","name":"ShockOne","type":"artist","uri":"spotify:artist:1yShtQaHjChbToQboKRzgH"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Dn88PoQjnQgLTOaokePFz"},"href":"https://api.spotify.com/v1/artists/1Dn88PoQjnQgLTOaokePFz","id":"1Dn88PoQjnQgLTOaokePFz","name":"Bright Sparks","type":"artist","uri":"spotify:artist:1Dn88PoQjnQgLTOaokePFz"}],"disc_number":1,"duration_ms":212617,"explicit":false,"external_ids":{"isrc":"AUCN32300106"},"external_urls":{"spotify":"https://open.spotify.com/track/20AFetMBmDCOBSalxv0YHv"},"href":"https://api.spotify.com/v1/tracks/20AFetMBmDCOBSalxv0YHv","id":"20AFetMBmDCOBSalxv0YHv","is_local":false,"is_playable":true,"name":"Ready To Go (feat. Bright Sparks)","track_number":1,"type":"track","uri":"spotify:track:20AFetMBmDCOBSalxv0YHv"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJlYWR5JTIwVG8lMjBHbyUyMiUyMGFydGlzdCUzQSUyMlNob2NrT25lJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xeVNodFFhSGpDaGJUb1Fib0tSemdIIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzF5U2h0UWFIakNoYlRvUWJvS1J6Z0giLCJpZCI6IjF5U2h0UWFIakNoYlRvUWJvS1J6Z0giLCJuYW1lIjoiU2hvY2tPbmUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MXlTaHRRYUhqQ2hiVG9RYm9LUnpnSCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzR4NDlnT0J6TUJaSUlhOWVZYXdwNzQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80eDQ5Z09Cek1CWklJYTllWWF3cDc0IiwiaWQiOiI0eDQ5Z09Cek1CWklJYTllWWF3cDc0IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZw==", + "ZS9hYjY3NjE2ZDAwMDBiMjczZjJlZWMwYzAyNDA5MGFkZTUxYjRhNDg5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmYyZWVjMGMwMjQwOTBhZGU1MWI0YTQ4OSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjJlZWMwYzAyNDA5MGFkZTUxYjRhNDg5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik9yZ2FuaXNtIEFsZ29yaXRobSIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDItMjMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0eDQ5Z09Cek1CWklJYTllWWF3cDc0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXlTaHRRYUhqQ2hiVG9RYm9LUnpnSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xeVNodFFhSGpDaGJUb1Fib0tSemdIIiwiaWQiOiIxeVNodFFhSGpDaGJUb1Fib0tSemdIIiwibmFtZSI6IlNob2NrT25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF5U2h0UWFIakNoYlRvUWJvS1J6Z0gifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMURuODhQb1FqblFnTFRPYW9rZVBGeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xRG44OFBvUWpuUWdMVE9hb2tlUEZ6IiwiaWQiOiIxRG44OFBvUWpuUWdMVE9hb2tlUEZ6IiwibmFtZSI6IkJyaWdodCBTcGFya3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MURuODhQb1FqblFnTFRPYW9rZVBGeiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTI2MTcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJBVUNOMzIzMDAxMDYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNlbDd1dHdQMEpoQTV0T2JVZVhCSTgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zZWw3dXR3UDBKaEE1dE9iVWVYQkk4IiwiaWQiOiIzZWw3dXR3UDBKaEE1dE9iVWVYQkk4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlYWR5IFRvIEdvIChmZWF0LiBCcmlnaHQgU3BhcmtzKSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjaw==", + "OjNlbDd1dHdQMEpoQTV0T2JVZVhCSTgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXlTaHRRYUhqQ2hiVG9RYm9LUnpnSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xeVNodFFhSGpDaGJUb1Fib0tSemdIIiwiaWQiOiIxeVNodFFhSGpDaGJUb1Fib0tSemdIIiwibmFtZSI6IlNob2NrT25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF5U2h0UWFIakNoYlRvUWJvS1J6Z0gifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83dktndE5kOVpjMm1lYndFTzNMYnd3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN3ZLZ3ROZDlaYzJtZWJ3RU8zTGJ3dyIsImlkIjoiN3ZLZ3ROZDlaYzJtZWJ3RU8zTGJ3dyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiYzRmNjA3ZjM4OTA5NjE3ODc0MmZiNGQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmM0ZjYwN2YzODkwOTYxNzg3NDJmYjRkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiYzRmNjA3ZjM4OTA5NjE3ODc0MmZiNGQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT3JnYW5pc20gQWxnb3JpdGhtIFBlcm11dGF0aW9ucyIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMTEtMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3dktndE5kOVpjMm1lYndFTzNMYnd3In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXlTaHRRYUhqQ2hiVG9RYm9LUnpnSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xeVNodFFhSGpDaGJUb1Fib0tSemdIIiwiaWQiOiIxeVNodFFhSGpDaGJUb1Fib0tSemdIIiwibmFtZSI6IlNob2NrT25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF5U2h0UWFIakNoYlRvUWJvS1J6Z0gifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMURuODhQb1FqblFnTFRPYW9rZVBGeg==", + "In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFEbjg4UG9Ram5RZ0xUT2Fva2VQRnoiLCJpZCI6IjFEbjg4UG9Ram5RZ0xUT2Fva2VQRnoiLCJuYW1lIjoiQnJpZ2h0IFNwYXJrcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxRG44OFBvUWpuUWdMVE9hb2tlUEZ6In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxMjYxNywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkFVQ04zMjMwMDEwNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNGFGQUpBZEdBdFhocU9HbGJLMkhEaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRhRkFKQWRHQXRYaHFPR2xiSzJIRGoiLCJpZCI6IjRhRkFKQWRHQXRYaHFPR2xiSzJIRGoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVhZHkgVG8gR28gKGZlYXQuIEJyaWdodCBTcGFya3MpIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRhRkFKQWRHQXRYaHFPR2xiSzJIRGoifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzF5U2h0UWFIakNoYlRvUWJvS1J6Z0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMXlTaHRRYUhqQ2hiVG9RYm9LUnpnSCIsImlkIjoiMXlTaHRRYUhqQ2hiVG9RYm9LUnpnSCIsIm5hbWUiOiJTaG9ja09uZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxeVNodFFhSGpDaGJUb1Fib0tSemdIIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFEbjg4UG9Ram5RZ0xUT2Fva2VQRnoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMURuODhQb1FqblFnTFRPYW9rZVBGeiIsImlkIjoiMURuODhQb1FqblFnTFRPYW9rZVBGeiIsIm5hbWUiOiJCcmlnaHQgU3BhcmtzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFEbjg4UG9Ram5RZ0xUT2Fva2VQRnoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82QTNkZzh4RU9mV1lJZ0xSRVRxcHJMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNkEzZGc4eEVPZldZSWdMUkVUcXByTCIsImlkIjoiNkEzZGc4eEVPZldZSWdMUkVUcXByTCIsImltYQ==", + "Z2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzI1NDhkM2QzMWFmYzdjZTQ1NzkwZjU5ZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyNTQ4ZDNkMzFhZmM3Y2U0NTc5MGY1OWUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTI1NDhkM2QzMWFmYzdjZTQ1NzkwZjU5ZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWFkeSBUbyBHbyAoZmVhdC4gQnJpZ2h0IFNwYXJrcykiLCJyZWxlYXNlX2RhdGUiOiIyMDIzLTA4LTA0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2QTNkZzh4RU9mV1lJZ0xSRVRxcHJMIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMXlTaHRRYUhqQ2hiVG9RYm9LUnpnSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xeVNodFFhSGpDaGJUb1Fib0tSemdIIiwiaWQiOiIxeVNodFFhSGpDaGJUb1Fib0tSemdIIiwibmFtZSI6IlNob2NrT25lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjF5U2h0UWFIakNoYlRvUWJvS1J6Z0gifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMURuODhQb1FqblFnTFRPYW9rZVBGeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xRG44OFBvUWpuUWdMVE9hb2tlUEZ6IiwiaWQiOiIxRG44OFBvUWpuUWdMVE9hb2tlUEZ6IiwibmFtZSI6IkJyaWdodCBTcGFya3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MURuODhQb1FqblFnTFRPYW9rZVBGeiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTI2MTcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJBVUNOMzIzMDAxMDYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzIwQUZldE1CbURDT0JTYWx4djBZSHYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yMEFGZXRNQm1EQ09CU2FseHYwWUh2IiwiaWQiOiIyMEFGZXRNQm1EQ09CU2FseHYwWUh2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlYWR5IFRvIEdvIA==", + "KGZlYXQuIEJyaWdodCBTcGFya3MpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjIwQUZldE1CbURDT0JTYWx4djBZSHYifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Ready+To+Go%22+artist%3A%22ShockOne%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRydWUlMjBDb2xvdXIlMjIlMjBhcnRpc3QlM0ElMjJDYW1vJTIwJTI2JTIwS3Jvb2tlZCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRydWUlMjBDb2xvdXIlMjIlMjBhcnRpc3QlM0ElMjJDYW1vJTIwJTI2JTIwS3Jvb2tlZCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22True+Colour%22+artist%3A%22Camo+%26+Krooked%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkFmdGVybWF0aCUyMiUyMGFydGlzdCUzQSUyMkNhbW8lMjAlMjYlMjBLcm9va2VkJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkFmdGVybWF0aCUyMiUyMGFydGlzdCUzQSUyMkNhbW8lMjAlMjYlMjBLcm9va2VkJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Aftermath%22+artist%3A%22Camo+%26+Krooked%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlR1cmJ1bGVuY2UlMjIlMjBhcnRpc3QlM0ElMjJSdWRpbWVudGFsJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlR1cmJ1bGVuY2UlMjIlMjBhcnRpc3QlM0ElMjJSdWRpbWVudGFsJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Turbulence%22+artist%3A%22Rudimental%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlNldCUyME1lJTIwRnJlZSUyMiUyMGFydGlzdCUzQSUyMkZyaWN0aW9uJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXhkaXpkZ2JRUXZHQWdBb2xHaHBYciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81eGRpemRnYlFRdkdBZ0FvbEdocFhyIiwiaWQiOiI1eGRpemRnYlFRdkdBZ0FvbEdocFhyIiwibmFtZSI6IkZyaWN0aW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV4ZGl6ZGdiUVF2R0FnQW9sR2hwWHIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80UEFqZnh2UXFVSnZmQzk1Q3k2ZGFvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNFBBamZ4dlFxVUp2ZkM5NUN5NmRhbyIsImlkIjoiNFBBamZ4dlFxVUp2ZkM5NUN5NmRhbyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYQ==", + "Z2UvYWI2NzYxNmQwMDAwYjI3MzkwNmMzZTJiNzljZDU2MjVkNGM1YTk0NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5MDZjM2UyYjc5Y2Q1NjI1ZDRjNWE5NDQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTkwNmMzZTJiNzljZDU2MjVkNGM1YTk0NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTZXQgTWUgRnJlZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMTEtMjYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRQQWpmeHZRcVVKdmZDOTVDeTZkYW8ifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81eGRpemRnYlFRdkdBZ0FvbEdocFhyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV4ZGl6ZGdiUVF2R0FnQW9sR2hwWHIiLCJpZCI6IjV4ZGl6ZGdiUVF2R0FnQW9sR2hwWHIiLCJuYW1lIjoiRnJpY3Rpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXhkaXpkZ2JRUXZHQWdBb2xHaHBYciJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMjM1MjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlBXUjIxMDAxMTQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNxMnVYMUJBakNpS21oRVFpcVdaVEQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zcTJ1WDFCQWpDaUttaEVRaXFXWlREIiwiaWQiOiIzcTJ1WDFCQWpDaUttaEVRaXFXWlREIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNldCBNZSBGcmVlIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNxMnVYMUJBakNpS21oRVFpcVdaVEQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV4ZGl6ZGdiUVF2R0FnQW9sR2hwWHIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXhkaXpkZ2JRUXZHQWdBb2xHaHBYciIsImlkIjoiNXhkaXpkZ2JRUXZHQWdBb2xHaHBYciIsIm5hbWUiOiJGcmljdGlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aQ==", + "Znk6YXJ0aXN0OjV4ZGl6ZGdiUVF2R0FnQW9sR2hwWHIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNmpzUzJtT1RBeFZybFNVV2lQTFhwSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82anNTMm1PVEF4VnJsU1VXaVBMWHBIIiwiaWQiOiI2anNTMm1PVEF4VnJsU1VXaVBMWHBIIiwibmFtZSI6IlQgJiBTdWdhaCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2anNTMm1PVEF4VnJsU1VXaVBMWHBIIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNFRTeThlOGlQZnlJQWY1ckhQb0tFMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRUU3k4ZThpUGZ5SUFmNXJIUG9LRTEiLCJpZCI6IjRUU3k4ZThpUGZ5SUFmNXJIUG9LRTEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTYwYjMwNDExYTM3MjU5MjJjMTI0NWI1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjk2MGIzMDQxMWEzNzI1OTIyYzEyNDViNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOTYwYjMwNDExYTM3MjU5MjJjMTI0NWI1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNldCBNZSBGcmVlIChUICYgU3VnYWggUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wMy0yMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFRTeThlOGlQZnlJQWY1ckhQb0tFMSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV4ZGl6ZGdiUVF2R0FnQW9sR2hwWHIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXhkaXpkZ2JRUXZHQWdBb2xHaHBYciIsImlkIjoiNXhkaXpkZ2JRUXZHQWdBb2xHaHBYciIsIm5hbWUiOiJGcmljdGlvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1eGRpemRnYlFRdkdBZ0FvbEdocFhyIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZqc1MybU9UQXhWcmxTVVdpUExYcEgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tLw==", + "djEvYXJ0aXN0cy82anNTMm1PVEF4VnJsU1VXaVBMWHBIIiwiaWQiOiI2anNTMm1PVEF4VnJsU1VXaVBMWHBIIiwibmFtZSI6IlQgJiBTdWdhaCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2anNTMm1PVEF4VnJsU1VXaVBMWHBIIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4MjA2OCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCUFdSMjUwMDAzMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNUZOcUxHUTJNUDVZTzdjVmJDMjlvRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVGTnFMR1EyTVA1WU83Y1ZiQzI5b0UiLCJpZCI6IjVGTnFMR1EyTVA1WU83Y1ZiQzI5b0UiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2V0IE1lIEZyZWUgLSBUICYgU3VnYWggUmVtaXgiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NUZOcUxHUTJNUDVZTzdjVmJDMjlvRSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Set+Me+Free%22+artist%3A%22Friction%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN0YXklMjBDbG9zZSUyMiUyMGFydGlzdCUzQSUyMkRlbHRhJTIwSGVhdnklMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN0YXklMjBDbG9zZSUyMiUyMGFydGlzdCUzQSUyMkRlbHRhJTIwSGVhdnklMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Stay+Close%22+artist%3A%22Delta+Heavy%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Anthem%22%20artist%3A%22Dimension%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/78bzUCJmEsEgENTy7rjMCV"},"href":"https://api.spotify.com/v1/artists/78bzUCJmEsEgENTy7rjMCV","id":"78bzUCJmEsEgENTy7rjMCV","name":"Dimen5ions","type":"artist","uri":"spotify:artist:78bzUCJmEsEgENTy7rjMCV"}],"external_urls":{"spotify":"https://open.spotify.com/album/0G8vo9O2jz1EaKu7uPSl4S"},"href":"https://api.spotify.com/v1/albums/0G8vo9O2jz1EaKu7uPSl4S","id":"0G8vo9O2jz1EaKu7uPSl4S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e0b6077f47a738d7f7c0138"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e0b6077f47a738d7f7c0138"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e0b6077f47a738d7f7c0138"}],"is_playable":true,"name":"Love In The Dark (Project X Anthem)","release_date":"2026-04-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0G8vo9O2jz1EaKu7uPSl4S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/78bzUCJmEsEgENTy7rjMCV"},"href":"https://api.spotify.com/v1/artists/78bzUCJmEsEgENTy7rjMCV","id":"78bzUCJmEsEgENTy7rjMCV","name":"Dimen5ions","type":"artist","uri":"spotify:artist:78bzUCJmEsEgENTy7rjMCV"}],"disc_number":1,"duration_ms":256904,"explicit":false,"external_ids":{"isrc":"QT4K32605884"},"external_urls":{"spotify":"https://open.spotify.com/track/4374JJ1LhDws4ZG0ztSUKj"},"href":"https://api.spotify.com/v1/tracks/4374JJ1LhDws4ZG0ztSUKj","id":"4374JJ1LhDws4ZG0ztSUKj","is_local":false,"is_playable":true,"name":"Love In The Dark (Project X Anthem)","track_number":1,"type":"track","uri":"spotify:track:4374JJ1LhDws4ZG0ztSUKj"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Fi28qVHrK9Z4Of14ZQgoQ"},"href":"https://api.spotify.com/v1/albums/4Fi28qVHrK9Z4Of14ZQgoQ","id":"4Fi28qVHrK9Z4Of14ZQgoQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b0248318fa36d284f2ee6740"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b0248318fa36d284f2ee6740"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b0248318fa36d284f2ee6740"}],"is_playable":true,"name":"Baddest Muthafucker","release_date":"1997-01-01","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:4Fi28qVHrK9Z4Of14ZQgoQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Le319anB04DUKyvGrYpah"},"href":"https://api.spotify.com/v1/artists/1Le319anB04DUKyvGrYpah","id":"1Le319anB04DUKyvGrYpah","name":"DJ Buzz Fuzz","type":"artist","uri":"spotify:artist:1Le319anB04DUKyvGrYpah"}],"disc_number":1,"duration_ms":339248,"explicit":true,"external_ids":{"isrc":"NLS240500853"},"external_urls":{"spotify":"https://open.spotify.com/track/0wIuyP7dYsi4YCvMfui1go"},"href":"https://api.spotify.com/v1/tracks/0wIuyP7dYsi4YCvMfui1go","id":"0wIuyP7dYsi4YCvMfui1go","is_local":false,"is_playable":true,"name":"Baddest Muthafucker - Buzzy's Anthem Mix","track_number":1,"type":"track","uri":"spotify:track:0wIuyP7dYsi4YCvMfui1go"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QzlZQ1HUYCYtmgQTsTNNg"},"href":"https://api.spotify.com/v1/albums/3QzlZQ1HUYCYtmgQTsTNNg","id":"3QzlZQ1HUYCYtmgQTsTNNg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273026fcfb19ddbe10e63f75e21"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02026fcfb19ddbe10e63f75e21"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851026fcfb19ddbe10e63f75e21"}],"is_playable":true,"name":"Happy Hardcore Top 100 (Best Ever)","release_date":"2010-05-17","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:3QzlZQ1HUYCYtmgQTsTNNg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"}],"disc_number":1,"duration_ms":339248,"explicit":true,"external_ids":{"isrc":"NLS240500853"},"external_urls":{"spotify":"https://open.spotify.com/track/72RlxcbZN6rzSb4UY28v6D"},"href":"https://api.spotify.com/v1/tracks/72RlxcbZN6rzSb4UY28v6D","id":"72RlxcbZN6rzSb4UY28v6D","is_local":false,"is_playable":true,"name":"Baddest Muthafucker - Buzzy's Anthem Mix","track_number":36,"type":"track","uri":"spotify:track:72RlxcbZN6rzSb4UY28v6D"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SiTwLI6Fui3ZFtp7biiVT"},"href":"https://api.spotify.com/v1/artists/2SiTwLI6Fui3ZFtp7biiVT","id":"2SiTwLI6Fui3ZFtp7biiVT","name":"Dimensions","type":"artist","uri":"spotify:artist:2SiTwLI6Fui3ZFtp7biiVT"}],"external_urls":{"spotify":"https://open.spotify.com/album/5zQU69vYW8zSuyRH6zx9uy"},"href":"https://api.spotify.com/v1/albums/5zQU69vYW8zSuyRH6zx9uy","id":"5zQU69vYW8zSuyRH6zx9uy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732d5f058ee4324b7b2c2e5b71"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022d5f058ee4324b7b2c2e5b71"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512d5f058ee4324b7b2c2e5b71"}],"is_playable":true,"name":"Blue Tape","release_date":"2025-06-27","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5zQU69vYW8zSuyRH6zx9uy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SiTwLI6Fui3ZFtp7biiVT"},"href":"https://api.spotify.com/v1/artists/2SiTwLI6Fui3ZFtp7biiVT","id":"2SiTwLI6Fui3ZFtp7biiVT","name":"Dimensions","type":"artist","uri":"spotify:artist:2SiTwLI6Fui3ZFtp7biiVT"}],"disc_number":1,"duration_ms":173418,"explicit":false,"external_ids":{"isrc":"USHM82591275"},"external_urls":{"spotify":"https://open.spotify.com/track/3e4416oVLBezbTY4KOke39"},"href":"https://api.spotify.com/v1/tracks/3e4416oVLBezbTY4KOke39","id":"3e4416oVLBezbTY4KOke39","is_local":false,"is_playable":true,"name":"Anthem","track_number":12,"type":"track","uri":"spotify:track:3e4416oVLBezbTY4KOke39"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/34CkXsjlBDBdIYThETJHhK"},"href":"https://api.spotify.com/v1/artists/34CkXsjlBDBdIYThETJHhK","id":"34CkXsjlBDBdIYThETJHhK","name":"Dimension Tribe","type":"artist","uri":"spotify:artist:34CkXsjlBDBdIYThETJHhK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/36tXqp4xQBrD0UYaNewD1x"},"href":"https://api.spotify.com/v1/artists/36tXqp4xQBrD0UYaNewD1x","id":"36tXqp4xQBrD0UYaNewD1x","name":"Mshika","type":"artist","uri":"spotify:artist:36tXqp4xQBrD0UYaNewD1x"}],"external_urls":{"spotify":"https://open.spotify.com/album/0SU5A1b3DD98uOlcRYxEeB"},"href":"https://api.spotify.com/v1/albums/0SU5A1b3DD98uOlcRYxEeB","id":"0SU5A1b3DD98uOlcRYxEeB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736320d4e790b49a7372a65357"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026320d4e790b49a7372a65357"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516320d4e790b49a7372a65357"}],"is_playable":true,"name":"Africa Is Not a Jungle","release_date":"2024-03-15","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:0SU5A1b3DD98uOlcRYxEeB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/34CkXsjlBDBdIYThETJHhK"},"href":"https://api.spotify.com/v1/artists/34CkXsjlBDBdIYThETJHhK","id":"34CkXsjlBDBdIYThETJHhK","name":"Dimension Tribe","type":"artist","uri":"spotify:artist:34CkXsjlBDBdIYThETJHhK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/36tXqp4xQBrD0UYaNewD1x"},"href":"https://api.spotify.com/v1/artists/36tXqp4xQBrD0UYaNewD1x","id":"36tXqp4xQBrD0UYaNewD1x","name":"Mshika","type":"artist","uri":"spotify:artist:36tXqp4xQBrD0UYaNewD1x"}],"disc_number":1,"duration_ms":382928,"explicit":false,"external_ids":{"isrc":"BGA472404781"},"external_urls":{"spotify":"https://open.spotify.com/track/3041B2FdbePA3ry2R00so1"},"href":"https://api.spotify.com/v1/tracks/3041B2FdbePA3ry2R00so1","id":"3041B2FdbePA3ry2R00so1","is_local":false,"is_playable":true,"name":"Anthem","track_number":1,"type":"track","uri":"spotify:track:3041B2FdbePA3ry2R00so1"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3A64xqBPw1wu0wlaf5pjtJ"},"href":"https://api.spotify.com/v1/artists/3A64xqBPw1wu0wlaf5pjtJ","id":"3A64xqBPw1wu0wlaf5pjtJ","name":"Dimension","type":"artist","uri":"spotify:artist:3A64xqBPw1wu0wlaf5pjtJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/7Arpxes0WNSD7vaHyzTY6I"},"href":"https://api.spotify.com/v1/albums/7Arpxes0WNSD7vaHyzTY6I","id":"7Arpxes0WNSD7vaHyzTY6I","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730615a49d2342f98027dda378"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020615a49d2342f98027dda378"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510615a49d2342f98027dda378"}],"is_playable":true,"name":"Anthem & Symphony Of Concern","release_date":"2010-05-21","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:7Arpxes0WNSD7vaHyzTY6I"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3A64xqBPw1wu0wlaf5pjtJ"},"href":"https://api.spotify.com/v1/artists/3A64xqBPw1wu0wlaf5pjtJ","id":"3A64xqBPw1wu0wlaf5pjtJ","name":"Dimension","type":"artist","uri":"spotify:artist:3A64xqBPw1wu0wlaf5pjtJ"}],"disc_number":1,"duration_ms":403226,"explicit":false,"external_ids":{"isrc":"DEQ601010102"},"external_urls":{"spotify":"https://open.spotify.com/track/7IioKuBQpLIuILPzdXRKlq"},"href":"https://api.spotify.com/v1/tracks/7IioKuBQpLIuILPzdXRKlq","id":"7IioKuBQpLIuILPzdXRKlq","is_local":false,"is_playable":true,"name":"Anthem - Original Mix","track_number":2,"type":"track","uri":"spotify:track:7IioKuBQpLIuILPzdXRKlq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0ZzRCvDp1gTEgqZjbqD3zZ"},"href":"https://api.spotify.com/v1/albums/0ZzRCvDp1gTEgqZjbqD3zZ","id":"0ZzRCvDp1gTEgqZjbqD3zZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27368ed4c4a3de8787157ab36a9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0268ed4c4a3de8787157ab36a9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485168ed4c4a3de8787157ab36a9"}],"is_playable":true,"name":"Happy Hardcore Top 100","release_date":"2012-04-13","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0ZzRCvDp1gTEgqZjbqD3zZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"}],"disc_number":1,"duration_ms":339248,"explicit":true,"external_ids":{"isrc":"NLS240500853"},"external_urls":{"spotify":"https://open.spotify.com/track/3eRtPx0dUAqTPxX9Vv0toR"},"href":"https://api.spotify.com/v1/tracks/3eRtPx0dUAqTPxX9Vv0toR","id":"3eRtPx0dUAqTPxX9Vv0toR","is_local":false,"is_playable":true,"name":"Baddest Muthafucker - Buzzy's Anthem Mix","track_number":36,"type":"track","uri":"spotify:track:3eRtPx0dUAqTPxX9Vv0toR"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Fi28qVHrK9Z4Of14ZQgoQ"},"href":"https://api.spotify.com/v1/albums/4Fi28qVHrK9Z4Of14ZQgoQ","id":"4Fi28qVHrK9Z4Of14ZQgoQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b0248318fa36d284f2ee6740"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b0248318fa36d284f2ee6740"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b0248318fa36d284f2ee6740"}],"is_playable":true,"name":"Baddest Muthafucker","release_date":"1997-01-01","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:4Fi28qVHrK9Z4Of14ZQgoQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/03pNICpxvPxHdKNAykLzr4"},"href":"https://api.spotify.com/v1/artists/03pNICpxvPxHdKNAykLzr4","id":"03pNICpxvPxHdKNAykLzr4","name":"Dj Gizmo","type":"artist","uri":"spotify:artist:03pNICpxvPxHdKNAykLzr4"}],"disc_number":1,"duration_ms":332346,"explicit":true,"external_ids":{"isrc":"NLS240600854"},"external_urls":{"spotify":"https://open.spotify.com/track/1UZro2y9uYislrXyuxCdlz"},"href":"https://api.spotify.com/v1/tracks/1UZro2y9uYislrXyuxCdlz","id":"1UZro2y9uYislrXyuxCdlz","is_local":false,"is_playable":true,"name":"Baddest Muthafucker - Gizmo's Anthem Mix","track_number":2,"type":"track","uri":"spotify:track:1UZro2y9uYislrXyuxCdlz"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3XPtxjkOkhOpT9LOz4TlzE"},"href":"https://api.spotify.com/v1/artists/3XPtxjkOkhOpT9LOz4TlzE","id":"3XPtxjkOkhOpT9LOz4TlzE","name":"Zero dimensional Gravity","type":"artist","uri":"spotify:artist:3XPtxjkOkhOpT9LOz4TlzE"}],"external_urls":{"spotify":"https://open.spotify.com/album/059u9hy3PmAwJaQdK2kYcH"},"href":"https://api.spotify.com/v1/albums/059u9hy3PmAwJaQdK2kYcH","id":"059u9hy3PmAwJaQdK2kYcH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dc52dc41084acccdeb728341"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dc52dc41084acccdeb728341"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dc52dc41084acccdeb728341"}],"is_playable":true,"name":"The Living Stone Sessions","release_date":"2024-11-22","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:059u9hy3PmAwJaQdK2kYcH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3XPtxjkOkhOpT9LOz4TlzE"},"href":"https://api.spotify.com/v1/artists/3XPtxjkOkhOpT9LOz4TlzE","id":"3XPtxjkOkhOpT9LOz4TlzE","name":"Zero dimensional Gravity","type":"artist","uri":"spotify:artist:3XPtxjkOkhOpT9LOz4TlzE"}],"disc_number":1,"duration_ms":164319,"explicit":false,"external_ids":{"isrc":"QZZ7M2492958"},"external_urls":{"spotify":"https://open.spotify.com/track/2Z3hRqrRpncc4GcrEw11F8"},"href":"https://api.spotify.com/v1/tracks/2Z3hRqrRpncc4GcrEw11F8","id":"2Z3hRqrRpncc4GcrEw11F8","is_local":false,"is_playable":true,"name":"Seagulls\u2019 Anthem","track_number":12,"type":"track","uri":"spotify:track:2Z3hRqrRpncc4GcrEw11F8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3XPtxjkOkhOpT9LOz4TlzE"},"href":"https://api.spotify.com/v1/artists/3XPtxjkOkhOpT9LOz4TlzE","id":"3XPtxjkOkhOpT9LOz4TlzE","name":"Zero dimensional Gravity","type":"artist","uri":"spotify:artist:3XPtxjkOkhOpT9LOz4TlzE"}],"external_urls":{"spotify":"https://open.spotify.com/album/1kXgMSj62sEstUjg7usLR4"},"href":"https://api.spotify.com/v1/albums/1kXgMSj62sEstUjg7usLR4","id":"1kXgMSj62sEstUjg7usLR4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731260886cb3925a760e54c7f0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021260886cb3925a760e54c7f0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511260886cb3925a760e54c7f0"}],"is_playable":true,"name":"Neurotheurgic Rites","release_date":"2025-04-30","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:1kXgMSj62sEstUjg7usLR4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3XPtxjkOkhOpT9LOz4TlzE"},"href":"https://api.spotify.com/v1/artists/3XPtxjkOkhOpT9LOz4TlzE","id":"3XPtxjkOkhOpT9LOz4TlzE","name":"Zero dimensional Gravity","type":"artist","uri":"spotify:artist:3XPtxjkOkhOpT9LOz4TlzE"}],"disc_number":1,"duration_ms":222879,"explicit":false,"external_ids":{"isrc":"QZNWR2574341"},"external_urls":{"spotify":"https://open.spotify.com/track/0StRZjQHagzjrvBgl809TM"},"href":"https://api.spotify.com/v1/tracks/0StRZjQHagzjrvBgl809TM","id":"0StRZjQHagzjrvBgl809TM","is_local":false,"is_playable":true,"name":"Anthem of the Silent Architects","track_number":9,"type":"track","uri":"spotify:track:0StRZjQHagzjrvBgl809TM"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Anthem%22%20artist%3A%22Dimension%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/78bzUCJmEsEgENTy7rjMCV"},"href":"https://api.spotify.com/v1/artists/78bzUCJmEsEgENTy7rjMCV","id":"78bzUCJmEsEgENTy7rjMCV","name":"Dimen5ions","type":"artist","uri":"spotify:artist:78bzUCJmEsEgENTy7rjMCV"}],"external_urls":{"spotify":"https://open.spotify.com/album/0G8vo9O2jz1EaKu7uPSl4S"},"href":"https://api.spotify.com/v1/albums/0G8vo9O2jz1EaKu7uPSl4S","id":"0G8vo9O2jz1EaKu7uPSl4S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e0b6077f47a738d7f7c0138"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e0b6077f47a738d7f7c0138"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e0b6077f47a738d7f7c0138"}],"is_playable":true,"name":"Love In The Dark (Project X Anthem)","release_date":"2026-04-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0G8vo9O2jz1EaKu7uPSl4S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/78bzUCJmEsEgENTy7rjMCV"},"href":"https://api.spotify.com/v1/artists/78bzUCJmEsEgENTy7rjMCV","id":"78bzUCJmEsEgENTy7rjMCV","name":"Dimen5ions","type":"artist","uri":"spotify:artist:78bzUCJmEsEgENTy7rjMCV"}],"disc_number":1,"duration_ms":256904,"explicit":false,"external_ids":{"isrc":"QT4K32605884"},"external_urls":{"spotify":"https://open.spotify.com/track/4374JJ1LhDws4ZG0ztSUKj"},"href":"https://api.spotify.com/v1/tracks/4374JJ1LhDws4ZG0ztSUKj","id":"4374JJ1LhDws4ZG0ztSUKj","is_local":false,"is_playable":true,"name":"Love In The Dark (Project X Anthem)","track_number":1,"type":"track","uri":"spotify:track:4374JJ1LhDws4ZG0ztSUKj"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Fi28qVHrK9Z4Of14ZQgoQ"},"href":"https://api.spotify.com/v1/albums/4Fi28qVHrK9Z4Of14ZQgoQ","id":"4Fi28qVHrK9Z4Of14ZQgoQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b0248318fa36d284f2ee6740"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b0248318fa36d284f2ee6740"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b0248318fa36d284f2ee6740"}],"is_playable":true,"name":"Baddest Muthafucker","release_date":"1997-01-01","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:4Fi28qVHrK9Z4Of14ZQgoQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1Le319anB04DUKyvGrYpah"},"href":"https://api.spotify.com/v1/artists/1Le319anB04DUKyvGrYpah","id":"1Le319anB04DUKyvGrYpah","name":"DJ Buzz Fuzz","type":"artist","uri":"spotify:artist:1Le319anB04DUKyvGrYpah"}],"disc_number":1,"duration_ms":339248,"explicit":true,"external_ids":{"isrc":"NLS240500853"},"external_urls":{"spotify":"https://open.spotify.com/track/0wIuyP7dYsi4YCvMfui1go"},"href":"https://api.spotify.com/v1/tracks/0wIuyP7dYsi4YCvMfui1go","id":"0wIuyP7dYsi4YCvMfui1go","is_local":false,"is_playable":true,"name":"Baddest Muthafucker - Buzzy's Anthem Mix","track_number":1,"type":"track","uri":"spotify:track:0wIuyP7dYsi4YCvMfui1go"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QzlZQ1HUYCYtmgQTsTNNg"},"href":"https://api.spotify.com/v1/albums/3QzlZQ1HUYCYtmgQTsTNNg","id":"3QzlZQ1HUYCYtmgQTsTNNg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273026fcfb19ddbe10e63f75e21"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02026fcfb19ddbe10e63f75e21"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851026fcfb19ddbe10e63f75e21"}],"is_playable":true,"name":"Happy Hardcore Top 100 (Best Ever)","release_date":"2010-05-17","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:3QzlZQ1HUYCYtmgQTsTNNg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"}],"disc_number":1,"duration_ms":339248,"explicit":true,"external_ids":{"isrc":"NLS240500853"},"external_urls":{"spotify":"https://open.spotify.com/track/72RlxcbZN6rzSb4UY28v6D"},"href":"https://api.spotify.com/v1/tracks/72RlxcbZN6rzSb4UY28v6D","id":"72RlxcbZN6rzSb4UY28v6D","is_local":false,"is_playable":true,"name":"Baddest Muthafucker - Buzzy's Anthem Mix","track_number":36,"type":"track","uri":"spotify:track:72RlxcbZN6rzSb4UY28v6D"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SiTwLI6Fui3ZFtp7biiVT"},"href":"https://api.spotify.com/v1/artists/2SiTwLI6Fui3ZFtp7biiVT","id":"2SiTwLI6Fui3ZFtp7biiVT","name":"Dimensions","type":"artist","uri":"spotify:artist:2SiTwLI6Fui3ZFtp7biiVT"}],"external_urls":{"spotify":"https://open.spotify.com/album/5zQU69vYW8zSuyRH6zx9uy"},"href":"https://api.spotify.com/v1/albums/5zQU69vYW8zSuyRH6zx9uy","id":"5zQU69vYW8zSuyRH6zx9uy","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732d5f058ee4324b7b2c2e5b71"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022d5f058ee4324b7b2c2e5b71"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512d5f058ee4324b7b2c2e5b71"}],"is_playable":true,"name":"Blue Tape","release_date":"2025-06-27","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:5zQU69vYW8zSuyRH6zx9uy"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2SiTwLI6Fui3ZFtp7biiVT"},"href":"https://api.spotify.com/v1/artists/2SiTwLI6Fui3ZFtp7biiVT","id":"2SiTwLI6Fui3ZFtp7biiVT","name":"Dimensions","type":"artist","uri":"spotify:artist:2SiTwLI6Fui3ZFtp7biiVT"}],"disc_number":1,"duration_ms":173418,"explicit":false,"external_ids":{"isrc":"USHM82591275"},"external_urls":{"spotify":"https://open.spotify.com/track/3e4416oVLBezbTY4KOke39"},"href":"https://api.spotify.com/v1/tracks/3e4416oVLBezbTY4KOke39","id":"3e4416oVLBezbTY4KOke39","is_local":false,"is_playable":true,"name":"Anthem","track_number":12,"type":"track","uri":"spotify:track:3e4416oVLBezbTY4KOke39"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/34CkXsjlBDBdIYThETJHhK"},"href":"https://api.spotify.com/v1/artists/34CkXsjlBDBdIYThETJHhK","id":"34CkXsjlBDBdIYThETJHhK","name":"Dimension Tribe","type":"artist","uri":"spotify:artist:34CkXsjlBDBdIYThETJHhK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/36tXqp4xQBrD0UYaNewD1x"},"href":"https://api.spotify.com/v1/artists/36tXqp4xQBrD0UYaNewD1x","id":"36tXqp4xQBrD0UYaNewD1x","name":"Mshika","type":"artist","uri":"spotify:artist:36tXqp4xQBrD0UYaNewD1x"}],"external_urls":{"spotify":"https://open.spotify.com/album/0SU5A1b3DD98uOlcRYxEeB"},"href":"https://api.spotify.com/v1/albums/0SU5A1b3DD98uOlcRYxEeB","id":"0SU5A1b3DD98uOlcRYxEeB","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736320d4e790b49a7372a65357"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026320d4e790b49a7372a65357"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516320d4e790b49a7372a65357"}],"is_playable":true,"name":"Africa Is Not a Jungle","release_date":"2024-03-15","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:0SU5A1b3DD98uOlcRYxEeB"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/34CkXsjlBDBdIYThETJHhK"},"href":"https://api.spotify.com/v1/artists/34CkXsjlBDBdIYThETJHhK","id":"34CkXsjlBDBdIYThETJHhK","name":"Dimension Tribe","type":"artist","uri":"spotify:artist:34CkXsjlBDBdIYThETJHhK"},{"external_urls":{"spotify":"https://open.spotify.com/artist/36tXqp4xQBrD0UYaNewD1x"},"href":"https://api.spotify.com/v1/artists/36tXqp4xQBrD0UYaNewD1x","id":"36tXqp4xQBrD0UYaNewD1x","name":"Mshika","type":"artist","uri":"spotify:artist:36tXqp4xQBrD0UYaNewD1x"}],"disc_number":1,"duration_ms":382928,"explicit":false,"external_ids":{"isrc":"BGA472404781"},"external_urls":{"spotify":"https://open.spotify.com/track/3041B2FdbePA3ry2R00so1"},"href":"https://api.spotify.com/v1/tracks/3041B2FdbePA3ry2R00so1","id":"3041B2FdbePA3ry2R00so1","is_local":false,"is_playable":true,"name":"Anthem","track_number":1,"type":"track","uri":"spotify:track:3041B2FdbePA3ry2R00so1"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3A64xqBPw1wu0wlaf5pjtJ"},"href":"https://api.spotify.com/v1/artists/3A64xqBPw1wu0wlaf5pjtJ","id":"3A64xqBPw1wu0wlaf5pjtJ","name":"Dimension","type":"artist","uri":"spotify:artist:3A64xqBPw1wu0wlaf5pjtJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/7Arpxes0WNSD7vaHyzTY6I"},"href":"https://api.spotify.com/v1/albums/7Arpxes0WNSD7vaHyzTY6I","id":"7Arpxes0WNSD7vaHyzTY6I","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730615a49d2342f98027dda378"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020615a49d2342f98027dda378"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510615a49d2342f98027dda378"}],"is_playable":true,"name":"Anthem & Symphony Of Concern","release_date":"2010-05-21","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:7Arpxes0WNSD7vaHyzTY6I"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3A64xqBPw1wu0wlaf5pjtJ"},"href":"https://api.spotify.com/v1/artists/3A64xqBPw1wu0wlaf5pjtJ","id":"3A64xqBPw1wu0wlaf5pjtJ","name":"Dimension","type":"artist","uri":"spotify:artist:3A64xqBPw1wu0wlaf5pjtJ"}],"disc_number":1,"duration_ms":403226,"explicit":false,"external_ids":{"isrc":"DEQ601010102"},"external_urls":{"spotify":"https://open.spotify.com/track/7IioKuBQpLIuILPzdXRKlq"},"href":"https://api.spotify.com/v1/tracks/7IioKuBQpLIuILPzdXRKlq","id":"7IioKuBQpLIuILPzdXRKlq","is_local":false,"is_playable":true,"name":"Anthem - Original Mix","track_number":2,"type":"track","uri":"spotify:track:7IioKuBQpLIuILPzdXRKlq"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0ZzRCvDp1gTEgqZjbqD3zZ"},"href":"https://api.spotify.com/v1/albums/0ZzRCvDp1gTEgqZjbqD3zZ","id":"0ZzRCvDp1gTEgqZjbqD3zZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27368ed4c4a3de8787157ab36a9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0268ed4c4a3de8787157ab36a9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485168ed4c4a3de8787157ab36a9"}],"is_playable":true,"name":"Happy Hardcore Top 100","release_date":"2012-04-13","release_date_precision":"day","total_tracks":100,"type":"album","uri":"spotify:album:0ZzRCvDp1gTEgqZjbqD3zZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"}],"disc_number":1,"duration_ms":339248,"explicit":true,"external_ids":{"isrc":"NLS240500853"},"external_urls":{"spotify":"https://open.spotify.com/track/3eRtPx0dUAqTPxX9Vv0toR"},"href":"https://api.spotify.com/v1/tracks/3eRtPx0dUAqTPxX9Vv0toR","id":"3eRtPx0dUAqTPxX9Vv0toR","is_local":false,"is_playable":true,"name":"Baddest Muthafucker - Buzzy's Anthem Mix","track_number":36,"type":"track","uri":"spotify:track:3eRtPx0dUAqTPxX9Vv0toR"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"}],"external_urls":{"spotify":"https://open.spotify.com/album/4Fi28qVHrK9Z4Of14ZQgoQ"},"href":"https://api.spotify.com/v1/albums/4Fi28qVHrK9Z4Of14ZQgoQ","id":"4Fi28qVHrK9Z4Of14ZQgoQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b0248318fa36d284f2ee6740"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b0248318fa36d284f2ee6740"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b0248318fa36d284f2ee6740"}],"is_playable":true,"name":"Baddest Muthafucker","release_date":"1997-01-01","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:4Fi28qVHrK9Z4Of14ZQgoQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1wphMTVD8P70mtjo0OgnLy"},"href":"https://api.spotify.com/v1/artists/1wphMTVD8P70mtjo0OgnLy","id":"1wphMTVD8P70mtjo0OgnLy","name":"Square Dimensione","type":"artist","uri":"spotify:artist:1wphMTVD8P70mtjo0OgnLy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/03pNICpxvPxHdKNAykLzr4"},"href":"https://api.spotify.com/v1/artists/03pNICpxvPxHdKNAykLzr4","id":"03pNICpxvPxHdKNAykLzr4","name":"Dj Gizmo","type":"artist","uri":"spotify:artist:03pNICpxvPxHdKNAykLzr4"}],"disc_number":1,"duration_ms":332346,"explicit":true,"external_ids":{"isrc":"NLS240600854"},"external_urls":{"spotify":"https://open.spotify.com/track/1UZro2y9uYislrXyuxCdlz"},"href":"https://api.spotify.com/v1/tracks/1UZro2y9uYislrXyuxCdlz","id":"1UZro2y9uYislrXyuxCdlz","is_local":false,"is_playable":true,"name":"Baddest Muthafucker - Gizmo's Anthem Mix","track_number":2,"type":"track","uri":"spotify:track:1UZro2y9uYislrXyuxCdlz"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3XPtxjkOkhOpT9LOz4TlzE"},"href":"https://api.spotify.com/v1/artists/3XPtxjkOkhOpT9LOz4TlzE","id":"3XPtxjkOkhOpT9LOz4TlzE","name":"Zero dimensional Gravity","type":"artist","uri":"spotify:artist:3XPtxjkOkhOpT9LOz4TlzE"}],"external_urls":{"spotify":"https://open.spotify.com/album/059u9hy3PmAwJaQdK2kYcH"},"href":"https://api.spotify.com/v1/albums/059u9hy3PmAwJaQdK2kYcH","id":"059u9hy3PmAwJaQdK2kYcH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dc52dc41084acccdeb728341"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dc52dc41084acccdeb728341"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dc52dc41084acccdeb728341"}],"is_playable":true,"name":"The Living Stone Sessions","release_date":"2024-11-22","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:059u9hy3PmAwJaQdK2kYcH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3XPtxjkOkhOpT9LOz4TlzE"},"href":"https://api.spotify.com/v1/artists/3XPtxjkOkhOpT9LOz4TlzE","id":"3XPtxjkOkhOpT9LOz4TlzE","name":"Zero dimensional Gravity","type":"artist","uri":"spotify:artist:3XPtxjkOkhOpT9LOz4TlzE"}],"disc_number":1,"duration_ms":164319,"explicit":false,"external_ids":{"isrc":"QZZ7M2492958"},"external_urls":{"spotify":"https://open.spotify.com/track/2Z3hRqrRpncc4GcrEw11F8"},"href":"https://api.spotify.com/v1/tracks/2Z3hRqrRpncc4GcrEw11F8","id":"2Z3hRqrRpncc4GcrEw11F8","is_local":false,"is_playable":true,"name":"Seagulls\u2019 Anthem","track_number":12,"type":"track","uri":"spotify:track:2Z3hRqrRpncc4GcrEw11F8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3XPtxjkOkhOpT9LOz4TlzE"},"href":"https://api.spotify.com/v1/artists/3XPtxjkOkhOpT9LOz4TlzE","id":"3XPtxjkOkhOpT9LOz4TlzE","name":"Zero dimensional Gravity","type":"artist","uri":"spotify:artist:3XPtxjkOkhOpT9LOz4TlzE"}],"external_urls":{"spotify":"https://open.spotify.com/album/1kXgMSj62sEstUjg7usLR4"},"href":"https://api.spotify.com/v1/albums/1kXgMSj62sEstUjg7usLR4","id":"1kXgMSj62sEstUjg7usLR4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731260886cb3925a760e54c7f0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021260886cb3925a760e54c7f0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511260886cb3925a760e54c7f0"}],"is_playable":true,"name":"Neurotheurgic Rites","release_date":"2025-04-30","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:1kXgMSj62sEstUjg7usLR4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3XPtxjkOkhOpT9LOz4TlzE"},"href":"https://api.spotify.com/v1/artists/3XPtxjkOkhOpT9LOz4TlzE","id":"3XPtxjkOkhOpT9LOz4TlzE","name":"Zero dimensional Gravity","type":"artist","uri":"spotify:artist:3XPtxjkOkhOpT9LOz4TlzE"}],"disc_number":1,"duration_ms":222879,"explicit":false,"external_ids":{"isrc":"QZNWR2574341"},"external_urls":{"spotify":"https://open.spotify.com/track/0StRZjQHagzjrvBgl809TM"},"href":"https://api.spotify.com/v1/tracks/0StRZjQHagzjrvBgl809TM","id":"0StRZjQHagzjrvBgl809TM","is_local":false,"is_playable":true,"name":"Anthem of the Silent Architects","track_number":9,"type":"track","uri":"spotify:track:0StRZjQHagzjrvBgl809TM"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Anthem%22+artist%3A%22Dimension%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Body%20Loose%20Wilkinson&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Body%20Loose%20Wilkinson&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7352aRY2mqSxBZwzUb6LmA"},"href":"https://api.spotify.com/v1/artists/7352aRY2mqSxBZwzUb6LmA","id":"7352aRY2mqSxBZwzUb6LmA","name":"Bow Wow","type":"artist","uri":"spotify:artist:7352aRY2mqSxBZwzUb6LmA"}],"external_urls":{"spotify":"https://open.spotify.com/album/65G0BpV00GmLi5WUCeWdvT"},"href":"https://api.spotify.com/v1/albums/65G0BpV00GmLi5WUCeWdvT","id":"65G0BpV00GmLi5WUCeWdvT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c0e4b61ae442a24e020c67ed"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c0e4b61ae442a24e020c67ed"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c0e4b61ae442a24e020c67ed"}],"is_playable":true,"name":"Wanted","release_date":"2005","release_date_precision":"year","total_tracks":11,"type":"album","uri":"spotify:album:65G0BpV00GmLi5WUCeWdvT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7352aRY2mqSxBZwzUb6LmA"},"href":"https://api.spotify.com/v1/artists/7352aRY2mqSxBZwzUb6LmA","id":"7352aRY2mqSxBZwzUb6LmA","name":"Bow Wow","type":"artist","uri":"spotify:artist:7352aRY2mqSxBZwzUb6LmA"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2NdeV5rLm47xAvogXrYhJX"},"href":"https://api.spotify.com/v1/artists/2NdeV5rLm47xAvogXrYhJX","id":"2NdeV5rLm47xAvogXrYhJX","name":"Ciara","type":"artist","uri":"spotify:artist:2NdeV5rLm47xAvogXrYhJX"}],"disc_number":1,"duration_ms":205840,"explicit":false,"external_ids":{"isrc":"USSM10500413"},"external_urls":{"spotify":"https://open.spotify.com/track/3jEqrIfwKO0M8ALu3TGilF"},"href":"https://api.spotify.com/v1/tracks/3jEqrIfwKO0M8ALu3TGilF","id":"3jEqrIfwKO0M8ALu3TGilF","is_local":false,"is_playable":true,"name":"Like You (feat. Ciara)","track_number":6,"type":"track","uri":"spotify:track:3jEqrIfwKO0M8ALu3TGilF"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7n2Ycct7Beij7Dj7meI4X0"},"href":"https://api.spotify.com/v1/artists/7n2Ycct7Beij7Dj7meI4X0","id":"7n2Ycct7Beij7Dj7meI4X0","name":"TWICE","type":"artist","uri":"spotify:artist:7n2Ycct7Beij7Dj7meI4X0"}],"external_urls":{"spotify":"https://open.spotify.com/album/5YamV8eSywqu7g1Ms4GoqA"},"href":"https://api.spotify.com/v1/albums/5YamV8eSywqu7g1Ms4GoqA","id":"5YamV8eSywqu7g1Ms4GoqA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273acf8ff27be32aec99d6c99a0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02acf8ff27be32aec99d6c99a0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851acf8ff27be32aec99d6c99a0"}],"is_playable":true,"name":"STRATEGY","release_date":"2024-12-06","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:5YamV8eSywqu7g1Ms4GoqA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7n2Ycct7Beij7Dj7meI4X0"},"href":"https://api.spotify.com/v1/artists/7n2Ycct7Beij7Dj7meI4X0","id":"7n2Ycct7Beij7Dj7meI4X0","name":"TWICE","type":"artist","uri":"spotify:artist:7n2Ycct7Beij7Dj7meI4X0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/181bsRPaVXVlUKXrxwZfHK"},"href":"https://api.spotify.com/v1/artists/181bsRPaVXVlUKXrxwZfHK","id":"181bsRPaVXVlUKXrxwZfHK","name":"Megan Thee Stallion","type":"artist","uri":"spotify:artist:181bsRPaVXVlUKXrxwZfHK"}],"disc_number":1,"duration_ms":201760,"explicit":false,"external_ids":{"isrc":"US5TA2400297"},"external_urls":{"spotify":"https://open.spotify.com/track/5zQUndaoBtXJ10SsApqtvw"},"href":"https://api.spotify.com/v1/tracks/5zQUndaoBtXJ10SsApqtvw","id":"5zQUndaoBtXJ10SsApqtvw","is_local":false,"is_playable":true,"name":"Strategy (feat. Megan Thee Stallion)","track_number":1,"type":"track","uri":"spotify:track:5zQUndaoBtXJ10SsApqtvw"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7mW7Tv7NvywKKXqafZo0Lc"},"href":"https://api.spotify.com/v1/artists/7mW7Tv7NvywKKXqafZo0Lc","id":"7mW7Tv7NvywKKXqafZo0Lc","name":"KPop Demon Hunters Cast","type":"artist","uri":"spotify:artist:7mW7Tv7NvywKKXqafZo0Lc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2yNNYQBChuox9A5Ka93BIn"},"href":"https://api.spotify.com/v1/artists/2yNNYQBChuox9A5Ka93BIn","id":"2yNNYQBChuox9A5Ka93BIn","name":"HUNTR/X","type":"artist","uri":"spotify:artist:2yNNYQBChuox9A5Ka93BIn"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0BJ2EjOqcfgFvlZXNKrNbE"},"href":"https://api.spotify.com/v1/artists/0BJ2EjOqcfgFvlZXNKrNbE","id":"0BJ2EjOqcfgFvlZXNKrNbE","name":"Saja Boys","type":"artist","uri":"spotify:artist:0BJ2EjOqcfgFvlZXNKrNbE"}],"external_urls":{"spotify":"https://open.spotify.com/album/14JkAa6IiFaOh5s0nMyMU9"},"href":"https://api.spotify.com/v1/albums/14JkAa6IiFaOh5s0nMyMU9","id":"14JkAa6IiFaOh5s0nMyMU9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734dcb6c5df15cf74596ab25a4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024dcb6c5df15cf74596ab25a4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514dcb6c5df15cf74596ab25a4"}],"is_playable":true,"name":"KPop Demon Hunters (Soundtrack from the Netflix Film)","release_date":"2025-06-20","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:14JkAa6IiFaOh5s0nMyMU9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7n2Ycct7Beij7Dj7meI4X0"},"href":"https://api.spotify.com/v1/artists/7n2Ycct7Beij7Dj7meI4X0","id":"7n2Ycct7Beij7Dj7meI4X0","name":"TWICE","type":"artist","uri":"spotify:artist:7n2Ycct7Beij7Dj7meI4X0"}],"disc_number":1,"duration_ms":168645,"explicit":false,"external_ids":{"isrc":"US5TA2400303"},"external_urls":{"spotify":"https://open.spotify.com/track/6Q3lFQgpvhA9VApFKLFZtZ"},"href":"https://api.spotify.com/v1/tracks/6Q3lFQgpvhA9VApFKLFZtZ","id":"6Q3lFQgpvhA9VApFKLFZtZ","is_local":false,"is_playable":true,"name":"Strategy","track_number":5,"type":"track","uri":"spotify:track:6Q3lFQgpvhA9VApFKLFZtZ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3vbKDsSS70ZX9D2OcvbZmS"},"href":"https://api.spotify.com/v1/artists/3vbKDsSS70ZX9D2OcvbZmS","id":"3vbKDsSS70ZX9D2OcvbZmS","name":"Beck","type":"artist","uri":"spotify:artist:3vbKDsSS70ZX9D2OcvbZmS"}],"external_urls":{"spotify":"https://open.spotify.com/album/6BOQkxcHspMoRWEwEexf4l"},"href":"https://api.spotify.com/v1/albums/6BOQkxcHspMoRWEwEexf4l","id":"6BOQkxcHspMoRWEwEexf4l","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27385c5d4eeba7c22b3df57e054"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0285c5d4eeba7c22b3df57e054"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485185c5d4eeba7c22b3df57e054"}],"is_playable":true,"name":"Colors","release_date":"2017-10-13","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:6BOQkxcHspMoRWEwEexf4l"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3vbKDsSS70ZX9D2OcvbZmS"},"href":"https://api.spotify.com/v1/artists/3vbKDsSS70ZX9D2OcvbZmS","id":"3vbKDsSS70ZX9D2OcvbZmS","name":"Beck","type":"artist","uri":"spotify:artist:3vbKDsSS70ZX9D2OcvbZmS"}],"disc_number":1,"duration_ms":190447,"explicit":false,"external_ids":{"isrc":"US3841600117"},"external_urls":{"spotify":"https://open.spotify.com/track/28AgTOIZke8nitD0NNeb3G"},"href":"https://api.spotify.com/v1/tracks/28AgTOIZke8nitD0NNeb3G","id":"28AgTOIZke8nitD0NNeb3G","is_local":false,"is_playable":true,"name":"Up All Night","track_number":8,"type":"track","uri":"spotify:track:28AgTOIZke8nitD0NNeb3G"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0JlQaGJZfrqYeZG1AQICxp"},"href":"https://api.spotify.com/v1/artists/0JlQaGJZfrqYeZG1AQICxp","id":"0JlQaGJZfrqYeZG1AQICxp","name":"Hp Boyz","type":"artist","uri":"spotify:artist:0JlQaGJZfrqYeZG1AQICxp"}],"external_urls":{"spotify":"https://open.spotify.com/album/17SSVIXiqDYVEQy006XDhN"},"href":"https://api.spotify.com/v1/albums/17SSVIXiqDYVEQy006XDhN","id":"17SSVIXiqDYVEQy006XDhN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27392c54c65b0fd18bb3b224439"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0292c54c65b0fd18bb3b224439"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485192c54c65b0fd18bb3b224439"}],"is_playable":true,"name":"Bad N Bouj","release_date":"2019-09-13","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:17SSVIXiqDYVEQy006XDhN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0JlQaGJZfrqYeZG1AQICxp"},"href":"https://api.spotify.com/v1/artists/0JlQaGJZfrqYeZG1AQICxp","id":"0JlQaGJZfrqYeZG1AQICxp","name":"Hp Boyz","type":"artist","uri":"spotify:artist:0JlQaGJZfrqYeZG1AQICxp"}],"disc_number":1,"duration_ms":168483,"explicit":true,"external_ids":{"isrc":"AUG0H2401341"},"external_urls":{"spotify":"https://open.spotify.com/track/1UfVbAcMJFNJLvM0csHygh"},"href":"https://api.spotify.com/v1/tracks/1UfVbAcMJFNJLvM0csHygh","id":"1UfVbAcMJFNJLvM0csHygh","is_local":false,"is_playable":true,"name":"Bad N Bouj","track_number":1,"type":"track","uri":"spotify:track:1UfVbAcMJFNJLvM0csHygh"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3h9jrx2NF7x7EkNDZAn2De"},"href":"https://api.spotify.com/v1/artists/3h9jrx2NF7x7EkNDZAn2De","id":"3h9jrx2NF7x7EkNDZAn2De","name":"Charlie Jeer","type":"artist","uri":"spotify:artist:3h9jrx2NF7x7EkNDZAn2De"}],"external_urls":{"spotify":"https://open.spotify.com/album/13UwuUtKwqvifXpghxD823"},"href":"https://api.spotify.com/v1/albums/13UwuUtKwqvifXpghxD823","id":"13UwuUtKwqvifXpghxD823","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c1bfc68212b306e42548e6d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c1bfc68212b306e42548e6d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c1bfc68212b306e42548e6d"}],"is_playable":true,"name":"Nobody","release_date":"2025-02-07","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:13UwuUtKwqvifXpghxD823"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3h9jrx2NF7x7EkNDZAn2De"},"href":"https://api.spotify.com/v1/artists/3h9jrx2NF7x7EkNDZAn2De","id":"3h9jrx2NF7x7EkNDZAn2De","name":"Charlie Jeer","type":"artist","uri":"spotify:artist:3h9jrx2NF7x7EkNDZAn2De"}],"disc_number":1,"duration_ms":173644,"explicit":false,"external_ids":{"isrc":"GBUM72500220"},"external_urls":{"spotify":"https://open.spotify.com/track/4lWnh8J3XsWTtG20xWFjfF"},"href":"https://api.spotify.com/v1/tracks/4lWnh8J3XsWTtG20xWFjfF","id":"4lWnh8J3XsWTtG20xWFjfF","is_local":false,"is_playable":true,"name":"Nobody","track_number":1,"type":"track","uri":"spotify:track:4lWnh8J3XsWTtG20xWFjfF"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1XkoF8ryArs86LZvFOkbyr"},"href":"https://api.spotify.com/v1/artists/1XkoF8ryArs86LZvFOkbyr","id":"1XkoF8ryArs86LZvFOkbyr","name":"Mary J. Blige","type":"artist","uri":"spotify:artist:1XkoF8ryArs86LZvFOkbyr"}],"external_urls":{"spotify":"https://open.spotify.com/album/5QJmKwPveBV4IwLlo4OcG4"},"href":"https://api.spotify.com/v1/albums/5QJmKwPveBV4IwLlo4OcG4","id":"5QJmKwPveBV4IwLlo4OcG4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273096a7fc9668305db9d3175fc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02096a7fc9668305db9d3175fc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851096a7fc9668305db9d3175fc"}],"is_playable":true,"name":"No More Drama","release_date":"2001-08-28","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5QJmKwPveBV4IwLlo4OcG4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1XkoF8ryArs86LZvFOkbyr"},"href":"https://api.spotify.com/v1/artists/1XkoF8ryArs86LZvFOkbyr","id":"1XkoF8ryArs86LZvFOkbyr","name":"Mary J. Blige","type":"artist","uri":"spotify:artist:1XkoF8ryArs86LZvFOkbyr"}],"disc_number":1,"duration_ms":265866,"explicit":false,"external_ids":{"isrc":"USMC10111369"},"external_urls":{"spotify":"https://open.spotify.com/track/3aw9iWUQ3VrPQltgwvN9Xu"},"href":"https://api.spotify.com/v1/tracks/3aw9iWUQ3VrPQltgwvN9Xu","id":"3aw9iWUQ3VrPQltgwvN9Xu","is_local":false,"is_playable":true,"name":"Family Affair","track_number":2,"type":"track","uri":"spotify:track:3aw9iWUQ3VrPQltgwvN9Xu"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4kYSro6naA4h99UJvo89HB"},"href":"https://api.spotify.com/v1/artists/4kYSro6naA4h99UJvo89HB","id":"4kYSro6naA4h99UJvo89HB","name":"Cardi B","type":"artist","uri":"spotify:artist:4kYSro6naA4h99UJvo89HB"}],"external_urls":{"spotify":"https://open.spotify.com/album/1LsNb6mVitbLZCxnRsbCDJ"},"href":"https://api.spotify.com/v1/albums/1LsNb6mVitbLZCxnRsbCDJ","id":"1LsNb6mVitbLZCxnRsbCDJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734449c12628ef639dd6500c4a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024449c12628ef639dd6500c4a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514449c12628ef639dd6500c4a"}],"is_playable":true,"name":"AM I THE DRAMA?","release_date":"2025-09-19","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:1LsNb6mVitbLZCxnRsbCDJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4kYSro6naA4h99UJvo89HB"},"href":"https://api.spotify.com/v1/artists/4kYSro6naA4h99UJvo89HB","id":"4kYSro6naA4h99UJvo89HB","name":"Cardi B","type":"artist","uri":"spotify:artist:4kYSro6naA4h99UJvo89HB"}],"disc_number":1,"duration_ms":206720,"explicit":true,"external_ids":{"isrc":"USAT22504480"},"external_urls":{"spotify":"https://open.spotify.com/track/0q2zGICTMJ3ZAZX0r2RLNH"},"href":"https://api.spotify.com/v1/tracks/0q2zGICTMJ3ZAZX0r2RLNH","id":"0q2zGICTMJ3ZAZX0r2RLNH","is_local":false,"is_playable":true,"name":"Outside","track_number":12,"type":"track","uri":"spotify:track:0q2zGICTMJ3ZAZX0r2RLNH"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4kYSro6naA4h99UJvo89HB"},"href":"https://api.spotify.com/v1/artists/4kYSro6naA4h99UJvo89HB","id":"4kYSro6naA4h99UJvo89HB","name":"Cardi B","type":"artist","uri":"spotify:artist:4kYSro6naA4h99UJvo89HB"}],"external_urls":{"spotify":"https://open.spotify.com/album/3yFZYSdLY7V209cDXPEeae"},"href":"https://api.spotify.com/v1/albums/3yFZYSdLY7V209cDXPEeae","id":"3yFZYSdLY7V209cDXPEeae","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273cc59191bafcaea197c3bdfc6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02cc59191bafcaea197c3bdfc6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851cc59191bafcaea197c3bdfc6"}],"is_playable":true,"name":"Outside","release_date":"2025-06-20","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3yFZYSdLY7V209cDXPEeae"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4kYSro6naA4h99UJvo89HB"},"href":"https://api.spotify.com/v1/artists/4kYSro6naA4h99UJvo89HB","id":"4kYSro6naA4h99UJvo89HB","name":"Cardi B","type":"artist","uri":"spotify:artist:4kYSro6naA4h99UJvo89HB"}],"disc_number":1,"duration_ms":206711,"explicit":true,"external_ids":{"isrc":"USAT22504480"},"external_urls":{"spotify":"https://open.spotify.com/track/139nLHDFZNr3anx8CpUy7u"},"href":"https://api.spotify.com/v1/tracks/139nLHDFZNr3anx8CpUy7u","id":"139nLHDFZNr3anx8CpUy7u","is_local":false,"is_playable":true,"name":"Outside","track_number":1,"type":"track","uri":"spotify:track:139nLHDFZNr3anx8CpUy7u"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7IGk0iXhaPjqvQF4Zi2R2K"},"href":"https://api.spotify.com/v1/artists/7IGk0iXhaPjqvQF4Zi2R2K","id":"7IGk0iXhaPjqvQF4Zi2R2K","name":"Janne Schra","type":"artist","uri":"spotify:artist:7IGk0iXhaPjqvQF4Zi2R2K"}],"external_urls":{"spotify":"https://open.spotify.com/album/6FqyoSKSRukmIm6kcXaLJR"},"href":"https://api.spotify.com/v1/albums/6FqyoSKSRukmIm6kcXaLJR","id":"6FqyoSKSRukmIm6kcXaLJR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d452fedcc12b519ce6eed79a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d452fedcc12b519ce6eed79a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d452fedcc12b519ce6eed79a"}],"is_playable":true,"name":"Body Language","release_date":"2025-09-11","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:6FqyoSKSRukmIm6kcXaLJR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7IGk0iXhaPjqvQF4Zi2R2K"},"href":"https://api.spotify.com/v1/artists/7IGk0iXhaPjqvQF4Zi2R2K","id":"7IGk0iXhaPjqvQF4Zi2R2K","name":"Janne Schra","type":"artist","uri":"spotify:artist:7IGk0iXhaPjqvQF4Zi2R2K"}],"disc_number":1,"duration_ms":191040,"explicit":false,"external_ids":{"isrc":"NL4BA2500004"},"external_urls":{"spotify":"https://open.spotify.com/track/0lMWdThDnxoiySOEX6ur4o"},"href":"https://api.spotify.com/v1/tracks/0lMWdThDnxoiySOEX6ur4o","id":"0lMWdThDnxoiySOEX6ur4o","is_local":false,"is_playable":true,"name":"Body Language","track_number":1,"type":"track","uri":"spotify:track:0lMWdThDnxoiySOEX6ur4o"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1Cb2R5JTIwTG9vc2UlMjBXaWxraW5zb24mdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MTAmbGltaXQ9MTAmcXVlcnk9Qm9keSUyMExvb3NlJTIwV2lsa2luc29uJnR5cGU9dHJhY2siLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MTIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzczNTJhUlkybXFTeEJad3pVYjZMbUEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNzM1MmFSWTJtcVN4Qlp3elViNkxtQSIsImlkIjoiNzM1MmFSWTJtcVN4Qlp3elViNkxtQSIsIm5hbWUiOiJCb3cgV293IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjczNTJhUlkybXFTeEJad3pVYjZMbUEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82NUcwQnBWMDBHbUxpNVdVQ2VXZHZUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjVHMEJwVjAwR21MaTVXVUNlV2R2VCIsImlkIjoiNjVHMEJwVjAwR21MaTVXVUNlV2R2VCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjMGU0YjYxYWU0NDJhMjRlMDIwYzY3ZWQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYzBlNGI2MWFlNDQyYTI0ZTAyMGM2N2VkIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjMGU0YjYxYWU0NDJhMjRlMDIwYzY3ZWQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2FudGVkIiwicmVsZWFzZV9kYXRlIjoiMjAwNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2NUcwQnBWMDBHbUxpNVdVQ2VXZHZUIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNzM1MmFSWTJtcVN4Qlp3elViNkxtQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cw==", + "LzczNTJhUlkybXFTeEJad3pVYjZMbUEiLCJpZCI6IjczNTJhUlkybXFTeEJad3pVYjZMbUEiLCJuYW1lIjoiQm93IFdvdyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3MzUyYVJZMm1xU3hCWnd6VWI2TG1BIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOZGVWNXJMbTQ3eEF2b2dYclloSlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk5kZVY1ckxtNDd4QXZvZ1hyWWhKWCIsImlkIjoiMk5kZVY1ckxtNDd4QXZvZ1hyWWhKWCIsIm5hbWUiOiJDaWFyYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTmRlVjVyTG00N3hBdm9nWHJZaEpYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNTg0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTU00xMDUwMDQxMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2pFcXJJZndLTzBNOEFMdTNUR2lsRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNqRXFySWZ3S08wTThBTHUzVEdpbEYiLCJpZCI6IjNqRXFySWZ3S08wTThBTHUzVEdpbEYiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGlrZSBZb3UgKGZlYXQuIENpYXJhKSIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozakVxcklmd0tPME04QUx1M1RHaWxGIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzduMlljY3Q3QmVpajdEajdtZUk0WDAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN24yWWNjdDdCZWlqN0RqN21lSTRYMCIsImlkIjoiN24yWWNjdDdCZWlqN0RqN21lSTRYMCIsIm5hbWUiOiJUV0lDRSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3bjJZY2N0N0JlaWo3RGo3bWVJNFgwIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVlhbVY4ZVN5d3F1N2cxTXM0R29xQSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVZYW1WOGVTeXdxdTdnMU1zNEdvcUEiLCJpZCI6IjVZYW1WOGVTeXdxdTdnMU1zNEdvcUEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMA==", + "MGIyNzNhY2Y4ZmYyN2JlMzJhZWM5OWQ2Yzk5YTAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWNmOGZmMjdiZTMyYWVjOTlkNmM5OWEwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhY2Y4ZmYyN2JlMzJhZWM5OWQ2Yzk5YTAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU1RSQVRFR1kiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTEyLTA2IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1WWFtVjhlU3l3cXU3ZzFNczRHb3FBIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN24yWWNjdDdCZWlqN0RqN21lSTRYMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83bjJZY2N0N0JlaWo3RGo3bWVJNFgwIiwiaWQiOiI3bjJZY2N0N0JlaWo3RGo3bWVJNFgwIiwibmFtZSI6IlRXSUNFIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjduMlljY3Q3QmVpajdEajdtZUk0WDAifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTgxYnNSUGFWWFZsVUtYcnh3WmZISyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xODFic1JQYVZYVmxVS1hyeHdaZkhLIiwiaWQiOiIxODFic1JQYVZYVmxVS1hyeHdaZkhLIiwibmFtZSI6Ik1lZ2FuIFRoZWUgU3RhbGxpb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MTgxYnNSUGFWWFZsVUtYcnh3WmZISyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDE3NjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVUzVUQTI0MDAyOTcifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzV6UVVuZGFvQnRYSjEwU3NBcHF0dncifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81elFVbmRhb0J0WEoxMFNzQXBxdHZ3IiwiaWQiOiI1elFVbmRhb0J0WEoxMFNzQXBxdHZ3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN0cmF0ZWd5IChmZWF0LiBNZWdhbiBUaGVlIFN0YWxsaW9uKSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1elFVbmRhb0J0WEoxMFNzQQ==", + "cHF0dncifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN21XN1R2N052eXdLS1hxYWZabzBMYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83bVc3VHY3TnZ5d0tLWHFhZlpvMExjIiwiaWQiOiI3bVc3VHY3TnZ5d0tLWHFhZlpvMExjIiwibmFtZSI6IktQb3AgRGVtb24gSHVudGVycyBDYXN0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdtVzdUdjdOdnl3S0tYcWFmWm8wTGMifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMnlOTllRQkNodW94OUE1S2E5M0JJbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yeU5OWVFCQ2h1b3g5QTVLYTkzQkluIiwiaWQiOiIyeU5OWVFCQ2h1b3g5QTVLYTkzQkluIiwibmFtZSI6IkhVTlRSL1giLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MnlOTllRQkNodW94OUE1S2E5M0JJbiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wQkoyRWpPcWNmZ0Z2bFpYTktyTmJFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBCSjJFak9xY2ZnRnZsWlhOS3JOYkUiLCJpZCI6IjBCSjJFak9xY2ZnRnZsWlhOS3JOYkUiLCJuYW1lIjoiU2FqYSBCb3lzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBCSjJFak9xY2ZnRnZsWlhOS3JOYkUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xNEprQWE2SWlGYU9oNXMwbk15TVU5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMTRKa0FhNklpRmFPaDVzMG5NeU1VOSIsImlkIjoiMTRKa0FhNklpRmFPaDVzMG5NeU1VOSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0ZGNiNmM1ZGYxNWNmNzQ1OTZhYjI1YTQifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNGRjYjZjNWRmMTVjZjc0NTk2YWIyNWE0In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0ZGNiNmM1ZGYxNWNmNzQ1OTZhYjI1YTQifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiS1BvcA==", + "IERlbW9uIEh1bnRlcnMgKFNvdW5kdHJhY2sgZnJvbSB0aGUgTmV0ZmxpeCBGaWxtKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDYtMjAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxNEprQWE2SWlGYU9oNXMwbk15TVU5In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN24yWWNjdDdCZWlqN0RqN21lSTRYMCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83bjJZY2N0N0JlaWo3RGo3bWVJNFgwIiwiaWQiOiI3bjJZY2N0N0JlaWo3RGo3bWVJNFgwIiwibmFtZSI6IlRXSUNFIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjduMlljY3Q3QmVpajdEajdtZUk0WDAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTY4NjQ1LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVM1VEEyNDAwMzAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82UTNsRlFncHZoQTlWQXBGS0xGWnRaIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNlEzbEZRZ3B2aEE5VkFwRktMRlp0WiIsImlkIjoiNlEzbEZRZ3B2aEE5VkFwRktMRlp0WiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTdHJhdGVneSIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2UTNsRlFncHZoQTlWQXBGS0xGWnRaIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN2YktEc1NTNzBaWDlEMk9jdmJabVMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3ZiS0RzU1M3MFpYOUQyT2N2YlptUyIsImlkIjoiM3ZiS0RzU1M3MFpYOUQyT2N2YlptUyIsIm5hbWUiOiJCZWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN2YktEc1NTNzBaWDlEMk9jdmJabVMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82Qk9Ra3hjSHNwTW9SV0V3RWV4ZjRsIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNkJPUWt4Y0hzcE1vUldFd0VleGY0bCIsImlkIjoiNkJPUWt4Y0hzcE1vUldFd0VleGY0bCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZA==", + "dGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzg1YzVkNGVlYmE3YzIyYjNkZjU3ZTA1NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4NWM1ZDRlZWJhN2MyMmIzZGY1N2UwNTQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTg1YzVkNGVlYmE3YzIyYjNkZjU3ZTA1NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDb2xvcnMiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTEwLTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NkJPUWt4Y0hzcE1vUldFd0VleGY0bCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzN2YktEc1NTNzBaWDlEMk9jdmJabVMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3ZiS0RzU1M3MFpYOUQyT2N2YlptUyIsImlkIjoiM3ZiS0RzU1M3MFpYOUQyT2N2YlptUyIsIm5hbWUiOiJCZWNrIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN2YktEc1NTNzBaWDlEMk9jdmJabVMifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTkwNDQ3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVMzODQxNjAwMTE3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8yOEFnVE9JWmtlOG5pdEQwTk5lYjNHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMjhBZ1RPSVprZThuaXREME5OZWIzRyIsImlkIjoiMjhBZ1RPSVprZThuaXREME5OZWIzRyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJVcCBBbGwgTmlnaHQiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MjhBZ1RPSVprZThuaXREME5OZWIzRyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEpsUWFHSlpmcnFZZVpHMUFRSUN4cCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wSmxRYUdKWmZycVllWkcxQVFJQ3hwIiwiaWQiOiIwSmxRYUdKWmZycVllWkcxQVFJQ3hwIiwibmFtZSI6IkhwIEJveXoiLA==", + "InR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowSmxRYUdKWmZycVllWkcxQVFJQ3hwIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMTdTU1ZJWGlxRFlWRVF5MDA2WERoTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzE3U1NWSVhpcURZVkVReTAwNlhEaE4iLCJpZCI6IjE3U1NWSVhpcURZVkVReTAwNlhEaE4iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTJjNTRjNjViMGZkMThiYjNiMjI0NDM5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjkyYzU0YzY1YjBmZDE4YmIzYjIyNDQzOSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOTJjNTRjNjViMGZkMThiYjNiMjI0NDM5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhZCBOIEJvdWoiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA5LTEzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxN1NTVklYaXFEWVZFUXkwMDZYRGhOIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEpsUWFHSlpmcnFZZVpHMUFRSUN4cCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wSmxRYUdKWmZycVllWkcxQVFJQ3hwIiwiaWQiOiIwSmxRYUdKWmZycVllWkcxQVFJQ3hwIiwibmFtZSI6IkhwIEJveXoiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEpsUWFHSlpmcnFZZVpHMUFRSUN4cCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjg0ODMsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkFVRzBIMjQwMTM0MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVVmVmJBY01KRk5KTHZNMGNzSHlnaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFVZlZiQWNNSkZOSkx2TTBjc0h5Z2giLCJpZCI6IjFVZlZiQWNNSkZOSkx2TTBjc0h5Z2giLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmFkIE4gQm91aiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeQ==", + "OnRyYWNrOjFVZlZiQWNNSkZOSkx2TTBjc0h5Z2gifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNoOWpyeDJORjd4N0VrTkRaQW4yRGUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2g5anJ4Mk5GN3g3RWtORFpBbjJEZSIsImlkIjoiM2g5anJ4Mk5GN3g3RWtORFpBbjJEZSIsIm5hbWUiOiJDaGFybGllIEplZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M2g5anJ4Mk5GN3g3RWtORFpBbjJEZSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzEzVXd1VXRLd3F2aWZYcGdoeEQ4MjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xM1V3dVV0S3dxdmlmWHBnaHhEODIzIiwiaWQiOiIxM1V3dVV0S3dxdmlmWHBnaHhEODIzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZjMWJmYzY4MjEyYjMwNmU0MjU0OGU2ZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2YzFiZmM2ODIxMmIzMDZlNDI1NDhlNmQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZjMWJmYzY4MjEyYjMwNmU0MjU0OGU2ZCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOb2JvZHkiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTAyLTA3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxM1V3dVV0S3dxdmlmWHBnaHhEODIzIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM2g5anJ4Mk5GN3g3RWtORFpBbjJEZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zaDlqcngyTkY3eDdFa05EWkFuMkRlIiwiaWQiOiIzaDlqcngyTkY3eDdFa05EWkFuMkRlIiwibmFtZSI6IkNoYXJsaWUgSmVlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozaDlqcngyTkY3eDdFa05EWkFuMkRlIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3MzY0NCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MjUwMDIyMCJ9LA==", + "ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80bFduaDhKM1hzV1R0RzIweFdGamZGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGxXbmg4SjNYc1dUdEcyMHhXRmpmRiIsImlkIjoiNGxXbmg4SjNYc1dUdEcyMHhXRmpmRiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJOb2JvZHkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGxXbmg4SjNYc1dUdEcyMHhXRmpmRiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xWGtvRjhyeUFyczg2TFp2Rk9rYnlyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFYa29GOHJ5QXJzODZMWnZGT2tieXIiLCJpZCI6IjFYa29GOHJ5QXJzODZMWnZGT2tieXIiLCJuYW1lIjoiTWFyeSBKLiBCbGlnZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxWGtvRjhyeUFyczg2TFp2Rk9rYnlyIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVFKbUt3UHZlQlY0SXdMbG80T2NHNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVRSm1Ld1B2ZUJWNEl3TGxvNE9jRzQiLCJpZCI6IjVRSm1Ld1B2ZUJWNEl3TGxvNE9jRzQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDk2YTdmYzk2NjgzMDVkYjlkMzE3NWZjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA5NmE3ZmM5NjY4MzA1ZGI5ZDMxNzVmYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDk2YTdmYzk2NjgzMDVkYjlkMzE3NWZjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik5vIE1vcmUgRHJhbWEiLCJyZWxlYXNlX2RhdGUiOiIyMDAxLTA4LTI4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NVFKbUt3UHZlQlY0SXdMbG80T2NHNCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFYa29GOHJ5QXJzODZMWg==", + "dkZPa2J5ciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xWGtvRjhyeUFyczg2TFp2Rk9rYnlyIiwiaWQiOiIxWGtvRjhyeUFyczg2TFp2Rk9rYnlyIiwibmFtZSI6Ik1hcnkgSi4gQmxpZ2UiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MVhrb0Y4cnlBcnM4NkxadkZPa2J5ciJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjU4NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU01DMTAxMTEzNjkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNhdzlpV1VRM1ZyUFFsdGd3dk45WHUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zYXc5aVdVUTNWclBRbHRnd3ZOOVh1IiwiaWQiOiIzYXc5aVdVUTNWclBRbHRnd3ZOOVh1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZhbWlseSBBZmZhaXIiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2F3OWlXVVEzVnJQUWx0Z3d2TjlYdSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80a1lTcm82bmFBNGg5OVVKdm84OUhCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRrWVNybzZuYUE0aDk5VUp2bzg5SEIiLCJpZCI6IjRrWVNybzZuYUE0aDk5VUp2bzg5SEIiLCJuYW1lIjoiQ2FyZGkgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0a1lTcm82bmFBNGg5OVVKdm84OUhCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMUxzTmI2bVZpdGJMWkN4blJzYkNESiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFMc05iNm1WaXRiTFpDeG5Sc2JDREoiLCJpZCI6IjFMc05iNm1WaXRiTFpDeG5Sc2JDREoiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDQ0OWMxMjYyOGVmNjM5ZGQ2NTAwYzRhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQ0NDljMTI2MjhlZjYzOWRkNjUwMGM0YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDQ0OWMxMg==", + "NjI4ZWY2MzlkZDY1MDBjNGEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQU0gSSBUSEUgRFJBTUE/IiwicmVsZWFzZV9kYXRlIjoiMjAyNS0wOS0xOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFMc05iNm1WaXRiTFpDeG5Sc2JDREoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80a1lTcm82bmFBNGg5OVVKdm84OUhCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRrWVNybzZuYUE0aDk5VUp2bzg5SEIiLCJpZCI6IjRrWVNybzZuYUE0aDk5VUp2bzg5SEIiLCJuYW1lIjoiQ2FyZGkgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0a1lTcm82bmFBNGg5OVVKdm84OUhCIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNjcyMCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBVDIyNTA0NDgwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wcTJ6R0lDVE1KM1pBWlgwcjJSTE5IIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMHEyekdJQ1RNSjNaQVpYMHIyUkxOSCIsImlkIjoiMHEyekdJQ1RNSjNaQVpYMHIyUkxOSCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPdXRzaWRlIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowcTJ6R0lDVE1KM1pBWlgwcjJSTE5IIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80a1lTcm82bmFBNGg5OVVKdm84OUhCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRrWVNybzZuYUE0aDk5VUp2bzg5SEIiLCJpZCI6IjRrWVNybzZuYUE0aDk5VUp2bzg5SEIiLCJuYW1lIjoiQ2FyZGkgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0a1lTcm82bmFBNGg5OVVKdm84OUhCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM3lGWllTZExZN1YyMDljRFhQRWVhZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzN5RlpZU2RMWTdWMjA5Y0RYUEVlYWUiLCJpZCI6IjN5RlpZU2RMWTdWMjA5Y0RYUEVlYWUiLCJpbWFnZXMiOg==", + "W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNjYzU5MTkxYmFmY2FlYTE5N2MzYmRmYzYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyY2M1OTE5MWJhZmNhZWExOTdjM2JkZmM2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFjYzU5MTkxYmFmY2FlYTE5N2MzYmRmYzYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiT3V0c2lkZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDYtMjAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjN5RlpZU2RMWTdWMjA5Y0RYUEVlYWUifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80a1lTcm82bmFBNGg5OVVKdm84OUhCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRrWVNybzZuYUE0aDk5VUp2bzg5SEIiLCJpZCI6IjRrWVNybzZuYUE0aDk5VUp2bzg5SEIiLCJuYW1lIjoiQ2FyZGkgQiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0a1lTcm82bmFBNGg5OVVKdm84OUhCIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNjcxMSwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBVDIyNTA0NDgwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xMzluTEhERlpOcjNhbng4Q3BVeTd1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMTM5bkxIREZaTnIzYW54OENwVXk3dSIsImlkIjoiMTM5bkxIREZaTnIzYW54OENwVXk3dSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJPdXRzaWRlIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjEzOW5MSERGWk5yM2FueDhDcFV5N3UifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJl", + "eHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdJR2swaVhoYVBqcXZRRjRaaTJSMksifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0lHazBpWGhhUGpxdlFGNFppMlIySyIsImlkIjoiN0lHazBpWGhhUGpxdlFGNFppMlIySyIsIm5hbWUiOiJKYW5uZSBTY2hyYSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3SUdrMGlYaGFQanF2UUY0WmkyUjJLIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkZxeW9TS1NSdWttSW02a2NYYUxKUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZGcXlvU0tTUnVrbUltNmtjWGFMSlIiLCJpZCI6IjZGcXlvU0tTUnVrbUltNmtjWGFMSlIiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDQ1MmZlZGNjMTJiNTE5Y2U2ZWVkNzlhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQ0NTJmZWRjYzEyYjUxOWNlNmVlZDc5YSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDQ1MmZlZGNjMTJiNTE5Y2U2ZWVkNzlhIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJvZHkgTGFuZ3VhZ2UiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA5LTExIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2RnF5b1NLU1J1a21JbTZrY1hhTEpSIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0lHazBpWGhhUGpxdlFGNFppMlIySyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83SUdrMGlYaGFQanF2UUY0WmkyUjJLIiwiaWQiOiI3SUdrMGlYaGFQanF2UUY0WmkyUjJLIiwibmFtZSI6Ikphbm5lIFNjaHJhIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdJR2swaVhoYVBqcXZRRjRaaTJSMksifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTkxMDQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiTkw0QkEyNTAwMDA0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wbE1XZFRoRG54b2l5Uw==", + "T0VYNnVyNG8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wbE1XZFRoRG54b2l5U09FWDZ1cjRvIiwiaWQiOiIwbE1XZFRoRG54b2l5U09FWDZ1cjRvIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJvZHkgTGFuZ3VhZ2UiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGxNV2RUaERueG9peVNPRVg2dXI0byJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Body+Loose+Wilkinson&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZvZGthJTIwJTI2JTIwQ29rZSUyMiUyMGFydGlzdCUzQSUyMkRlbHRhJTIwSGVhdnklMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlZvZGthJTIwJTI2JTIwQ29rZSUyMiUyMGFydGlzdCUzQSUyMkRlbHRhJTIwSGVhdnklMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Vodka+%26+Coke%22+artist%3A%22Delta+Heavy%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1UdXJidWxlbmNlJTIwUnVkaW1lbnRhbCZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzA3b1lXbnNuQVhaUWIxbG5KN1pIUFkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMDdvWVduc25BWFpRYjFsbko3WkhQWSIsImlkIjoiMDdvWVduc25BWFpRYjFsbko3WkhQWSIsIm5hbWUiOiJGYWx0b3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MDdvWVduc25BWFpRYjFsbko3WkhQWSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZPcFpBcUhaY2p3d2dEc0dJREJRYlYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82T3BaQXFIWmNqd3dnRHNHSURCUWJWIiwiaWQiOiI2T3BaQXFIWmNqd3dnRHNHSURCUWJWIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzAyODRlMzEzMTEwMWIxMg==", + "YzBjYzY0NzFkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjAyODRlMzEzMTEwMWIxMmMwY2M2NDcxZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDI4NGUzMTMxMTAxYjEyYzBjYzY0NzFkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlR1cmJ1bGVuY2UiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTA1LTIzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2T3BaQXFIWmNqd3dnRHNHSURCUWJWIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMDdvWVduc25BWFpRYjFsbko3WkhQWSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wN29ZV25zbkFYWlFiMWxuSjdaSFBZIiwiaWQiOiIwN29ZV25zbkFYWlFiMWxuSjdaSFBZIiwibmFtZSI6IkZhbHRvcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowN29ZV25zbkFYWlFiMWxuSjdaSFBZIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEzMDU3NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCS1FVMjQ0OTE3OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMXpseU1YendaWDVNR2hwTjlhN2NlNyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzF6bHlNWHp3Wlg1TUdocE45YTdjZTciLCJpZCI6IjF6bHlNWHp3Wlg1TUdocE45YTdjZTciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVHVyYnVsZW5jZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxemx5TVh6d1pYNU1HaHBOOWE3Y2U3In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNzaWdhRlJrOXpZOFNabWtjYnlJNXEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM3NpZ2FGUms5elk4U1pta2NieUk1cSIsImlkIjoiM3NpZ2FGUms5elk4U1pta2NieUk1cSIsIm5hbWUiOiJDaHJpcyBOYWxiYW5kaWFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNzaWdhRlJrOXpZOFNabWtjYnlJNQ==", + "cSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzA5ZU9samVwMkVkZjYwTkwyVmllVFEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wOWVPbGplcDJFZGY2ME5MMlZpZVRRIiwiaWQiOiIwOWVPbGplcDJFZGY2ME5MMlZpZVRRIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2YxOTJmYjAwOGZlZWUxOWFhYWM0MTU4ZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmMTkyZmIwMDhmZWVlMTlhYWFjNDE1OGUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWYxOTJmYjAwOGZlZWUxOWFhYWM0MTU4ZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQYXJhbHlzaXMgb2YgQW5hbHlzaXMiLCJyZWxlYXNlX2RhdGUiOiIyMDEwLTA2LTI4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowOWVPbGplcDJFZGY2ME5MMlZpZVRRIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3NpZ2FGUms5elk4U1pta2NieUk1cSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zc2lnYUZSazl6WThTWm1rY2J5STVxIiwiaWQiOiIzc2lnYUZSazl6WThTWm1rY2J5STVxIiwibmFtZSI6IkNocmlzIE5hbGJhbmRpYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M3NpZ2FGUms5elk4U1pta2NieUk1cSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNzE0MTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJ1c2htMjEwMzA3MDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNwMnExODhLUFFzZVFRQm1wV29vTGEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zcDJxMTg4S1BRc2VRUUJtcFdvb0xhIiwiaWQiOiIzcDJxMTg4S1BRc2VRUUJtcFdvb0xhIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlR1cmJ1bGVuY2UiLCJ0cmFja19udW1iZXIiOjgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M3AycTE4OEtQUXNlUVFCbXBXb29MYSJ9LHsiYWxidQ==", + "bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFLQ1NQWTFnbElLcVcyVG90V3VYT1IifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUtDU1BZMWdsSUtxVzJUb3RXdVhPUiIsImlkIjoiMUtDU1BZMWdsSUtxVzJUb3RXdVhPUiIsIm5hbWUiOiJQIW5rIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFLQ1NQWTFnbElLcVcyVG90V3VYT1IifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xR0lXSnM3bUVkekt5bTN0UThRU2NKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUdJV0pzN21FZHpLeW0zdFE4UVNjSiIsImlkIjoiMUdJV0pzN21FZHpLeW0zdFE4UVNjSiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNhYmNkMWEzNDliYzliN2IwMmQ4MDhkYjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYWJjZDFhMzQ5YmM5YjdiMDJkODA4ZGI3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhYmNkMWEzNDliYzliN2IwMmQ4MDhkYjcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVFJVU1RGQUxMIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wMi0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFHSVdKczdtRWR6S3ltM3RROFFTY0oifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xS0NTUFkxZ2xJS3FXMlRvdFd1WE9SIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFLQ1NQWTFnbElLcVcyVG90V3VYT1IiLCJpZCI6IjFLQ1NQWTFnbElLcVcyVG90V3VYT1IiLCJuYW1lIjoiUCFuayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxS0NTUFkxZ2xJS3FXMlRvdFd1WE9SIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNjQ1NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkMxMjIwNDE5MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jbw==", + "bS90cmFjay8xZEp6VE5tNDZydHZRUjJBM0daVThGIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMWRKelRObTQ2cnR2UVIyQTNHWlU4RiIsImlkIjoiMWRKelRObTQ2cnR2UVIyQTNHWlU4RiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUdXJidWxlbmNlIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFkSnpUTm00NnJ0dlFSMkEzR1pVOEYifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Turbulence+Rudimental&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Aftermath%20Camo%20%26%20Krooked&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":6,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/17BmVePNxhzlRGKc85xYsd"},"href":"https://api.spotify.com/v1/artists/17BmVePNxhzlRGKc85xYsd","id":"17BmVePNxhzlRGKc85xYsd","name":"Dan Bull","type":"artist","uri":"spotify:artist:17BmVePNxhzlRGKc85xYsd"}],"external_urls":{"spotify":"https://open.spotify.com/album/6KxtFWYnWSvSAP05aOg1sE"},"href":"https://api.spotify.com/v1/albums/6KxtFWYnWSvSAP05aOg1sE","id":"6KxtFWYnWSvSAP05aOg1sE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27357af0540089e17b47222ba57"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0257af0540089e17b47222ba57"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485157af0540089e17b47222ba57"}],"is_playable":true,"name":"The Garden","release_date":"2014","release_date_precision":"year","total_tracks":12,"type":"album","uri":"spotify:album:6KxtFWYnWSvSAP05aOg1sE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/17BmVePNxhzlRGKc85xYsd"},"href":"https://api.spotify.com/v1/artists/17BmVePNxhzlRGKc85xYsd","id":"17BmVePNxhzlRGKc85xYsd","name":"Dan Bull","type":"artist","uri":"spotify:artist:17BmVePNxhzlRGKc85xYsd"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3ljdpPPLFT4Io15J5eXu8k"},"href":"https://api.spotify.com/v1/artists/3ljdpPPLFT4Io15J5eXu8k","id":"3ljdpPPLFT4Io15J5eXu8k","name":"Beit Nun","type":"artist","uri":"spotify:artist:3ljdpPPLFT4Io15J5eXu8k"}],"disc_number":1,"duration_ms":160890,"explicit":true,"external_ids":{"isrc":"FR10S1413677"},"external_urls":{"spotify":"https://open.spotify.com/track/7Io1OOsVRCSTPUsoJvasle"},"href":"https://api.spotify.com/v1/tracks/7Io1OOsVRCSTPUsoJvasle","id":"7Io1OOsVRCSTPUsoJvasle","is_local":false,"is_playable":true,"name":"Top Down","track_number":6,"type":"track","uri":"spotify:track:7Io1OOsVRCSTPUsoJvasle"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4bcIXbVQvuiFEjrxIA2DHM"},"href":"https://api.spotify.com/v1/artists/4bcIXbVQvuiFEjrxIA2DHM","id":"4bcIXbVQvuiFEjrxIA2DHM","name":"The Thought","type":"artist","uri":"spotify:artist:4bcIXbVQvuiFEjrxIA2DHM"}],"external_urls":{"spotify":"https://open.spotify.com/album/3TVkI4cBE4ryCm7e5tRYKu"},"href":"https://api.spotify.com/v1/albums/3TVkI4cBE4ryCm7e5tRYKu","id":"3TVkI4cBE4ryCm7e5tRYKu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273193b3643c2f987b8e2178189"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02193b3643c2f987b8e2178189"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851193b3643c2f987b8e2178189"}],"is_playable":true,"name":"It's Not What You Think","release_date":"2019-05-31","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:3TVkI4cBE4ryCm7e5tRYKu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4bcIXbVQvuiFEjrxIA2DHM"},"href":"https://api.spotify.com/v1/artists/4bcIXbVQvuiFEjrxIA2DHM","id":"4bcIXbVQvuiFEjrxIA2DHM","name":"The Thought","type":"artist","uri":"spotify:artist:4bcIXbVQvuiFEjrxIA2DHM"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7mZwevexzYEUUU6dyX4FqX"},"href":"https://api.spotify.com/v1/artists/7mZwevexzYEUUU6dyX4FqX","id":"7mZwevexzYEUUU6dyX4FqX","name":"Zen Stokely","type":"artist","uri":"spotify:artist:7mZwevexzYEUUU6dyX4FqX"}],"disc_number":1,"duration_ms":214825,"explicit":true,"external_ids":{"isrc":"QZFYW1974589"},"external_urls":{"spotify":"https://open.spotify.com/track/4K18sHuoLJigEvprDTZ90m"},"href":"https://api.spotify.com/v1/tracks/4K18sHuoLJigEvprDTZ90m","id":"4K18sHuoLJigEvprDTZ90m","is_local":false,"is_playable":true,"name":"FOOD CHAINZ","track_number":6,"type":"track","uri":"spotify:track:4K18sHuoLJigEvprDTZ90m"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5oySKQIqZqZU7JSfsvPmNH"},"href":"https://api.spotify.com/v1/artists/5oySKQIqZqZU7JSfsvPmNH","id":"5oySKQIqZqZU7JSfsvPmNH","name":"Kaiju Cant Die","type":"artist","uri":"spotify:artist:5oySKQIqZqZU7JSfsvPmNH"}],"external_urls":{"spotify":"https://open.spotify.com/album/3mZjC2ejEVkox0uDEoYmws"},"href":"https://api.spotify.com/v1/albums/3mZjC2ejEVkox0uDEoYmws","id":"3mZjC2ejEVkox0uDEoYmws","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731cc70e2fe6d2038923f2d157"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021cc70e2fe6d2038923f2d157"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511cc70e2fe6d2038923f2d157"}],"is_playable":true,"name":"VIOLENT HOSTILE SITUATION (VHS)","release_date":"2024-11-05","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:3mZjC2ejEVkox0uDEoYmws"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5oySKQIqZqZU7JSfsvPmNH"},"href":"https://api.spotify.com/v1/artists/5oySKQIqZqZU7JSfsvPmNH","id":"5oySKQIqZqZU7JSfsvPmNH","name":"Kaiju Cant Die","type":"artist","uri":"spotify:artist:5oySKQIqZqZU7JSfsvPmNH"}],"disc_number":1,"duration_ms":250830,"explicit":true,"external_ids":{"isrc":"QZNWR2472870"},"external_urls":{"spotify":"https://open.spotify.com/track/1ncWkBvzKDBsiQAmsZBZR7"},"href":"https://api.spotify.com/v1/tracks/1ncWkBvzKDBsiQAmsZBZR7","id":"1ncWkBvzKDBsiQAmsZBZR7","is_local":false,"is_playable":true,"name":"SISU'S VENGEANCE","track_number":4,"type":"track","uri":"spotify:track:1ncWkBvzKDBsiQAmsZBZR7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5oySKQIqZqZU7JSfsvPmNH"},"href":"https://api.spotify.com/v1/artists/5oySKQIqZqZU7JSfsvPmNH","id":"5oySKQIqZqZU7JSfsvPmNH","name":"Kaiju Cant Die","type":"artist","uri":"spotify:artist:5oySKQIqZqZU7JSfsvPmNH"}],"external_urls":{"spotify":"https://open.spotify.com/album/1GZRmutoJBdbk86G1N2Qn2"},"href":"https://api.spotify.com/v1/albums/1GZRmutoJBdbk86G1N2Qn2","id":"1GZRmutoJBdbk86G1N2Qn2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273973d6d49fee6548107dfe3c9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02973d6d49fee6548107dfe3c9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851973d6d49fee6548107dfe3c9"}],"is_playable":true,"name":"Sisu's Vengeance","release_date":"2024-06-03","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1GZRmutoJBdbk86G1N2Qn2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5oySKQIqZqZU7JSfsvPmNH"},"href":"https://api.spotify.com/v1/artists/5oySKQIqZqZU7JSfsvPmNH","id":"5oySKQIqZqZU7JSfsvPmNH","name":"Kaiju Cant Die","type":"artist","uri":"spotify:artist:5oySKQIqZqZU7JSfsvPmNH"}],"disc_number":1,"duration_ms":250830,"explicit":true,"external_ids":{"isrc":"QZNWR2472870"},"external_urls":{"spotify":"https://open.spotify.com/track/3Jb37v1al1nAYgL4y4Qjdf"},"href":"https://api.spotify.com/v1/tracks/3Jb37v1al1nAYgL4y4Qjdf","id":"3Jb37v1al1nAYgL4y4Qjdf","is_local":false,"is_playable":true,"name":"Sisu's Vengeance","track_number":1,"type":"track","uri":"spotify:track:3Jb37v1al1nAYgL4y4Qjdf"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3M4lwK6rsTXw8NbzekKVZz"},"href":"https://api.spotify.com/v1/artists/3M4lwK6rsTXw8NbzekKVZz","id":"3M4lwK6rsTXw8NbzekKVZz","name":"AiBangers","type":"artist","uri":"spotify:artist:3M4lwK6rsTXw8NbzekKVZz"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Eyl03dsBo9GazTD3Mwqkq"},"href":"https://api.spotify.com/v1/albums/5Eyl03dsBo9GazTD3Mwqkq","id":"5Eyl03dsBo9GazTD3Mwqkq","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731e9ec5b0b94bb9dcba54deb4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021e9ec5b0b94bb9dcba54deb4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511e9ec5b0b94bb9dcba54deb4"}],"is_playable":true,"name":"Berget 21","release_date":"2025-06-12","release_date_precision":"day","total_tracks":4,"type":"album","uri":"spotify:album:5Eyl03dsBo9GazTD3Mwqkq"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3M4lwK6rsTXw8NbzekKVZz"},"href":"https://api.spotify.com/v1/artists/3M4lwK6rsTXw8NbzekKVZz","id":"3M4lwK6rsTXw8NbzekKVZz","name":"AiBangers","type":"artist","uri":"spotify:artist:3M4lwK6rsTXw8NbzekKVZz"}],"disc_number":1,"duration_ms":198279,"explicit":false,"external_ids":{"isrc":"QZTB22508745"},"external_urls":{"spotify":"https://open.spotify.com/track/3SzIuynb2quJDlgUl2E65s"},"href":"https://api.spotify.com/v1/tracks/3SzIuynb2quJDlgUl2E65s","id":"3SzIuynb2quJDlgUl2E65s","is_local":false,"is_playable":true,"name":"Ghost of the green","track_number":1,"type":"track","uri":"spotify:track:3SzIuynb2quJDlgUl2E65s"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3F4vfyQQDgEg3jF3qPdeDK"},"href":"https://api.spotify.com/v1/artists/3F4vfyQQDgEg3jF3qPdeDK","id":"3F4vfyQQDgEg3jF3qPdeDK","name":"Psych3d3licX","type":"artist","uri":"spotify:artist:3F4vfyQQDgEg3jF3qPdeDK"}],"external_urls":{"spotify":"https://open.spotify.com/album/3G5cbuBM1HHm2QIEoXc2Mp"},"href":"https://api.spotify.com/v1/albums/3G5cbuBM1HHm2QIEoXc2Mp","id":"3G5cbuBM1HHm2QIEoXc2Mp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735c7379b40351c72793ccc7e3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025c7379b40351c72793ccc7e3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515c7379b40351c72793ccc7e3"}],"is_playable":true,"name":"Deranged Conspiracy Bullshit","release_date":"2026-07-31","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:3G5cbuBM1HHm2QIEoXc2Mp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3F4vfyQQDgEg3jF3qPdeDK"},"href":"https://api.spotify.com/v1/artists/3F4vfyQQDgEg3jF3qPdeDK","id":"3F4vfyQQDgEg3jF3qPdeDK","name":"Psych3d3licX","type":"artist","uri":"spotify:artist:3F4vfyQQDgEg3jF3qPdeDK"}],"disc_number":1,"duration_ms":310680,"explicit":true,"external_ids":{"isrc":"QT6FP2634085"},"external_urls":{"spotify":"https://open.spotify.com/track/5oJoafgffIIXe9LIEsiRcH"},"href":"https://api.spotify.com/v1/tracks/5oJoafgffIIXe9LIEsiRcH","id":"5oJoafgffIIXe9LIEsiRcH","is_local":false,"is_playable":true,"name":"Q-Anon is Shit (Final Tribunal)","track_number":9,"type":"track","uri":"spotify:track:5oJoafgffIIXe9LIEsiRcH"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1BZnRlcm1hdGglMjBDYW1vJTIwJTI2JTIwS3Jvb2tlZCZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6NiwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMTdCbVZlUE54aHpsUkdLYzg1eFlzZCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8xN0JtVmVQTnhoemxSR0tjODV4WXNkIiwiaWQiOiIxN0JtVmVQTnhoemxSR0tjODV4WXNkIiwibmFtZSI6IkRhbiBCdWxsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjE3Qm1WZVBOeGh6bFJHS2M4NXhZc2QifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82S3h0RldZbldTdlNBUDA1YU9nMXNFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNkt4dEZXWW5XU3ZTQVAwNWFPZzFzRSIsImlkIjoiNkt4dEZXWW5XU3ZTQVAwNWFPZzFzRSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1N2Fm", + "MDU0MDA4OWUxN2I0NzIyMmJhNTcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTdhZjA1NDAwODllMTdiNDcyMjJiYTU3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1N2FmMDU0MDA4OWUxN2I0NzIyMmJhNTcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIEdhcmRlbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTIsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06Nkt4dEZXWW5XU3ZTQVAwNWFPZzFzRSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzE3Qm1WZVBOeGh6bFJHS2M4NXhZc2QifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMTdCbVZlUE54aHpsUkdLYzg1eFlzZCIsImlkIjoiMTdCbVZlUE54aHpsUkdLYzg1eFlzZCIsIm5hbWUiOiJEYW4gQnVsbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxN0JtVmVQTnhoemxSR0tjODV4WXNkIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNsamRwUFBMRlQ0SW8xNUo1ZVh1OGsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM2xqZHBQUExGVDRJbzE1SjVlWHU4ayIsImlkIjoiM2xqZHBQUExGVDRJbzE1SjVlWHU4ayIsIm5hbWUiOiJCZWl0IE51biIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozbGpkcFBQTEZUNElvMTVKNWVYdThrIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2MDg5MCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiRlIxMFMxNDEzNjc3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83SW8xT09zVlJDU1RQVXNvSnZhc2xlIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN0lvMU9Pc1ZSQ1NUUFVzb0p2YXNsZSIsImlkIjoiN0lvMU9Pc1ZSQ1NUUFVzb0p2YXNsZSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUb3AgRG93biIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3SW8xT09zVlJDU1RQVXNvSnZhc2xlIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIg==", + "Olt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGJjSVhiVlF2dWlGRWpyeElBMkRITSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80YmNJWGJWUXZ1aUZFanJ4SUEyREhNIiwiaWQiOiI0YmNJWGJWUXZ1aUZFanJ4SUEyREhNIiwibmFtZSI6IlRoZSBUaG91Z2h0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRiY0lYYlZRdnVpRkVqcnhJQTJESE0ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zVFZrSTRjQkU0cnlDbTdlNXRSWUt1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM1RWa0k0Y0JFNHJ5Q203ZTV0UllLdSIsImlkIjoiM1RWa0k0Y0JFNHJ5Q203ZTV0UllLdSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxOTNiMzY0M2MyZjk4N2I4ZTIxNzgxODkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTkzYjM2NDNjMmY5ODdiOGUyMTc4MTg5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExOTNiMzY0M2MyZjk4N2I4ZTIxNzgxODkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSXQncyBOb3QgV2hhdCBZb3UgVGhpbmsiLCJyZWxlYXNlX2RhdGUiOiIyMDE5LTA1LTMxIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozVFZrSTRjQkU0cnlDbTdlNXRSWUt1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGJjSVhiVlF2dWlGRWpyeElBMkRITSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80YmNJWGJWUXZ1aUZFanJ4SUEyREhNIiwiaWQiOiI0YmNJWGJWUXZ1aUZFanJ4SUEyREhNIiwibmFtZSI6IlRoZSBUaG91Z2h0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRiY0lYYlZRdnVpRkVqcnhJQTJESE0ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN21ad2V2ZXh6WUVVVVU2ZHlYNEZxWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83bVp3ZXZleHpZRVVVVTZkeVg0RnFYIg==", + "LCJpZCI6IjdtWndldmV4ellFVVVVNmR5WDRGcVgiLCJuYW1lIjoiWmVuIFN0b2tlbHkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N21ad2V2ZXh6WUVVVVU2ZHlYNEZxWCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMTQ4MjUsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaRllXMTk3NDU4OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNEsxOHNIdW9MSmlnRXZwckRUWjkwbSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRLMThzSHVvTEppZ0V2cHJEVFo5MG0iLCJpZCI6IjRLMThzSHVvTEppZ0V2cHJEVFo5MG0iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRk9PRCBDSEFJTloiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NEsxOHNIdW9MSmlnRXZwckRUWjkwbSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81b3lTS1FJcVpxWlU3SlNmc3ZQbU5IIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVveVNLUUlxWnFaVTdKU2ZzdlBtTkgiLCJpZCI6IjVveVNLUUlxWnFaVTdKU2ZzdlBtTkgiLCJuYW1lIjoiS2FpanUgQ2FudCBEaWUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NW95U0tRSXFacVpVN0pTZnN2UG1OSCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNtWmpDMmVqRVZrb3gwdURFb1ltd3MifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zbVpqQzJlakVWa294MHVERW9ZbXdzIiwiaWQiOiIzbVpqQzJlakVWa294MHVERW9ZbXdzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzFjYzcwZTJmZTZkMjAzODkyM2YyZDE1NyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxY2M3MGUyZmU2ZDIwMzg5MjNmMmQxNTcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTFjYzcwZTJmZTZkMjAzODkyM2YyZDE1NyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJWSU9MRU5UIEhPU1RJTEUgU0lUVUFUSU9OIA==", + "KFZIUykiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTExLTA1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozbVpqQzJlakVWa294MHVERW9ZbXdzIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNW95U0tRSXFacVpVN0pTZnN2UG1OSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81b3lTS1FJcVpxWlU3SlNmc3ZQbU5IIiwiaWQiOiI1b3lTS1FJcVpxWlU3SlNmc3ZQbU5IIiwibmFtZSI6IkthaWp1IENhbnQgRGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVveVNLUUlxWnFaVTdKU2ZzdlBtTkgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjUwODMwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWk5XUjI0NzI4NzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzFuY1drQnZ6S0RCc2lRQW1zWkJaUjcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xbmNXa0J2ektEQnNpUUFtc1pCWlI3IiwiaWQiOiIxbmNXa0J2ektEQnNpUUFtc1pCWlI3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNJU1UnUyBWRU5HRUFOQ0UiLCJ0cmFja19udW1iZXIiOjQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MW5jV2tCdnpLREJzaVFBbXNaQlpSNyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNW95U0tRSXFacVpVN0pTZnN2UG1OSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81b3lTS1FJcVpxWlU3SlNmc3ZQbU5IIiwiaWQiOiI1b3lTS1FJcVpxWlU3SlNmc3ZQbU5IIiwibmFtZSI6IkthaWp1IENhbnQgRGllIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVveVNLUUlxWnFaVTdKU2ZzdlBtTkgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xR1pSbXV0b0pCZGJrODZHMU4yUW4yIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMUdaUm11dG9KQmRiazg2RzFOMlFuMiIsImlkIjoiMUdaUm11dG9KQmRiazg2RzFOMlFuMiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dA==", + "cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzk3M2Q2ZDQ5ZmVlNjU0ODEwN2RmZTNjOSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5NzNkNmQ0OWZlZTY1NDgxMDdkZmUzYzkifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTk3M2Q2ZDQ5ZmVlNjU0ODEwN2RmZTNjOSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTaXN1J3MgVmVuZ2VhbmNlIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wNi0wMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MUdaUm11dG9KQmRiazg2RzFOMlFuMiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVveVNLUUlxWnFaVTdKU2ZzdlBtTkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNW95U0tRSXFacVpVN0pTZnN2UG1OSCIsImlkIjoiNW95U0tRSXFacVpVN0pTZnN2UG1OSCIsIm5hbWUiOiJLYWlqdSBDYW50IERpZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1b3lTS1FJcVpxWlU3SlNmc3ZQbU5IIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI1MDgzMCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUVpOV1IyNDcyODcwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zSmIzN3YxYWwxbkFZZ0w0eTRRamRmIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM0piMzd2MWFsMW5BWWdMNHk0UWpkZiIsImlkIjoiM0piMzd2MWFsMW5BWWdMNHk0UWpkZiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTaXN1J3MgVmVuZ2VhbmNlIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNKYjM3djFhbDFuQVlnTDR5NFFqZGYifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNNNGx3SzZyc1RYdzhOYnpla0tWWnoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM000bHdLNnJzVFh3OE5iemVrS1ZaeiIsImlkIjoiM000bHdLNnJzVFh3OE5iemVrS1ZaeiIsIm5hbWUiOiJBaUJhbg==", + "Z2VycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozTTRsd0s2cnNUWHc4TmJ6ZWtLVlp6In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNUV5bDAzZHNCbzlHYXpURDNNd3FrcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVFeWwwM2RzQm85R2F6VEQzTXdxa3EiLCJpZCI6IjVFeWwwM2RzQm85R2F6VEQzTXdxa3EiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMWU5ZWM1YjBiOTRiYjlkY2JhNTRkZWI0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjFlOWVjNWIwYjk0YmI5ZGNiYTU0ZGViNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMWU5ZWM1YjBiOTRiYjlkY2JhNTRkZWI0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlcmdldCAyMSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDYtMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVFeWwwM2RzQm85R2F6VEQzTXdxa3EifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zTTRsd0s2cnNUWHc4TmJ6ZWtLVlp6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNNNGx3SzZyc1RYdzhOYnpla0tWWnoiLCJpZCI6IjNNNGx3SzZyc1RYdzhOYnpla0tWWnoiLCJuYW1lIjoiQWlCYW5nZXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNNNGx3SzZyc1RYdzhOYnpla0tWWnoifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk4Mjc5LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUVpUQjIyNTA4NzQ1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zU3pJdXluYjJxdUpEbGdVbDJFNjVzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM1N6SXV5bmIycXVKRGxnVWwyRTY1cyIsImlkIjoiM1N6SXV5bmIycXVKRGxnVWwyRTY1cyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJHaG9zdCBvZiB0aGUgZ3JlZW4iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjaw==", + "IiwidXJpIjoic3BvdGlmeTp0cmFjazozU3pJdXluYjJxdUpEbGdVbDJFNjVzIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNGNHZmeVFRRGdFZzNqRjNxUGRlREsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM0Y0dmZ5UVFEZ0VnM2pGM3FQZGVESyIsImlkIjoiM0Y0dmZ5UVFEZ0VnM2pGM3FQZGVESyIsIm5hbWUiOiJQc3ljaDNkM2xpY1giLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M0Y0dmZ5UVFEZ0VnM2pGM3FQZGVESyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNHNWNidUJNMUhIbTJRSUVvWGMyTXAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zRzVjYnVCTTFISG0yUUlFb1hjMk1wIiwiaWQiOiIzRzVjYnVCTTFISG0yUUlFb1hjMk1wIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzVjNzM3OWI0MDM1MWM3Mjc5M2NjYzdlMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1YzczNzliNDAzNTFjNzI3OTNjY2M3ZTMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTVjNzM3OWI0MDM1MWM3Mjc5M2NjYzdlMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJEZXJhbmdlZCBDb25zcGlyYWN5IEJ1bGxzaGl0IiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wNy0zMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNHNWNidUJNMUhIbTJRSUVvWGMyTXAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zRjR2ZnlRUURnRWczakYzcVBkZURLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNGNHZmeVFRRGdFZzNqRjNxUGRlREsiLCJpZCI6IjNGNHZmeVFRRGdFZzNqRjNxUGRlREsiLCJuYW1lIjoiUHN5Y2gzZDNsaWNYIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNGNHZmeVFRRGdFZzNqRjNxUGRlREsifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzEwNjgwLCJleHBsaWNpdCI6dHJ1ZSwiZQ==", + "eHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFUNkZQMjYzNDA4NSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNW9Kb2FmZ2ZmSUlYZTlMSUVzaVJjSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVvSm9hZmdmZklJWGU5TElFc2lSY0giLCJpZCI6IjVvSm9hZmdmZklJWGU5TElFc2lSY0giLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUS1Bbm9uIGlzIFNoaXQgKEZpbmFsIFRyaWJ1bmFsKSIsInRyYWNrX251bWJlciI6OSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1b0pvYWZnZmZJSVhlOUxJRXNpUmNIIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Aftermath+Camo+%26+Krooked&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNhc2NhZGUlMjIlMjBhcnRpc3QlM0ElMjJDYW1vJTIwJTI2JTIwS3Jvb2tlZCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkNhc2NhZGUlMjIlMjBhcnRpc3QlM0ElMjJDYW1vJTIwJTI2JTIwS3Jvb2tlZCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Cascade%22+artist%3A%22Camo+%26+Krooked%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1UcnVlJTIwQ29sb3VyJTIwQ2FtbyUyMCUyNiUyMEtyb29rZWQmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBieEhjaTNKSWhoS0E1M244ckgzdFQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMGJ4SGNpM0pJaGhLQTUzbjhySDN0VCIsImlkIjoiMGJ4SGNpM0pJaGhLQTUzbjhySDN0VCIsIm5hbWUiOiJIaWdoIENvbnRyYXN0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBieEhjaTNKSWhoS0E1M244ckgzdFQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80R2RwMjdyZHVCQndxek9YaHBLamwwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNEdkcDI3cmR1QkJ3cXpPWGhwS2psMCIsImlkIjoiNEdkcDI3cmR1QkJ3cXpPWGhwS2psMCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMA==", + "YjI3MzJiYjI1MDQ2YjlmOGFiYjZjM2JhOTA4NCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIyYmIyNTA0NmI5ZjhhYmI2YzNiYTkwODQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTJiYjI1MDQ2YjlmOGFiYjZjM2JhOTA4NCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUcnVlIENvbG91cnMgKDIwdGggQW5uaXZlcnNhcnkgRWRpdGlvbiArIFJlbWl4ZXMpIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0wNi0yNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRHZHAyN3JkdUJCd3F6T1hocEtqbDAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wYnhIY2kzSkloaEtBNTNuOHJIM3RUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBieEhjaTNKSWhoS0E1M244ckgzdFQiLCJpZCI6IjBieEhjaTNKSWhoS0E1M244ckgzdFQiLCJuYW1lIjoiSGlnaCBDb250cmFzdCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowYnhIY2kzSkloaEtBNTNuOHJIM3RUIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJOOElQTlpUaU5vM25qNG1yZU9sSFUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMk44SVBOWlRpTm8zbmo0bXJlT2xIVSIsImlkIjoiMk44SVBOWlRpTm8zbmo0bXJlT2xIVSIsIm5hbWUiOiJDYW1vICYgS3Jvb2tlZCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyTjhJUE5aVGlObzNuajRtcmVPbEhVIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzU0cXFhU0g2YnlKSWI4ZUZXeGUzUGoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTRxcWFTSDZieUpJYjhlRld4ZTNQaiIsImlkIjoiNTRxcWFTSDZieUpJYjhlRld4ZTNQaiIsIm5hbWUiOiJNZWZqdXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NTRxcWFTSDZieUpJYjhlRld4ZTNQaiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNzA2OTcsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHWDVIVjIyMDAwMDMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5Ig==", + "OiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNUEyTW9xWFdraWM5TFlyWmM2ZUt2YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVBMk1vcVhXa2ljOUxZclpjNmVLdmIiLCJpZCI6IjVBMk1vcVhXa2ljOUxZclpjNmVLdmIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmV0dXJuIE9mIEZvcmV2ZXIgLSBDYW1vICYgS3Jvb2tlZCAmIE1lZmp1cyBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1QTJNb3FYV2tpYzlMWXJaYzZlS3ZiIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zZ2swT1llTEZXWXVwR0ZSSHFMU1I3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNnazBPWWVMRldZdXBHRlJIcUxTUjciLCJpZCI6IjNnazBPWWVMRldZdXBHRlJIcUxTUjciLCJuYW1lIjoiU2hvd3RlayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZ2swT1llTEZXWXVwR0ZSSHFMU1I3In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN3ViaUJRSkhlVlVvSFZBUmJyOVdVaSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzd1YmlCUUpIZVZVb0hWQVJicjlXVWkiLCJpZCI6Ijd1YmlCUUpIZVZVb0hWQVJicjlXVWkiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjkxOTFiNDI4NGMzNTgzYWI5ZDI2NWY4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY5MTkxYjQyODRjMzU4M2FiOWQyNjVmOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjkxOTFiNDI4NGMzNTgzYWI5ZDI2NWY4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBDb2xvdXIgb2YgdGhlIEhhcmRlciBTdHlsZXMgRVAiLCJyZWxlYXNlX2RhdGUiOiIyMDI2LTA2LTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3dWJpQlFKSGVWVW9IVkFSYnI5V1VpIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcA==", + "b3RpZnkuY29tL2FydGlzdC8zZ2swT1llTEZXWXVwR0ZSSHFMU1I3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNnazBPWWVMRldZdXBHRlJIcUxTUjciLCJpZCI6IjNnazBPWWVMRldZdXBHRlJIcUxTUjciLCJuYW1lIjoiU2hvd3RlayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozZ2swT1llTEZXWXVwR0ZSSHFMU1I3In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0MjUwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MSDJMMjYwMDIwNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMzZtRzFLbXI1Nldqb29zb2hmTXBYSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzM2bUcxS21yNTZXam9vc29oZk1wWEoiLCJpZCI6IjM2bUcxS21yNTZXam9vc29oZk1wWEoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIENvbG91ciBPZiBUaGUgSGFyZGVyIFN0eWxlcyAtIDIwMjYgUmV3b3JrIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjM2bUcxS21yNTZXam9vc29oZk1wWEoifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=True+Colour+Camo+%26+Krooked&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk9uJTIwTXklMjBNaW5kJTIyJTIwYXJ0aXN0JTNBJTIyU3ViJTIwRm9jdXMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMk9uJTIwTXklMjBNaW5kJTIyJTIwYXJ0aXN0JTNBJTIyU3ViJTIwRm9jdXMlMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22On+My+Mind%22+artist%3A%22Sub+Focus%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJlbG9uZyUyMiUyMGFydGlzdCUzQSUyMlh0cmFoJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJlbG9uZyUyMiUyMGFydGlzdCUzQSUyMlh0cmFoJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Belong%22+artist%3A%22Xtrah%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Stay%20Close%20Delta%20Heavy&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Stay%20Close%20Delta%20Heavy&type=track","offset":0,"previous":null,"total":15,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"}],"external_urls":{"spotify":"https://open.spotify.com/album/2BJWf56WWnTfxfP4xCiTup"},"href":"https://api.spotify.com/v1/albums/2BJWf56WWnTfxfP4xCiTup","id":"2BJWf56WWnTfxfP4xCiTup","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fa1c51c5a375eca23372470d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fa1c51c5a375eca23372470d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fa1c51c5a375eca23372470d"}],"is_playable":true,"name":"Set You Free","release_date":"2026-07-28","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2BJWf56WWnTfxfP4xCiTup"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"}],"disc_number":1,"duration_ms":183297,"explicit":false,"external_ids":{"isrc":"GB2LD2610161"},"external_urls":{"spotify":"https://open.spotify.com/track/0ZtsqqqeOWnqpYIs5ncQSe"},"href":"https://api.spotify.com/v1/tracks/0ZtsqqqeOWnqpYIs5ncQSe","id":"0ZtsqqqeOWnqpYIs5ncQSe","is_local":false,"is_playable":true,"name":"Set You Free","track_number":1,"type":"track","uri":"spotify:track:0ZtsqqqeOWnqpYIs5ncQSe"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41ouHqoKXNijIMFsQTmFQV"},"href":"https://api.spotify.com/v1/artists/41ouHqoKXNijIMFsQTmFQV","id":"41ouHqoKXNijIMFsQTmFQV","name":"\u00c6ON:MODE","type":"artist","uri":"spotify:artist:41ouHqoKXNijIMFsQTmFQV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4yzrGOiPCcssfpKBT0bnHR"},"href":"https://api.spotify.com/v1/artists/4yzrGOiPCcssfpKBT0bnHR","id":"4yzrGOiPCcssfpKBT0bnHR","name":"Nu-La","type":"artist","uri":"spotify:artist:4yzrGOiPCcssfpKBT0bnHR"}],"external_urls":{"spotify":"https://open.spotify.com/album/2EuzUEdeJgOfGsyM89w8Gh"},"href":"https://api.spotify.com/v1/albums/2EuzUEdeJgOfGsyM89w8Gh","id":"2EuzUEdeJgOfGsyM89w8Gh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739818f72515c432f75f5b1995"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029818f72515c432f75f5b1995"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519818f72515c432f75f5b1995"}],"is_playable":true,"name":"Glow","release_date":"2026-04-02","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2EuzUEdeJgOfGsyM89w8Gh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41ouHqoKXNijIMFsQTmFQV"},"href":"https://api.spotify.com/v1/artists/41ouHqoKXNijIMFsQTmFQV","id":"41ouHqoKXNijIMFsQTmFQV","name":"\u00c6ON:MODE","type":"artist","uri":"spotify:artist:41ouHqoKXNijIMFsQTmFQV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4yzrGOiPCcssfpKBT0bnHR"},"href":"https://api.spotify.com/v1/artists/4yzrGOiPCcssfpKBT0bnHR","id":"4yzrGOiPCcssfpKBT0bnHR","name":"Nu-La","type":"artist","uri":"spotify:artist:4yzrGOiPCcssfpKBT0bnHR"}],"disc_number":1,"duration_ms":231724,"explicit":false,"external_ids":{"isrc":"GB2LD2610041"},"external_urls":{"spotify":"https://open.spotify.com/track/0vA8uwu9xTryDZOZnUr9w2"},"href":"https://api.spotify.com/v1/tracks/0vA8uwu9xTryDZOZnUr9w2","id":"0vA8uwu9xTryDZOZnUr9w2","is_local":false,"is_playable":true,"name":"Glow","track_number":1,"type":"track","uri":"spotify:track:0vA8uwu9xTryDZOZnUr9w2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4EzkuveR9pLvDVFNx6foYD"},"href":"https://api.spotify.com/v1/artists/4EzkuveR9pLvDVFNx6foYD","id":"4EzkuveR9pLvDVFNx6foYD","name":"James Bay","type":"artist","uri":"spotify:artist:4EzkuveR9pLvDVFNx6foYD"}],"external_urls":{"spotify":"https://open.spotify.com/album/3G2kixP0Pi8L0KgmSYohb2"},"href":"https://api.spotify.com/v1/albums/3G2kixP0Pi8L0KgmSYohb2","id":"3G2kixP0Pi8L0KgmSYohb2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27394fc1b024d726774f146ec5e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0294fc1b024d726774f146ec5e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485194fc1b024d726774f146ec5e"}],"is_playable":true,"name":"Chaos And The Calm","release_date":"2015-03-23","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:3G2kixP0Pi8L0KgmSYohb2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4EzkuveR9pLvDVFNx6foYD"},"href":"https://api.spotify.com/v1/artists/4EzkuveR9pLvDVFNx6foYD","id":"4EzkuveR9pLvDVFNx6foYD","name":"James Bay","type":"artist","uri":"spotify:artist:4EzkuveR9pLvDVFNx6foYD"}],"disc_number":1,"duration_ms":250346,"explicit":false,"external_ids":{"isrc":"USUM71305746"},"external_urls":{"spotify":"https://open.spotify.com/track/09BoTSQdcXgaN5AeozxArT"},"href":"https://api.spotify.com/v1/tracks/09BoTSQdcXgaN5AeozxArT","id":"09BoTSQdcXgaN5AeozxArT","is_local":false,"is_playable":true,"name":"Clocks Go Forward","track_number":14,"type":"track","uri":"spotify:track:09BoTSQdcXgaN5AeozxArT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0htlZDCG9I8LSENteF1TyQ"},"href":"https://api.spotify.com/v1/artists/0htlZDCG9I8LSENteF1TyQ","id":"0htlZDCG9I8LSENteF1TyQ","name":"Kofi Stone","type":"artist","uri":"spotify:artist:0htlZDCG9I8LSENteF1TyQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/0TpMAy5WPGObUkL5LPuuMc"},"href":"https://api.spotify.com/v1/albums/0TpMAy5WPGObUkL5LPuuMc","id":"0TpMAy5WPGObUkL5LPuuMc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273541c74a2790a31a33a85b682"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02541c74a2790a31a33a85b682"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851541c74a2790a31a33a85b682"}],"is_playable":true,"name":"Nobody Cares Till Everybody Does","release_date":"2019-12-06","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:0TpMAy5WPGObUkL5LPuuMc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0htlZDCG9I8LSENteF1TyQ"},"href":"https://api.spotify.com/v1/artists/0htlZDCG9I8LSENteF1TyQ","id":"0htlZDCG9I8LSENteF1TyQ","name":"Kofi Stone","type":"artist","uri":"spotify:artist:0htlZDCG9I8LSENteF1TyQ"}],"disc_number":1,"duration_ms":166700,"explicit":false,"external_ids":{"isrc":"GBKPL1977436"},"external_urls":{"spotify":"https://open.spotify.com/track/09xF6sy3PQ84INQOp7vZig"},"href":"https://api.spotify.com/v1/tracks/09xF6sy3PQ84INQOp7vZig","id":"09xF6sy3PQ84INQOp7vZig","is_local":false,"is_playable":true,"name":"Frozen Hearts","track_number":2,"type":"track","uri":"spotify:track:09xF6sy3PQ84INQOp7vZig"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6eUKZXaKkcviH0Ku9w2n3V"},"href":"https://api.spotify.com/v1/artists/6eUKZXaKkcviH0Ku9w2n3V","id":"6eUKZXaKkcviH0Ku9w2n3V","name":"Ed Sheeran","type":"artist","uri":"spotify:artist:6eUKZXaKkcviH0Ku9w2n3V"}],"external_urls":{"spotify":"https://open.spotify.com/album/6DpIyaMgt5p9HlGd1c0LDM"},"href":"https://api.spotify.com/v1/albums/6DpIyaMgt5p9HlGd1c0LDM","id":"6DpIyaMgt5p9HlGd1c0LDM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733c33fbe943babf9510e3715c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023c33fbe943babf9510e3715c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513c33fbe943babf9510e3715c"}],"is_playable":true,"name":"No.5 Collaborations Project","release_date":"2011-09-09","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:6DpIyaMgt5p9HlGd1c0LDM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6eUKZXaKkcviH0Ku9w2n3V"},"href":"https://api.spotify.com/v1/artists/6eUKZXaKkcviH0Ku9w2n3V","id":"6eUKZXaKkcviH0Ku9w2n3V","name":"Ed Sheeran","type":"artist","uri":"spotify:artist:6eUKZXaKkcviH0Ku9w2n3V"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ks3elJhSP20mD04lgiA68"},"href":"https://api.spotify.com/v1/artists/7Ks3elJhSP20mD04lgiA68","id":"7Ks3elJhSP20mD04lgiA68","name":"Devlin","type":"artist","uri":"spotify:artist:7Ks3elJhSP20mD04lgiA68"}],"disc_number":1,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"TCAAU1114520"},"external_urls":{"spotify":"https://open.spotify.com/track/1iyJwocwqUMwLgmu9O5Y13"},"href":"https://api.spotify.com/v1/tracks/1iyJwocwqUMwLgmu9O5Y13","id":"1iyJwocwqUMwLgmu9O5Y13","is_local":false,"is_playable":true,"name":"Lately (feat. Devlin)","track_number":1,"type":"track","uri":"spotify:track:1iyJwocwqUMwLgmu9O5Y13"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3QuQwLqdQBjhieJ1c6uLc8"},"href":"https://api.spotify.com/v1/artists/3QuQwLqdQBjhieJ1c6uLc8","id":"3QuQwLqdQBjhieJ1c6uLc8","name":"Benny G","type":"artist","uri":"spotify:artist:3QuQwLqdQBjhieJ1c6uLc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/5IKnij5cDGxlLgRhMc0jqE"},"href":"https://api.spotify.com/v1/albums/5IKnij5cDGxlLgRhMc0jqE","id":"5IKnij5cDGxlLgRhMc0jqE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c4a4874c7c9c44ca796c020b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c4a4874c7c9c44ca796c020b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c4a4874c7c9c44ca796c020b"}],"is_playable":true,"name":"I Got a Feeling (bennygsingz version)","release_date":"2025-09-26","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5IKnij5cDGxlLgRhMc0jqE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3QuQwLqdQBjhieJ1c6uLc8"},"href":"https://api.spotify.com/v1/artists/3QuQwLqdQBjhieJ1c6uLc8","id":"3QuQwLqdQBjhieJ1c6uLc8","name":"Benny G","type":"artist","uri":"spotify:artist:3QuQwLqdQBjhieJ1c6uLc8"}],"disc_number":1,"duration_ms":195022,"explicit":false,"external_ids":{"isrc":"QZZVQ2500276"},"external_urls":{"spotify":"https://open.spotify.com/track/2H66q7oukkdbFXTuOhuy0c"},"href":"https://api.spotify.com/v1/tracks/2H66q7oukkdbFXTuOhuy0c","id":"2H66q7oukkdbFXTuOhuy0c","is_local":false,"is_playable":true,"name":"I Got a Feeling - bennygsingz version","track_number":1,"type":"track","uri":"spotify:track:2H66q7oukkdbFXTuOhuy0c"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5DK8eK7fjvRsziXzyr3sFA"},"href":"https://api.spotify.com/v1/artists/5DK8eK7fjvRsziXzyr3sFA","id":"5DK8eK7fjvRsziXzyr3sFA","name":"Moon Taxi","type":"artist","uri":"spotify:artist:5DK8eK7fjvRsziXzyr3sFA"}],"external_urls":{"spotify":"https://open.spotify.com/album/0wSpiKFkyVyyyySsDtl36m"},"href":"https://api.spotify.com/v1/albums/0wSpiKFkyVyyyySsDtl36m","id":"0wSpiKFkyVyyyySsDtl36m","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735d939b9a70e4bc4807e5ff1f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025d939b9a70e4bc4807e5ff1f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515d939b9a70e4bc4807e5ff1f"}],"is_playable":true,"name":"Silver Dream","release_date":"2021-01-22","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:0wSpiKFkyVyyyySsDtl36m"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5DK8eK7fjvRsziXzyr3sFA"},"href":"https://api.spotify.com/v1/artists/5DK8eK7fjvRsziXzyr3sFA","id":"5DK8eK7fjvRsziXzyr3sFA","name":"Moon Taxi","type":"artist","uri":"spotify:artist:5DK8eK7fjvRsziXzyr3sFA"}],"disc_number":1,"duration_ms":186586,"explicit":false,"external_ids":{"isrc":"QMRSZ2000515"},"external_urls":{"spotify":"https://open.spotify.com/track/3cf1lZQP3vFZ0KRK0TRYtm"},"href":"https://api.spotify.com/v1/tracks/3cf1lZQP3vFZ0KRK0TRYtm","id":"3cf1lZQP3vFZ0KRK0TRYtm","is_local":false,"is_playable":true,"name":"Hometown Heroes","track_number":3,"type":"track","uri":"spotify:track:3cf1lZQP3vFZ0KRK0TRYtm"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fSaE6BXtQy0x7R7v9IOmZ"},"href":"https://api.spotify.com/v1/artists/2fSaE6BXtQy0x7R7v9IOmZ","id":"2fSaE6BXtQy0x7R7v9IOmZ","name":"Aesop Rock","type":"artist","uri":"spotify:artist:2fSaE6BXtQy0x7R7v9IOmZ"}],"external_urls":{"spotify":"https://open.spotify.com/album/63y5mkLctupacSr20e0O6j"},"href":"https://api.spotify.com/v1/albums/63y5mkLctupacSr20e0O6j","id":"63y5mkLctupacSr20e0O6j","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27341099595d5b6824762277406"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0241099595d5b6824762277406"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485141099595d5b6824762277406"}],"is_playable":true,"name":"Black Hole Superette","release_date":"2025-05-30","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:63y5mkLctupacSr20e0O6j"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fSaE6BXtQy0x7R7v9IOmZ"},"href":"https://api.spotify.com/v1/artists/2fSaE6BXtQy0x7R7v9IOmZ","id":"2fSaE6BXtQy0x7R7v9IOmZ","name":"Aesop Rock","type":"artist","uri":"spotify:artist:2fSaE6BXtQy0x7R7v9IOmZ"}],"disc_number":1,"duration_ms":212533,"explicit":true,"external_ids":{"isrc":"USBWK2400107"},"external_urls":{"spotify":"https://open.spotify.com/track/0rnhjjdY8szBKmi6HAVDvC"},"href":"https://api.spotify.com/v1/tracks/0rnhjjdY8szBKmi6HAVDvC","id":"0rnhjjdY8szBKmi6HAVDvC","is_local":false,"is_playable":true,"name":"Secret Knock","track_number":1,"type":"track","uri":"spotify:track:0rnhjjdY8szBKmi6HAVDvC"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ZUjdwG0NvY6MT7vvmluhV"},"href":"https://api.spotify.com/v1/artists/6ZUjdwG0NvY6MT7vvmluhV","id":"6ZUjdwG0NvY6MT7vvmluhV","name":"Young Rising Sons","type":"artist","uri":"spotify:artist:6ZUjdwG0NvY6MT7vvmluhV"}],"external_urls":{"spotify":"https://open.spotify.com/album/6ciJlSCd5DkKV8DJmty2Zl"},"href":"https://api.spotify.com/v1/albums/6ciJlSCd5DkKV8DJmty2Zl","id":"6ciJlSCd5DkKV8DJmty2Zl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273710417de6e36b934b1b83b7f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02710417de6e36b934b1b83b7f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851710417de6e36b934b1b83b7f"}],"is_playable":true,"name":"Carry On","release_date":"2017-02-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6ciJlSCd5DkKV8DJmty2Zl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ZUjdwG0NvY6MT7vvmluhV"},"href":"https://api.spotify.com/v1/artists/6ZUjdwG0NvY6MT7vvmluhV","id":"6ZUjdwG0NvY6MT7vvmluhV","name":"Young Rising Sons","type":"artist","uri":"spotify:artist:6ZUjdwG0NvY6MT7vvmluhV"}],"disc_number":1,"duration_ms":209585,"explicit":false,"external_ids":{"isrc":"USUM71615105"},"external_urls":{"spotify":"https://open.spotify.com/track/4dpD3TDufxz2rQ9JLkYPgV"},"href":"https://api.spotify.com/v1/tracks/4dpD3TDufxz2rQ9JLkYPgV","id":"4dpD3TDufxz2rQ9JLkYPgV","is_local":false,"is_playable":true,"name":"Carry On","track_number":1,"type":"track","uri":"spotify:track:4dpD3TDufxz2rQ9JLkYPgV"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5WC6EbIrTO76x30w5LtzS6"},"href":"https://api.spotify.com/v1/artists/5WC6EbIrTO76x30w5LtzS6","id":"5WC6EbIrTO76x30w5LtzS6","name":"Lily Meola","type":"artist","uri":"spotify:artist:5WC6EbIrTO76x30w5LtzS6"}],"external_urls":{"spotify":"https://open.spotify.com/album/5QQCXdKA7aXLrJSt3Zmu2j"},"href":"https://api.spotify.com/v1/albums/5QQCXdKA7aXLrJSt3Zmu2j","id":"5QQCXdKA7aXLrJSt3Zmu2j","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738cd8978fc6ada479b1c3030d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028cd8978fc6ada479b1c3030d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518cd8978fc6ada479b1c3030d"}],"is_playable":true,"name":"Sunshine","release_date":"2022-02-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5QQCXdKA7aXLrJSt3Zmu2j"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5WC6EbIrTO76x30w5LtzS6"},"href":"https://api.spotify.com/v1/artists/5WC6EbIrTO76x30w5LtzS6","id":"5WC6EbIrTO76x30w5LtzS6","name":"Lily Meola","type":"artist","uri":"spotify:artist:5WC6EbIrTO76x30w5LtzS6"}],"disc_number":1,"duration_ms":205449,"explicit":false,"external_ids":{"isrc":"US3DF2211219"},"external_urls":{"spotify":"https://open.spotify.com/track/4Yx4nkx3ymrAZZ3DSlhV8O"},"href":"https://api.spotify.com/v1/tracks/4Yx4nkx3ymrAZZ3DSlhV8O","id":"4Yx4nkx3ymrAZZ3DSlhV8O","is_local":false,"is_playable":true,"name":"Sunshine","track_number":1,"type":"track","uri":"spotify:track:4Yx4nkx3ymrAZZ3DSlhV8O"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Stay%20Close%20Delta%20Heavy&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Stay%20Close%20Delta%20Heavy&type=track","offset":0,"previous":null,"total":15,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"}],"external_urls":{"spotify":"https://open.spotify.com/album/2BJWf56WWnTfxfP4xCiTup"},"href":"https://api.spotify.com/v1/albums/2BJWf56WWnTfxfP4xCiTup","id":"2BJWf56WWnTfxfP4xCiTup","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fa1c51c5a375eca23372470d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fa1c51c5a375eca23372470d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fa1c51c5a375eca23372470d"}],"is_playable":true,"name":"Set You Free","release_date":"2026-07-28","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2BJWf56WWnTfxfP4xCiTup"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"}],"disc_number":1,"duration_ms":183297,"explicit":false,"external_ids":{"isrc":"GB2LD2610161"},"external_urls":{"spotify":"https://open.spotify.com/track/0ZtsqqqeOWnqpYIs5ncQSe"},"href":"https://api.spotify.com/v1/tracks/0ZtsqqqeOWnqpYIs5ncQSe","id":"0ZtsqqqeOWnqpYIs5ncQSe","is_local":false,"is_playable":true,"name":"Set You Free","track_number":1,"type":"track","uri":"spotify:track:0ZtsqqqeOWnqpYIs5ncQSe"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41ouHqoKXNijIMFsQTmFQV"},"href":"https://api.spotify.com/v1/artists/41ouHqoKXNijIMFsQTmFQV","id":"41ouHqoKXNijIMFsQTmFQV","name":"\u00c6ON:MODE","type":"artist","uri":"spotify:artist:41ouHqoKXNijIMFsQTmFQV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4yzrGOiPCcssfpKBT0bnHR"},"href":"https://api.spotify.com/v1/artists/4yzrGOiPCcssfpKBT0bnHR","id":"4yzrGOiPCcssfpKBT0bnHR","name":"Nu-La","type":"artist","uri":"spotify:artist:4yzrGOiPCcssfpKBT0bnHR"}],"external_urls":{"spotify":"https://open.spotify.com/album/2EuzUEdeJgOfGsyM89w8Gh"},"href":"https://api.spotify.com/v1/albums/2EuzUEdeJgOfGsyM89w8Gh","id":"2EuzUEdeJgOfGsyM89w8Gh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739818f72515c432f75f5b1995"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029818f72515c432f75f5b1995"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519818f72515c432f75f5b1995"}],"is_playable":true,"name":"Glow","release_date":"2026-04-02","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2EuzUEdeJgOfGsyM89w8Gh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41ouHqoKXNijIMFsQTmFQV"},"href":"https://api.spotify.com/v1/artists/41ouHqoKXNijIMFsQTmFQV","id":"41ouHqoKXNijIMFsQTmFQV","name":"\u00c6ON:MODE","type":"artist","uri":"spotify:artist:41ouHqoKXNijIMFsQTmFQV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4yzrGOiPCcssfpKBT0bnHR"},"href":"https://api.spotify.com/v1/artists/4yzrGOiPCcssfpKBT0bnHR","id":"4yzrGOiPCcssfpKBT0bnHR","name":"Nu-La","type":"artist","uri":"spotify:artist:4yzrGOiPCcssfpKBT0bnHR"}],"disc_number":1,"duration_ms":231724,"explicit":false,"external_ids":{"isrc":"GB2LD2610041"},"external_urls":{"spotify":"https://open.spotify.com/track/0vA8uwu9xTryDZOZnUr9w2"},"href":"https://api.spotify.com/v1/tracks/0vA8uwu9xTryDZOZnUr9w2","id":"0vA8uwu9xTryDZOZnUr9w2","is_local":false,"is_playable":true,"name":"Glow","track_number":1,"type":"track","uri":"spotify:track:0vA8uwu9xTryDZOZnUr9w2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4EzkuveR9pLvDVFNx6foYD"},"href":"https://api.spotify.com/v1/artists/4EzkuveR9pLvDVFNx6foYD","id":"4EzkuveR9pLvDVFNx6foYD","name":"James Bay","type":"artist","uri":"spotify:artist:4EzkuveR9pLvDVFNx6foYD"}],"external_urls":{"spotify":"https://open.spotify.com/album/3G2kixP0Pi8L0KgmSYohb2"},"href":"https://api.spotify.com/v1/albums/3G2kixP0Pi8L0KgmSYohb2","id":"3G2kixP0Pi8L0KgmSYohb2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27394fc1b024d726774f146ec5e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0294fc1b024d726774f146ec5e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485194fc1b024d726774f146ec5e"}],"is_playable":true,"name":"Chaos And The Calm","release_date":"2015-03-23","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:3G2kixP0Pi8L0KgmSYohb2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4EzkuveR9pLvDVFNx6foYD"},"href":"https://api.spotify.com/v1/artists/4EzkuveR9pLvDVFNx6foYD","id":"4EzkuveR9pLvDVFNx6foYD","name":"James Bay","type":"artist","uri":"spotify:artist:4EzkuveR9pLvDVFNx6foYD"}],"disc_number":1,"duration_ms":250346,"explicit":false,"external_ids":{"isrc":"USUM71305746"},"external_urls":{"spotify":"https://open.spotify.com/track/09BoTSQdcXgaN5AeozxArT"},"href":"https://api.spotify.com/v1/tracks/09BoTSQdcXgaN5AeozxArT","id":"09BoTSQdcXgaN5AeozxArT","is_local":false,"is_playable":true,"name":"Clocks Go Forward","track_number":14,"type":"track","uri":"spotify:track:09BoTSQdcXgaN5AeozxArT"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0htlZDCG9I8LSENteF1TyQ"},"href":"https://api.spotify.com/v1/artists/0htlZDCG9I8LSENteF1TyQ","id":"0htlZDCG9I8LSENteF1TyQ","name":"Kofi Stone","type":"artist","uri":"spotify:artist:0htlZDCG9I8LSENteF1TyQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/0TpMAy5WPGObUkL5LPuuMc"},"href":"https://api.spotify.com/v1/albums/0TpMAy5WPGObUkL5LPuuMc","id":"0TpMAy5WPGObUkL5LPuuMc","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273541c74a2790a31a33a85b682"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02541c74a2790a31a33a85b682"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851541c74a2790a31a33a85b682"}],"is_playable":true,"name":"Nobody Cares Till Everybody Does","release_date":"2019-12-06","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:0TpMAy5WPGObUkL5LPuuMc"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0htlZDCG9I8LSENteF1TyQ"},"href":"https://api.spotify.com/v1/artists/0htlZDCG9I8LSENteF1TyQ","id":"0htlZDCG9I8LSENteF1TyQ","name":"Kofi Stone","type":"artist","uri":"spotify:artist:0htlZDCG9I8LSENteF1TyQ"}],"disc_number":1,"duration_ms":166700,"explicit":false,"external_ids":{"isrc":"GBKPL1977436"},"external_urls":{"spotify":"https://open.spotify.com/track/09xF6sy3PQ84INQOp7vZig"},"href":"https://api.spotify.com/v1/tracks/09xF6sy3PQ84INQOp7vZig","id":"09xF6sy3PQ84INQOp7vZig","is_local":false,"is_playable":true,"name":"Frozen Hearts","track_number":2,"type":"track","uri":"spotify:track:09xF6sy3PQ84INQOp7vZig"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6eUKZXaKkcviH0Ku9w2n3V"},"href":"https://api.spotify.com/v1/artists/6eUKZXaKkcviH0Ku9w2n3V","id":"6eUKZXaKkcviH0Ku9w2n3V","name":"Ed Sheeran","type":"artist","uri":"spotify:artist:6eUKZXaKkcviH0Ku9w2n3V"}],"external_urls":{"spotify":"https://open.spotify.com/album/6DpIyaMgt5p9HlGd1c0LDM"},"href":"https://api.spotify.com/v1/albums/6DpIyaMgt5p9HlGd1c0LDM","id":"6DpIyaMgt5p9HlGd1c0LDM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733c33fbe943babf9510e3715c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023c33fbe943babf9510e3715c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513c33fbe943babf9510e3715c"}],"is_playable":true,"name":"No.5 Collaborations Project","release_date":"2011-09-09","release_date_precision":"day","total_tracks":8,"type":"album","uri":"spotify:album:6DpIyaMgt5p9HlGd1c0LDM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6eUKZXaKkcviH0Ku9w2n3V"},"href":"https://api.spotify.com/v1/artists/6eUKZXaKkcviH0Ku9w2n3V","id":"6eUKZXaKkcviH0Ku9w2n3V","name":"Ed Sheeran","type":"artist","uri":"spotify:artist:6eUKZXaKkcviH0Ku9w2n3V"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7Ks3elJhSP20mD04lgiA68"},"href":"https://api.spotify.com/v1/artists/7Ks3elJhSP20mD04lgiA68","id":"7Ks3elJhSP20mD04lgiA68","name":"Devlin","type":"artist","uri":"spotify:artist:7Ks3elJhSP20mD04lgiA68"}],"disc_number":1,"duration_ms":271333,"explicit":false,"external_ids":{"isrc":"TCAAU1114520"},"external_urls":{"spotify":"https://open.spotify.com/track/1iyJwocwqUMwLgmu9O5Y13"},"href":"https://api.spotify.com/v1/tracks/1iyJwocwqUMwLgmu9O5Y13","id":"1iyJwocwqUMwLgmu9O5Y13","is_local":false,"is_playable":true,"name":"Lately (feat. Devlin)","track_number":1,"type":"track","uri":"spotify:track:1iyJwocwqUMwLgmu9O5Y13"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3QuQwLqdQBjhieJ1c6uLc8"},"href":"https://api.spotify.com/v1/artists/3QuQwLqdQBjhieJ1c6uLc8","id":"3QuQwLqdQBjhieJ1c6uLc8","name":"Benny G","type":"artist","uri":"spotify:artist:3QuQwLqdQBjhieJ1c6uLc8"}],"external_urls":{"spotify":"https://open.spotify.com/album/5IKnij5cDGxlLgRhMc0jqE"},"href":"https://api.spotify.com/v1/albums/5IKnij5cDGxlLgRhMc0jqE","id":"5IKnij5cDGxlLgRhMc0jqE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c4a4874c7c9c44ca796c020b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c4a4874c7c9c44ca796c020b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c4a4874c7c9c44ca796c020b"}],"is_playable":true,"name":"I Got a Feeling (bennygsingz version)","release_date":"2025-09-26","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5IKnij5cDGxlLgRhMc0jqE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3QuQwLqdQBjhieJ1c6uLc8"},"href":"https://api.spotify.com/v1/artists/3QuQwLqdQBjhieJ1c6uLc8","id":"3QuQwLqdQBjhieJ1c6uLc8","name":"Benny G","type":"artist","uri":"spotify:artist:3QuQwLqdQBjhieJ1c6uLc8"}],"disc_number":1,"duration_ms":195022,"explicit":false,"external_ids":{"isrc":"QZZVQ2500276"},"external_urls":{"spotify":"https://open.spotify.com/track/2H66q7oukkdbFXTuOhuy0c"},"href":"https://api.spotify.com/v1/tracks/2H66q7oukkdbFXTuOhuy0c","id":"2H66q7oukkdbFXTuOhuy0c","is_local":false,"is_playable":true,"name":"I Got a Feeling - bennygsingz version","track_number":1,"type":"track","uri":"spotify:track:2H66q7oukkdbFXTuOhuy0c"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5DK8eK7fjvRsziXzyr3sFA"},"href":"https://api.spotify.com/v1/artists/5DK8eK7fjvRsziXzyr3sFA","id":"5DK8eK7fjvRsziXzyr3sFA","name":"Moon Taxi","type":"artist","uri":"spotify:artist:5DK8eK7fjvRsziXzyr3sFA"}],"external_urls":{"spotify":"https://open.spotify.com/album/0wSpiKFkyVyyyySsDtl36m"},"href":"https://api.spotify.com/v1/albums/0wSpiKFkyVyyyySsDtl36m","id":"0wSpiKFkyVyyyySsDtl36m","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735d939b9a70e4bc4807e5ff1f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025d939b9a70e4bc4807e5ff1f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515d939b9a70e4bc4807e5ff1f"}],"is_playable":true,"name":"Silver Dream","release_date":"2021-01-22","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:0wSpiKFkyVyyyySsDtl36m"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5DK8eK7fjvRsziXzyr3sFA"},"href":"https://api.spotify.com/v1/artists/5DK8eK7fjvRsziXzyr3sFA","id":"5DK8eK7fjvRsziXzyr3sFA","name":"Moon Taxi","type":"artist","uri":"spotify:artist:5DK8eK7fjvRsziXzyr3sFA"}],"disc_number":1,"duration_ms":186586,"explicit":false,"external_ids":{"isrc":"QMRSZ2000515"},"external_urls":{"spotify":"https://open.spotify.com/track/3cf1lZQP3vFZ0KRK0TRYtm"},"href":"https://api.spotify.com/v1/tracks/3cf1lZQP3vFZ0KRK0TRYtm","id":"3cf1lZQP3vFZ0KRK0TRYtm","is_local":false,"is_playable":true,"name":"Hometown Heroes","track_number":3,"type":"track","uri":"spotify:track:3cf1lZQP3vFZ0KRK0TRYtm"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fSaE6BXtQy0x7R7v9IOmZ"},"href":"https://api.spotify.com/v1/artists/2fSaE6BXtQy0x7R7v9IOmZ","id":"2fSaE6BXtQy0x7R7v9IOmZ","name":"Aesop Rock","type":"artist","uri":"spotify:artist:2fSaE6BXtQy0x7R7v9IOmZ"}],"external_urls":{"spotify":"https://open.spotify.com/album/63y5mkLctupacSr20e0O6j"},"href":"https://api.spotify.com/v1/albums/63y5mkLctupacSr20e0O6j","id":"63y5mkLctupacSr20e0O6j","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27341099595d5b6824762277406"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0241099595d5b6824762277406"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485141099595d5b6824762277406"}],"is_playable":true,"name":"Black Hole Superette","release_date":"2025-05-30","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:63y5mkLctupacSr20e0O6j"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2fSaE6BXtQy0x7R7v9IOmZ"},"href":"https://api.spotify.com/v1/artists/2fSaE6BXtQy0x7R7v9IOmZ","id":"2fSaE6BXtQy0x7R7v9IOmZ","name":"Aesop Rock","type":"artist","uri":"spotify:artist:2fSaE6BXtQy0x7R7v9IOmZ"}],"disc_number":1,"duration_ms":212533,"explicit":true,"external_ids":{"isrc":"USBWK2400107"},"external_urls":{"spotify":"https://open.spotify.com/track/0rnhjjdY8szBKmi6HAVDvC"},"href":"https://api.spotify.com/v1/tracks/0rnhjjdY8szBKmi6HAVDvC","id":"0rnhjjdY8szBKmi6HAVDvC","is_local":false,"is_playable":true,"name":"Secret Knock","track_number":1,"type":"track","uri":"spotify:track:0rnhjjdY8szBKmi6HAVDvC"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ZUjdwG0NvY6MT7vvmluhV"},"href":"https://api.spotify.com/v1/artists/6ZUjdwG0NvY6MT7vvmluhV","id":"6ZUjdwG0NvY6MT7vvmluhV","name":"Young Rising Sons","type":"artist","uri":"spotify:artist:6ZUjdwG0NvY6MT7vvmluhV"}],"external_urls":{"spotify":"https://open.spotify.com/album/6ciJlSCd5DkKV8DJmty2Zl"},"href":"https://api.spotify.com/v1/albums/6ciJlSCd5DkKV8DJmty2Zl","id":"6ciJlSCd5DkKV8DJmty2Zl","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273710417de6e36b934b1b83b7f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02710417de6e36b934b1b83b7f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851710417de6e36b934b1b83b7f"}],"is_playable":true,"name":"Carry On","release_date":"2017-02-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6ciJlSCd5DkKV8DJmty2Zl"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6ZUjdwG0NvY6MT7vvmluhV"},"href":"https://api.spotify.com/v1/artists/6ZUjdwG0NvY6MT7vvmluhV","id":"6ZUjdwG0NvY6MT7vvmluhV","name":"Young Rising Sons","type":"artist","uri":"spotify:artist:6ZUjdwG0NvY6MT7vvmluhV"}],"disc_number":1,"duration_ms":209585,"explicit":false,"external_ids":{"isrc":"USUM71615105"},"external_urls":{"spotify":"https://open.spotify.com/track/4dpD3TDufxz2rQ9JLkYPgV"},"href":"https://api.spotify.com/v1/tracks/4dpD3TDufxz2rQ9JLkYPgV","id":"4dpD3TDufxz2rQ9JLkYPgV","is_local":false,"is_playable":true,"name":"Carry On","track_number":1,"type":"track","uri":"spotify:track:4dpD3TDufxz2rQ9JLkYPgV"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5WC6EbIrTO76x30w5LtzS6"},"href":"https://api.spotify.com/v1/artists/5WC6EbIrTO76x30w5LtzS6","id":"5WC6EbIrTO76x30w5LtzS6","name":"Lily Meola","type":"artist","uri":"spotify:artist:5WC6EbIrTO76x30w5LtzS6"}],"external_urls":{"spotify":"https://open.spotify.com/album/5QQCXdKA7aXLrJSt3Zmu2j"},"href":"https://api.spotify.com/v1/albums/5QQCXdKA7aXLrJSt3Zmu2j","id":"5QQCXdKA7aXLrJSt3Zmu2j","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738cd8978fc6ada479b1c3030d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028cd8978fc6ada479b1c3030d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518cd8978fc6ada479b1c3030d"}],"is_playable":true,"name":"Sunshine","release_date":"2022-02-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5QQCXdKA7aXLrJSt3Zmu2j"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5WC6EbIrTO76x30w5LtzS6"},"href":"https://api.spotify.com/v1/artists/5WC6EbIrTO76x30w5LtzS6","id":"5WC6EbIrTO76x30w5LtzS6","name":"Lily Meola","type":"artist","uri":"spotify:artist:5WC6EbIrTO76x30w5LtzS6"}],"disc_number":1,"duration_ms":205449,"explicit":false,"external_ids":{"isrc":"US3DF2211219"},"external_urls":{"spotify":"https://open.spotify.com/track/4Yx4nkx3ymrAZZ3DSlhV8O"},"href":"https://api.spotify.com/v1/tracks/4Yx4nkx3ymrAZZ3DSlhV8O","id":"4Yx4nkx3ymrAZZ3DSlhV8O","is_local":false,"is_playable":true,"name":"Sunshine","track_number":1,"type":"track","uri":"spotify:track:4Yx4nkx3ymrAZZ3DSlhV8O"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Stay+Close+Delta+Heavy&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Bad%20Company%22%20artist%3A%22Bad%20Company%20UK%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":3,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4k1ELeJKT1ISyDv8JivPpB"},"href":"https://api.spotify.com/v1/artists/4k1ELeJKT1ISyDv8JivPpB","id":"4k1ELeJKT1ISyDv8JivPpB","name":"The Prodigy","type":"artist","uri":"spotify:artist:4k1ELeJKT1ISyDv8JivPpB"}],"external_urls":{"spotify":"https://open.spotify.com/album/1z4n8pE2pFbf9fYvpqrLEV"},"href":"https://api.spotify.com/v1/albums/1z4n8pE2pFbf9fYvpqrLEV","id":"1z4n8pE2pFbf9fYvpqrLEV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737492dd94c571f3e63768f47b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027492dd94c571f3e63768f47b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517492dd94c571f3e63768f47b"}],"is_playable":true,"name":"The Day Is My Enemy (Bad Company UK Remix)","release_date":"2016-10-01","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1z4n8pE2pFbf9fYvpqrLEV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4k1ELeJKT1ISyDv8JivPpB"},"href":"https://api.spotify.com/v1/artists/4k1ELeJKT1ISyDv8JivPpB","id":"4k1ELeJKT1ISyDv8JivPpB","name":"The Prodigy","type":"artist","uri":"spotify:artist:4k1ELeJKT1ISyDv8JivPpB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"disc_number":1,"duration_ms":242758,"explicit":false,"external_ids":{"isrc":"GBCEJ1600279"},"external_urls":{"spotify":"https://open.spotify.com/track/4NHx4cOfce2T2eMU6j1KIQ"},"href":"https://api.spotify.com/v1/tracks/4NHx4cOfce2T2eMU6j1KIQ","id":"4NHx4cOfce2T2eMU6j1KIQ","is_local":false,"is_playable":true,"name":"The Day Is My Enemy - Bad Company UK Remix","track_number":1,"type":"track","uri":"spotify:track:4NHx4cOfce2T2eMU6j1KIQ"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4S2udpRV9DTZ2PimP7VzL0"},"href":"https://api.spotify.com/v1/artists/4S2udpRV9DTZ2PimP7VzL0","id":"4S2udpRV9DTZ2PimP7VzL0","name":"Moving Fusion","type":"artist","uri":"spotify:artist:4S2udpRV9DTZ2PimP7VzL0"}],"external_urls":{"spotify":"https://open.spotify.com/album/7HMIVWdjylm0PuT8vDl8eJ"},"href":"https://api.spotify.com/v1/albums/7HMIVWdjylm0PuT8vDl8eJ","id":"7HMIVWdjylm0PuT8vDl8eJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dd791f5b935a4ab0aed0b439"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dd791f5b935a4ab0aed0b439"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dd791f5b935a4ab0aed0b439"}],"is_playable":true,"name":"Atlantis (Bad Company UK Remix) / Survival","release_date":"2001","release_date_precision":"year","total_tracks":2,"type":"album","uri":"spotify:album:7HMIVWdjylm0PuT8vDl8eJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4S2udpRV9DTZ2PimP7VzL0"},"href":"https://api.spotify.com/v1/artists/4S2udpRV9DTZ2PimP7VzL0","id":"4S2udpRV9DTZ2PimP7VzL0","name":"Moving Fusion","type":"artist","uri":"spotify:artist:4S2udpRV9DTZ2PimP7VzL0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"disc_number":1,"duration_ms":383448,"explicit":false,"external_ids":{"isrc":"GBBZH0103301"},"external_urls":{"spotify":"https://open.spotify.com/track/38VmARkijeRMtUcdrehdyb"},"href":"https://api.spotify.com/v1/tracks/38VmARkijeRMtUcdrehdyb","id":"38VmARkijeRMtUcdrehdyb","is_local":false,"is_playable":true,"name":"Atlantis - Bad Company UK Remix","track_number":1,"type":"track","uri":"spotify:track:38VmARkijeRMtUcdrehdyb"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6dA177iQC3d7jbCGFlCkcF"},"href":"https://api.spotify.com/v1/albums/6dA177iQC3d7jbCGFlCkcF","id":"6dA177iQC3d7jbCGFlCkcF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2733a72c0cd15fcb2f87c7b243b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e023a72c0cd15fcb2f87c7b243b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048513a72c0cd15fcb2f87c7b243b"}],"is_playable":true,"name":"Andy C Presents Ram Raiders: The Mix","release_date":"2001-07-09","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:6dA177iQC3d7jbCGFlCkcF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4S2udpRV9DTZ2PimP7VzL0"},"href":"https://api.spotify.com/v1/artists/4S2udpRV9DTZ2PimP7VzL0","id":"4S2udpRV9DTZ2PimP7VzL0","name":"Moving Fusion","type":"artist","uri":"spotify:artist:4S2udpRV9DTZ2PimP7VzL0"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"disc_number":1,"duration_ms":186840,"explicit":false,"external_ids":{"isrc":"GBBZH0190420"},"external_urls":{"spotify":"https://open.spotify.com/track/6zrcHI2nqAgFkQYPRdjVYQ"},"href":"https://api.spotify.com/v1/tracks/6zrcHI2nqAgFkQYPRdjVYQ","id":"6zrcHI2nqAgFkQYPRdjVYQ","is_local":false,"is_playable":true,"name":"Atlantis - Bad Company UK Remix - Mixed","track_number":20,"type":"track","uri":"spotify:track:6zrcHI2nqAgFkQYPRdjVYQ"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJhZCUyMENvbXBhbnklMjIlMjBhcnRpc3QlM0ElMjJCYWQlMjBDb21wYW55JTIwVUslMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjMsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80azFFTGVKS1QxSVN5RHY4Sml2UHBCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRrMUVMZUpLVDFJU3lEdjhKaXZQcEIiLCJpZCI6IjRrMUVMZUpLVDFJU3lEdjhKaXZQcEIiLCJuYW1lIjoiVGhlIFByb2RpZ3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGsxRUxlSktUMUlTeUR2OEppdlBwQiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzF6NG44cEUycEZiZjlmWXZwcXJMRVYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xejRuOHBFMnBGYmY5Zll2cHFyTEVWIiwiaWQiOiIxejRuOHBFMnBGYmY5Zll2cHFyTEVWIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLg==", + "c2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzQ5MmRkOTRjNTcxZjNlNjM3NjhmNDdiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjc0OTJkZDk0YzU3MWYzZTYzNzY4ZjQ3YiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzQ5MmRkOTRjNTcxZjNlNjM3NjhmNDdiIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBEYXkgSXMgTXkgRW5lbXkgKEJhZCBDb21wYW55IFVLIFJlbWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMTYtMTAtMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjF6NG44cEUycEZiZjlmWXZwcXJMRVYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80azFFTGVKS1QxSVN5RHY4Sml2UHBCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRrMUVMZUpLVDFJU3lEdjhKaXZQcEIiLCJpZCI6IjRrMUVMZUpLVDFJU3lEdjhKaXZQcEIiLCJuYW1lIjoiVGhlIFByb2RpZ3kiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NGsxRUxlSktUMUlTeUR2OEppdlBwQiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80QUFmNkJJMUlKeHZrcXY5OG1ESGluIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRBQWY2QkkxSUp4dmtxdjk4bURIaW4iLCJpZCI6IjRBQWY2QkkxSUp4dmtxdjk4bURIaW4iLCJuYW1lIjoiQmFkIENvbXBhbnkgVUsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEFBZjZCSTFJSnh2a3F2OThtREhpbiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNDI3NTgsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkNFSjE2MDAyNzkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzROSHg0Y09mY2UyVDJlTVU2ajFLSVEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80Tkh4NGNPZmNlMlQyZU1VNmoxS0lRIiwiaWQiOiI0Tkh4NGNPZmNlMlQyZU1VNmoxS0lRIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBEYXkgSXMgTXkgRW5lbXkgLSBCYWQgQ29tcGFueSBVSyBSZW1peCIsInRyYQ==", + "Y2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjROSHg0Y09mY2UyVDJlTVU2ajFLSVEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRTMnVkcFJWOURUWjJQaW1QN1Z6TDAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFMydWRwUlY5RFRaMlBpbVA3VnpMMCIsImlkIjoiNFMydWRwUlY5RFRaMlBpbVA3VnpMMCIsIm5hbWUiOiJNb3ZpbmcgRnVzaW9uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRTMnVkcFJWOURUWjJQaW1QN1Z6TDAifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83SE1JVldkanlsbTBQdVQ4dkRsOGVKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0hNSVZXZGp5bG0wUHVUOHZEbDhlSiIsImlkIjoiN0hNSVZXZGp5bG0wUHVUOHZEbDhlSiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNkZDc5MWY1YjkzNWE0YWIwYWVkMGI0MzkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZGQ3OTFmNWI5MzVhNGFiMGFlZDBiNDM5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFkZDc5MWY1YjkzNWE0YWIwYWVkMGI0MzkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQXRsYW50aXMgKEJhZCBDb21wYW55IFVLIFJlbWl4KSAvIFN1cnZpdmFsIiwicmVsZWFzZV9kYXRlIjoiMjAwMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdITUlWV2RqeWxtMFB1VDh2RGw4ZUoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80UzJ1ZHBSVjlEVFoyUGltUDdWekwwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRTMnVkcFJWOURUWjJQaW1QN1Z6TDAiLCJpZCI6IjRTMnVkcFJWOURUWjJQaW1QN1Z6TDAiLCJuYW1lIjoiTW92aW5nIEZ1c2lvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0UzJ1ZHBSVjlEVFoyUGltUDdWekwwIn0seyJleHRlcm5hbF91cmxzIjp7Ig==", + "c3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEFBZjZCSTFJSnh2a3F2OThtREhpbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80QUFmNkJJMUlKeHZrcXY5OG1ESGluIiwiaWQiOiI0QUFmNkJJMUlKeHZrcXY5OG1ESGluIiwibmFtZSI6IkJhZCBDb21wYW55IFVLIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRBQWY2QkkxSUp4dmtxdjk4bURIaW4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzgzNDQ4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JCWkgwMTAzMzAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zOFZtQVJraWplUk10VWNkcmVoZHliIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzhWbUFSa2lqZVJNdFVjZHJlaGR5YiIsImlkIjoiMzhWbUFSa2lqZVJNdFVjZHJlaGR5YiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBdGxhbnRpcyAtIEJhZCBDb21wYW55IFVLIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjM4Vm1BUmtpamVSTXRVY2RyZWhkeWIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNmRBMTc3aVFDM2Q3amJDR0ZsQ2tjRiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZkQTE3N2lRQzNkN2piQ0dGbENrY0YiLCJpZCI6IjZkQTE3N2lRQzNkN2piQ0dGbENrY0YiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczM2E3MmMwY2QxNWZjYjJmODdjN2IyNDNiIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjNhNzJjMGNkMTVmY2IyZg==", + "ODdjN2IyNDNiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzYTcyYzBjZDE1ZmNiMmY4N2M3YjI0M2IifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQW5keSBDIFByZXNlbnRzIFJhbSBSYWlkZXJzOiBUaGUgTWl4IiwicmVsZWFzZV9kYXRlIjoiMjAwMS0wNy0wOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZkQTE3N2lRQzNkN2piQ0dGbENrY0YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80UzJ1ZHBSVjlEVFoyUGltUDdWekwwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRTMnVkcFJWOURUWjJQaW1QN1Z6TDAiLCJpZCI6IjRTMnVkcFJWOURUWjJQaW1QN1Z6TDAiLCJuYW1lIjoiTW92aW5nIEZ1c2lvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0UzJ1ZHBSVjlEVFoyUGltUDdWekwwIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRBQWY2QkkxSUp4dmtxdjk4bURIaW4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsImlkIjoiNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsIm5hbWUiOiJCYWQgQ29tcGFueSBVSyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0QUFmNkJJMUlKeHZrcXY5OG1ESGluIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE4Njg0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQlpIMDE5MDQyMCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNnpyY0hJMm5xQWdGa1FZUFJkalZZUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZ6cmNISTJucUFnRmtRWVBSZGpWWVEiLCJpZCI6IjZ6cmNISTJucUFnRmtRWVBSZGpWWVEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQXRsYW50aXMgLSBCYWQgQ29tcGFueSBVSyBSZW1peCAtIE1peGVkIiwidHJhY2tfbnVtYmVyIjoyMCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2enJjSEkybnFBZ0ZrUVlQUmRqVllRIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Bad+Company%22+artist%3A%22Bad+Company+UK%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRpbWV3YXJwJTIyJTIwYXJ0aXN0JTNBJTIyQmFkJTIwQ29tcGFueSUyMFVLJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlRpbWV3YXJwJTIyJTIwYXJ0aXN0JTNBJTIyQmFkJTIwQ29tcGFueSUyMFVLJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Timewarp%22+artist%3A%22Bad+Company+UK%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1DYXNjYWRlJTIwQ2FtbyUyMCUyNiUyMEtyb29rZWQmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1DYXNjYWRlJTIwQ2FtbyUyMCUyNiUyMEtyb29rZWQmdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Cascade+Camo+%26+Krooked&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Vodka%20%26%20Coke%20Delta%20Heavy&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Vodka%20%26%20Coke%20Delta%20Heavy&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41ouHqoKXNijIMFsQTmFQV"},"href":"https://api.spotify.com/v1/artists/41ouHqoKXNijIMFsQTmFQV","id":"41ouHqoKXNijIMFsQTmFQV","name":"\u00c6ON:MODE","type":"artist","uri":"spotify:artist:41ouHqoKXNijIMFsQTmFQV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4yzrGOiPCcssfpKBT0bnHR"},"href":"https://api.spotify.com/v1/artists/4yzrGOiPCcssfpKBT0bnHR","id":"4yzrGOiPCcssfpKBT0bnHR","name":"Nu-La","type":"artist","uri":"spotify:artist:4yzrGOiPCcssfpKBT0bnHR"}],"external_urls":{"spotify":"https://open.spotify.com/album/2EuzUEdeJgOfGsyM89w8Gh"},"href":"https://api.spotify.com/v1/albums/2EuzUEdeJgOfGsyM89w8Gh","id":"2EuzUEdeJgOfGsyM89w8Gh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739818f72515c432f75f5b1995"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029818f72515c432f75f5b1995"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519818f72515c432f75f5b1995"}],"is_playable":true,"name":"Glow","release_date":"2026-04-02","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2EuzUEdeJgOfGsyM89w8Gh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41ouHqoKXNijIMFsQTmFQV"},"href":"https://api.spotify.com/v1/artists/41ouHqoKXNijIMFsQTmFQV","id":"41ouHqoKXNijIMFsQTmFQV","name":"\u00c6ON:MODE","type":"artist","uri":"spotify:artist:41ouHqoKXNijIMFsQTmFQV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4yzrGOiPCcssfpKBT0bnHR"},"href":"https://api.spotify.com/v1/artists/4yzrGOiPCcssfpKBT0bnHR","id":"4yzrGOiPCcssfpKBT0bnHR","name":"Nu-La","type":"artist","uri":"spotify:artist:4yzrGOiPCcssfpKBT0bnHR"}],"disc_number":1,"duration_ms":231724,"explicit":false,"external_ids":{"isrc":"GB2LD2610041"},"external_urls":{"spotify":"https://open.spotify.com/track/0vA8uwu9xTryDZOZnUr9w2"},"href":"https://api.spotify.com/v1/tracks/0vA8uwu9xTryDZOZnUr9w2","id":"0vA8uwu9xTryDZOZnUr9w2","is_local":false,"is_playable":true,"name":"Glow","track_number":1,"type":"track","uri":"spotify:track:0vA8uwu9xTryDZOZnUr9w2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"}],"external_urls":{"spotify":"https://open.spotify.com/album/3sysiYphqNRQw7VKLCg1yE"},"href":"https://api.spotify.com/v1/albums/3sysiYphqNRQw7VKLCg1yE","id":"3sysiYphqNRQw7VKLCg1yE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d7b2aa3834b82b1cbe899a48"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d7b2aa3834b82b1cbe899a48"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d7b2aa3834b82b1cbe899a48"}],"is_playable":true,"name":"Love?","release_date":"2011-04-29","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:3sysiYphqNRQw7VKLCg1yE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/3C0nOe05EIt1390bVABLyN"},"href":"https://api.spotify.com/v1/tracks/3C0nOe05EIt1390bVABLyN","id":"3C0nOe05EIt1390bVABLyN","is_local":false,"is_playable":true,"name":"On The Floor","track_number":1,"type":"track","uri":"spotify:track:3C0nOe05EIt1390bVABLyN"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"external_urls":{"spotify":"https://open.spotify.com/album/543NK5YT3RjGmP7nFzWJPm"},"href":"https://api.spotify.com/v1/albums/543NK5YT3RjGmP7nFzWJPm","id":"543NK5YT3RjGmP7nFzWJPm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735c7fdd07d99c156401073aaa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025c7fdd07d99c156401073aaa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515c7fdd07d99c156401073aaa"}],"is_playable":true,"name":"On The Floor","release_date":"2011-02-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:543NK5YT3RjGmP7nFzWJPm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":230906,"explicit":false,"external_ids":{"isrc":"USUM71100721"},"external_urls":{"spotify":"https://open.spotify.com/track/0Oe49j06Bjrxs8PltuVeaW"},"href":"https://api.spotify.com/v1/tracks/0Oe49j06Bjrxs8PltuVeaW","id":"0Oe49j06Bjrxs8PltuVeaW","is_local":false,"is_playable":true,"name":"On The Floor - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:0Oe49j06Bjrxs8PltuVeaW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5QmLvPJ5Wj0nUUP3yHSoyM"},"href":"https://api.spotify.com/v1/albums/5QmLvPJ5Wj0nUUP3yHSoyM","id":"5QmLvPJ5Wj0nUUP3yHSoyM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a150a790f1ed224de90cb009"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a150a790f1ed224de90cb009"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a150a790f1ed224de90cb009"}],"is_playable":true,"name":"Female Pop Hits","release_date":"2020-03-13","release_date_precision":"day","total_tracks":31,"type":"album","uri":"spotify:album:5QmLvPJ5Wj0nUUP3yHSoyM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/66cdXfnsyHc60WM4EuyUxT"},"href":"https://api.spotify.com/v1/tracks/66cdXfnsyHc60WM4EuyUxT","id":"66cdXfnsyHc60WM4EuyUxT","is_local":false,"is_playable":true,"name":"On The Floor","track_number":18,"type":"track","uri":"spotify:track:66cdXfnsyHc60WM4EuyUxT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3IJxyZ07BQS9q5oCZScKV2"},"href":"https://api.spotify.com/v1/albums/3IJxyZ07BQS9q5oCZScKV2","id":"3IJxyZ07BQS9q5oCZScKV2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736b52d113115458487be99e03"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026b52d113115458487be99e03"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516b52d113115458487be99e03"}],"is_playable":true,"name":"Kids Dance Party Music","release_date":"2021-12-03","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:3IJxyZ07BQS9q5oCZScKV2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/2NedI091BMLjjHFUW1bVqA"},"href":"https://api.spotify.com/v1/tracks/2NedI091BMLjjHFUW1bVqA","id":"2NedI091BMLjjHFUW1bVqA","is_local":false,"is_playable":true,"name":"On The Floor","track_number":24,"type":"track","uri":"spotify:track:2NedI091BMLjjHFUW1bVqA"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7h3LTdqT5vRFyngdExHF7q"},"href":"https://api.spotify.com/v1/albums/7h3LTdqT5vRFyngdExHF7q","id":"7h3LTdqT5vRFyngdExHF7q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736f6cdc9dab844d480f0d2b3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026f6cdc9dab844d480f0d2b3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516f6cdc9dab844d480f0d2b3c"}],"is_playable":true,"name":"Smash Hits 2000","release_date":"2021-04-13","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:7h3LTdqT5vRFyngdExHF7q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/5nuJyWwpHrbKmhvFs0gsPK"},"href":"https://api.spotify.com/v1/tracks/5nuJyWwpHrbKmhvFs0gsPK","id":"5nuJyWwpHrbKmhvFs0gsPK","is_local":false,"is_playable":true,"name":"On The Floor","track_number":8,"type":"track","uri":"spotify:track:5nuJyWwpHrbKmhvFs0gsPK"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3xPCz3xss0WRIswW4S9Lxw"},"href":"https://api.spotify.com/v1/albums/3xPCz3xss0WRIswW4S9Lxw","id":"3xPCz3xss0WRIswW4S9Lxw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c51ffd36d657b21a18c269f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c51ffd36d657b21a18c269f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c51ffd36d657b21a18c269f"}],"is_playable":true,"name":"Putzen & Aufr\u00e4umen","release_date":"2024-11-22","release_date_precision":"day","total_tracks":71,"type":"album","uri":"spotify:album:3xPCz3xss0WRIswW4S9Lxw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/2GJUeTCPhqtnjGVKpMoNzH"},"href":"https://api.spotify.com/v1/tracks/2GJUeTCPhqtnjGVKpMoNzH","id":"2GJUeTCPhqtnjGVKpMoNzH","is_local":false,"is_playable":true,"name":"On The Floor","track_number":22,"type":"track","uri":"spotify:track:2GJUeTCPhqtnjGVKpMoNzH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1QAUXhqohQvcIOyXzkWKRe"},"href":"https://api.spotify.com/v1/albums/1QAUXhqohQvcIOyXzkWKRe","id":"1QAUXhqohQvcIOyXzkWKRe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fbecd5657bdb53001058b698"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fbecd5657bdb53001058b698"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fbecd5657bdb53001058b698"}],"is_playable":true,"name":"Pump It 2020","release_date":"2020-10-30","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:1QAUXhqohQvcIOyXzkWKRe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/38TlVAWWRyWq2LlWrvEldT"},"href":"https://api.spotify.com/v1/tracks/38TlVAWWRyWq2LlWrvEldT","id":"38TlVAWWRyWq2LlWrvEldT","is_local":false,"is_playable":true,"name":"On The Floor","track_number":7,"type":"track","uri":"spotify:track:38TlVAWWRyWq2LlWrvEldT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/49RWiM2AvWj1Oufsaj0kbt"},"href":"https://api.spotify.com/v1/albums/49RWiM2AvWj1Oufsaj0kbt","id":"49RWiM2AvWj1Oufsaj0kbt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f6e8d148f1903ef0de6eaff"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f6e8d148f1903ef0de6eaff"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f6e8d148f1903ef0de6eaff"}],"is_playable":true,"name":"Pop girl era | Pop Hits 2023 | Women on Top","release_date":"2023-11-14","release_date_precision":"day","total_tracks":45,"type":"album","uri":"spotify:album:49RWiM2AvWj1Oufsaj0kbt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/3bMoD1XliqgZfnZY88T30B"},"href":"https://api.spotify.com/v1/tracks/3bMoD1XliqgZfnZY88T30B","id":"3bMoD1XliqgZfnZY88T30B","is_local":false,"is_playable":true,"name":"On The Floor","track_number":43,"type":"track","uri":"spotify:track:3bMoD1XliqgZfnZY88T30B"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0WHZne2taTnKv2WuS88pTi"},"href":"https://api.spotify.com/v1/albums/0WHZne2taTnKv2WuS88pTi","id":"0WHZne2taTnKv2WuS88pTi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273843b2a3506d299e3a28de16e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02843b2a3506d299e3a28de16e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851843b2a3506d299e3a28de16e"}],"is_playable":true,"name":"Die besten Songs 2026","release_date":"2026-08-07","release_date_precision":"day","total_tracks":66,"type":"album","uri":"spotify:album:0WHZne2taTnKv2WuS88pTi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/11JX5rjOQllobqy6BM4lLN"},"href":"https://api.spotify.com/v1/tracks/11JX5rjOQllobqy6BM4lLN","id":"11JX5rjOQllobqy6BM4lLN","is_local":false,"is_playable":true,"name":"On The Floor","track_number":21,"type":"track","uri":"spotify:track:11JX5rjOQllobqy6BM4lLN"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Vodka%20%26%20Coke%20Delta%20Heavy&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Vodka%20%26%20Coke%20Delta%20Heavy&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41ouHqoKXNijIMFsQTmFQV"},"href":"https://api.spotify.com/v1/artists/41ouHqoKXNijIMFsQTmFQV","id":"41ouHqoKXNijIMFsQTmFQV","name":"\u00c6ON:MODE","type":"artist","uri":"spotify:artist:41ouHqoKXNijIMFsQTmFQV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4yzrGOiPCcssfpKBT0bnHR"},"href":"https://api.spotify.com/v1/artists/4yzrGOiPCcssfpKBT0bnHR","id":"4yzrGOiPCcssfpKBT0bnHR","name":"Nu-La","type":"artist","uri":"spotify:artist:4yzrGOiPCcssfpKBT0bnHR"}],"external_urls":{"spotify":"https://open.spotify.com/album/2EuzUEdeJgOfGsyM89w8Gh"},"href":"https://api.spotify.com/v1/albums/2EuzUEdeJgOfGsyM89w8Gh","id":"2EuzUEdeJgOfGsyM89w8Gh","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739818f72515c432f75f5b1995"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029818f72515c432f75f5b1995"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519818f72515c432f75f5b1995"}],"is_playable":true,"name":"Glow","release_date":"2026-04-02","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2EuzUEdeJgOfGsyM89w8Gh"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7GvVTb8yFV0ZrdI30Qce6T"},"href":"https://api.spotify.com/v1/artists/7GvVTb8yFV0ZrdI30Qce6T","id":"7GvVTb8yFV0ZrdI30Qce6T","name":"Delta Heavy","type":"artist","uri":"spotify:artist:7GvVTb8yFV0ZrdI30Qce6T"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41ouHqoKXNijIMFsQTmFQV"},"href":"https://api.spotify.com/v1/artists/41ouHqoKXNijIMFsQTmFQV","id":"41ouHqoKXNijIMFsQTmFQV","name":"\u00c6ON:MODE","type":"artist","uri":"spotify:artist:41ouHqoKXNijIMFsQTmFQV"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4yzrGOiPCcssfpKBT0bnHR"},"href":"https://api.spotify.com/v1/artists/4yzrGOiPCcssfpKBT0bnHR","id":"4yzrGOiPCcssfpKBT0bnHR","name":"Nu-La","type":"artist","uri":"spotify:artist:4yzrGOiPCcssfpKBT0bnHR"}],"disc_number":1,"duration_ms":231724,"explicit":false,"external_ids":{"isrc":"GB2LD2610041"},"external_urls":{"spotify":"https://open.spotify.com/track/0vA8uwu9xTryDZOZnUr9w2"},"href":"https://api.spotify.com/v1/tracks/0vA8uwu9xTryDZOZnUr9w2","id":"0vA8uwu9xTryDZOZnUr9w2","is_local":false,"is_playable":true,"name":"Glow","track_number":1,"type":"track","uri":"spotify:track:0vA8uwu9xTryDZOZnUr9w2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"}],"external_urls":{"spotify":"https://open.spotify.com/album/3sysiYphqNRQw7VKLCg1yE"},"href":"https://api.spotify.com/v1/albums/3sysiYphqNRQw7VKLCg1yE","id":"3sysiYphqNRQw7VKLCg1yE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d7b2aa3834b82b1cbe899a48"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d7b2aa3834b82b1cbe899a48"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d7b2aa3834b82b1cbe899a48"}],"is_playable":true,"name":"Love?","release_date":"2011-04-29","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:3sysiYphqNRQw7VKLCg1yE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/3C0nOe05EIt1390bVABLyN"},"href":"https://api.spotify.com/v1/tracks/3C0nOe05EIt1390bVABLyN","id":"3C0nOe05EIt1390bVABLyN","is_local":false,"is_playable":true,"name":"On The Floor","track_number":1,"type":"track","uri":"spotify:track:3C0nOe05EIt1390bVABLyN"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"external_urls":{"spotify":"https://open.spotify.com/album/543NK5YT3RjGmP7nFzWJPm"},"href":"https://api.spotify.com/v1/albums/543NK5YT3RjGmP7nFzWJPm","id":"543NK5YT3RjGmP7nFzWJPm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735c7fdd07d99c156401073aaa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025c7fdd07d99c156401073aaa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515c7fdd07d99c156401073aaa"}],"is_playable":true,"name":"On The Floor","release_date":"2011-02-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:543NK5YT3RjGmP7nFzWJPm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":230906,"explicit":false,"external_ids":{"isrc":"USUM71100721"},"external_urls":{"spotify":"https://open.spotify.com/track/0Oe49j06Bjrxs8PltuVeaW"},"href":"https://api.spotify.com/v1/tracks/0Oe49j06Bjrxs8PltuVeaW","id":"0Oe49j06Bjrxs8PltuVeaW","is_local":false,"is_playable":true,"name":"On The Floor - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:0Oe49j06Bjrxs8PltuVeaW"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5QmLvPJ5Wj0nUUP3yHSoyM"},"href":"https://api.spotify.com/v1/albums/5QmLvPJ5Wj0nUUP3yHSoyM","id":"5QmLvPJ5Wj0nUUP3yHSoyM","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a150a790f1ed224de90cb009"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a150a790f1ed224de90cb009"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a150a790f1ed224de90cb009"}],"is_playable":true,"name":"Female Pop Hits","release_date":"2020-03-13","release_date_precision":"day","total_tracks":31,"type":"album","uri":"spotify:album:5QmLvPJ5Wj0nUUP3yHSoyM"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/66cdXfnsyHc60WM4EuyUxT"},"href":"https://api.spotify.com/v1/tracks/66cdXfnsyHc60WM4EuyUxT","id":"66cdXfnsyHc60WM4EuyUxT","is_local":false,"is_playable":true,"name":"On The Floor","track_number":18,"type":"track","uri":"spotify:track:66cdXfnsyHc60WM4EuyUxT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3IJxyZ07BQS9q5oCZScKV2"},"href":"https://api.spotify.com/v1/albums/3IJxyZ07BQS9q5oCZScKV2","id":"3IJxyZ07BQS9q5oCZScKV2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736b52d113115458487be99e03"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026b52d113115458487be99e03"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516b52d113115458487be99e03"}],"is_playable":true,"name":"Kids Dance Party Music","release_date":"2021-12-03","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:3IJxyZ07BQS9q5oCZScKV2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/2NedI091BMLjjHFUW1bVqA"},"href":"https://api.spotify.com/v1/tracks/2NedI091BMLjjHFUW1bVqA","id":"2NedI091BMLjjHFUW1bVqA","is_local":false,"is_playable":true,"name":"On The Floor","track_number":24,"type":"track","uri":"spotify:track:2NedI091BMLjjHFUW1bVqA"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/7h3LTdqT5vRFyngdExHF7q"},"href":"https://api.spotify.com/v1/albums/7h3LTdqT5vRFyngdExHF7q","id":"7h3LTdqT5vRFyngdExHF7q","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736f6cdc9dab844d480f0d2b3c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026f6cdc9dab844d480f0d2b3c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516f6cdc9dab844d480f0d2b3c"}],"is_playable":true,"name":"Smash Hits 2000","release_date":"2021-04-13","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:7h3LTdqT5vRFyngdExHF7q"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/5nuJyWwpHrbKmhvFs0gsPK"},"href":"https://api.spotify.com/v1/tracks/5nuJyWwpHrbKmhvFs0gsPK","id":"5nuJyWwpHrbKmhvFs0gsPK","is_local":false,"is_playable":true,"name":"On The Floor","track_number":8,"type":"track","uri":"spotify:track:5nuJyWwpHrbKmhvFs0gsPK"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3xPCz3xss0WRIswW4S9Lxw"},"href":"https://api.spotify.com/v1/albums/3xPCz3xss0WRIswW4S9Lxw","id":"3xPCz3xss0WRIswW4S9Lxw","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731c51ffd36d657b21a18c269f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021c51ffd36d657b21a18c269f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511c51ffd36d657b21a18c269f"}],"is_playable":true,"name":"Putzen & Aufr\u00e4umen","release_date":"2024-11-22","release_date_precision":"day","total_tracks":71,"type":"album","uri":"spotify:album:3xPCz3xss0WRIswW4S9Lxw"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/2GJUeTCPhqtnjGVKpMoNzH"},"href":"https://api.spotify.com/v1/tracks/2GJUeTCPhqtnjGVKpMoNzH","id":"2GJUeTCPhqtnjGVKpMoNzH","is_local":false,"is_playable":true,"name":"On The Floor","track_number":22,"type":"track","uri":"spotify:track:2GJUeTCPhqtnjGVKpMoNzH"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1QAUXhqohQvcIOyXzkWKRe"},"href":"https://api.spotify.com/v1/albums/1QAUXhqohQvcIOyXzkWKRe","id":"1QAUXhqohQvcIOyXzkWKRe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fbecd5657bdb53001058b698"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fbecd5657bdb53001058b698"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fbecd5657bdb53001058b698"}],"is_playable":true,"name":"Pump It 2020","release_date":"2020-10-30","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:1QAUXhqohQvcIOyXzkWKRe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/38TlVAWWRyWq2LlWrvEldT"},"href":"https://api.spotify.com/v1/tracks/38TlVAWWRyWq2LlWrvEldT","id":"38TlVAWWRyWq2LlWrvEldT","is_local":false,"is_playable":true,"name":"On The Floor","track_number":7,"type":"track","uri":"spotify:track:38TlVAWWRyWq2LlWrvEldT"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/49RWiM2AvWj1Oufsaj0kbt"},"href":"https://api.spotify.com/v1/albums/49RWiM2AvWj1Oufsaj0kbt","id":"49RWiM2AvWj1Oufsaj0kbt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735f6e8d148f1903ef0de6eaff"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025f6e8d148f1903ef0de6eaff"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515f6e8d148f1903ef0de6eaff"}],"is_playable":true,"name":"Pop girl era | Pop Hits 2023 | Women on Top","release_date":"2023-11-14","release_date_precision":"day","total_tracks":45,"type":"album","uri":"spotify:album:49RWiM2AvWj1Oufsaj0kbt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/3bMoD1XliqgZfnZY88T30B"},"href":"https://api.spotify.com/v1/tracks/3bMoD1XliqgZfnZY88T30B","id":"3bMoD1XliqgZfnZY88T30B","is_local":false,"is_playable":true,"name":"On The Floor","track_number":43,"type":"track","uri":"spotify:track:3bMoD1XliqgZfnZY88T30B"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0WHZne2taTnKv2WuS88pTi"},"href":"https://api.spotify.com/v1/albums/0WHZne2taTnKv2WuS88pTi","id":"0WHZne2taTnKv2WuS88pTi","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273843b2a3506d299e3a28de16e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02843b2a3506d299e3a28de16e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851843b2a3506d299e3a28de16e"}],"is_playable":true,"name":"Die besten Songs 2026","release_date":"2026-08-07","release_date_precision":"day","total_tracks":66,"type":"album","uri":"spotify:album:0WHZne2taTnKv2WuS88pTi"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2DlGxzQSjYe5N6G9nkYghR"},"href":"https://api.spotify.com/v1/artists/2DlGxzQSjYe5N6G9nkYghR","id":"2DlGxzQSjYe5N6G9nkYghR","name":"Jennifer Lopez","type":"artist","uri":"spotify:artist:2DlGxzQSjYe5N6G9nkYghR"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0TnOYISbd1XYRBk9myaseg"},"href":"https://api.spotify.com/v1/artists/0TnOYISbd1XYRBk9myaseg","id":"0TnOYISbd1XYRBk9myaseg","name":"Pitbull","type":"artist","uri":"spotify:artist:0TnOYISbd1XYRBk9myaseg"}],"disc_number":1,"duration_ms":284866,"explicit":false,"external_ids":{"isrc":"USUM71104034"},"external_urls":{"spotify":"https://open.spotify.com/track/11JX5rjOQllobqy6BM4lLN"},"href":"https://api.spotify.com/v1/tracks/11JX5rjOQllobqy6BM4lLN","id":"11JX5rjOQllobqy6BM4lLN","is_local":false,"is_playable":true,"name":"On The Floor","track_number":21,"type":"track","uri":"spotify:track:11JX5rjOQllobqy6BM4lLN"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Vodka+%26+Coke+Delta+Heavy&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1CZWxvbmclMjBYdHJhaCZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzViNFIwOTI4Zzg5eTZxbU9ndEVOMU8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNWI0UjA5MjhnODl5NnFtT2d0RU4xTyIsImlkIjoiNWI0UjA5MjhnODl5NnFtT2d0RU4xTyIsIm5hbWUiOiJIeXN0YSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1YjRSMDkyOGc4OXk2cW1PZ3RFTjFPIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNTBjUnQ2MVlKSG1lYzlURm5MajRvUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzUwY1J0NjFZSkhtZWM5VEZuTGo0b1IiLCJpZCI6IjUwY1J0NjFZSkhtZWM5VEZuTGo0b1IiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMWY2YTBjMTA5MzM0MTQ0MGEwMmNlM2Y1Ig==", + "fSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWY2YTBjMTA5MzM0MTQ0MGEwMmNlM2Y1In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExZjZhMGMxMDkzMzQxNDQwYTAyY2UzZjUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmVsb25nIHRvIE9uZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDctMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjUwY1J0NjFZSkhtZWM5VEZuTGo0b1IifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81YjRSMDkyOGc4OXk2cW1PZ3RFTjFPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzViNFIwOTI4Zzg5eTZxbU9ndEVOMU8iLCJpZCI6IjViNFIwOTI4Zzg5eTZxbU9ndEVOMU8iLCJuYW1lIjoiSHlzdGEiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NWI0UjA5MjhnODl5NnFtT2d0RU4xTyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNzY3MzUsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJGUlI2NDI2MDE4MTUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRqN0ZoTjFEVjBNQTVTWkJ6VDlEajcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80ajdGaE4xRFYwTUE1U1pCelQ5RGo3IiwiaWQiOiI0ajdGaE4xRFYwTUE1U1pCelQ5RGo3IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlbG9uZyB0byBPbmUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGo3RmhOMURWME1BNVNaQnpUOURqNyJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zNFNPWlFiS1FPSVdOV2Nsdjlob0F6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzM0U09aUWJLUU9JV05XY2x2OWhvQXoiLCJpZCI6IjM0U09aUWJLUU9JV05XY2x2OWhvQXoiLCJuYW1lIjoiQ2hhZS1Xb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MzRTT1pRYktRT0lXTldjbHY5aG9BeiJ9XSwiZXh0ZXJuYQ==", + "bF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNkJ1SlZlV0Q4Tmd3bnQ2dHhGaXFhcSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZCdUpWZVdEOE5nd250NnR4RmlxYXEiLCJpZCI6IjZCdUpWZVdEOE5nd250NnR4RmlxYXEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODMxMzRlY2JmOTNlZmUwNTBkZjAyZjVmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjgzMTM0ZWNiZjkzZWZlMDUwZGYwMmY1ZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODMxMzRlY2JmOTNlZmUwNTBkZjAyZjVmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Ik1vcmFscyIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMTItMzEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2QnVKVmVXRDhOZ3dudDZ0eEZpcWFxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzRTT1pRYktRT0lXTldjbHY5aG9BeiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zNFNPWlFiS1FPSVdOV2Nsdjlob0F6IiwiaWQiOiIzNFNPWlFiS1FPSVdOV2Nsdjlob0F6IiwibmFtZSI6IkNoYWUtV29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjM0U09aUWJLUU9JV05XY2x2OWhvQXoifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NjM0NzEsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRVDYyVzI1MTExNDYifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzUyb1A0TGRyWHZxVUtHR2lJWnR1STkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81Mm9QNExkclh2cVVLR0dpSVp0dUk5IiwiaWQiOiI1Mm9QNExkclh2cVVLR0dpSVp0dUk5IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlbG9uZyB0byBtZSIsInRyYWNrX251bWJlciI6MTAsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NTJvUDRMZHJYdnFVS0dHaUladHVJOSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdA==", + "cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82SG1LSGY5d3RaMklSOUxUMlUyZFc0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZIbUtIZjl3dFoySVI5TFQyVTJkVzQiLCJpZCI6IjZIbUtIZjl3dFoySVI5TFQyVTJkVzQiLCJuYW1lIjoiSGlyZW50aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2SG1LSGY5d3RaMklSOUxUMlUyZFc0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMGtMclRkYTF5SWVQS1R6NDUyVE9wYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBrTHJUZGExeUllUEtUejQ1MlRPcGMiLCJpZCI6IjBrTHJUZGExeUllUEtUejQ1MlRPcGMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNTA3ZGY2NjJiMzhmNzk2MmM0NGViMjU2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjUwN2RmNjYyYjM4Zjc5NjJjNDRlYjI1NiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNTA3ZGY2NjJiMzhmNzk2MmM0NGViMjU2In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJlbG9uZyBUbyIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDEtMTYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBrTHJUZGExeUllUEtUejQ1MlRPcGMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82SG1LSGY5d3RaMklSOUxUMlUyZFc0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZIbUtIZjl3dFoySVI5TFQyVTJkVzQiLCJpZCI6IjZIbUtIZjl3dFoySVI5TFQyVTJkVzQiLCJuYW1lIjoiSGlyZW50aCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2SG1LSGY5d3RaMklSOUxUMlUyZFc0In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE2NTAwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlNFNjlOMjUwNzU2MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNktCQnBweTUxY3Zod0oyendUcA==", + "azk1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNktCQnBweTUxY3Zod0oyendUcGs5NSIsImlkIjoiNktCQnBweTUxY3Zod0oyendUcGs5NSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCZWxvbmcgVG8iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NktCQnBweTUxY3Zod0oyendUcGs5NSJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Belong+Xtrah&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=On%20My%20Mind%20Sub%20Focus&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=On%20My%20Mind%20Sub%20Focus&type=track","offset":0,"previous":null,"total":14,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ybINI1qPiFbwDXamRtwxD"},"href":"https://api.spotify.com/v1/artists/1ybINI1qPiFbwDXamRtwxD","id":"1ybINI1qPiFbwDXamRtwxD","name":"Smino","type":"artist","uri":"spotify:artist:1ybINI1qPiFbwDXamRtwxD"}],"external_urls":{"spotify":"https://open.spotify.com/album/3bTjPEgPzm1XwXsNlMVHhs"},"href":"https://api.spotify.com/v1/albums/3bTjPEgPzm1XwXsNlMVHhs","id":"3bTjPEgPzm1XwXsNlMVHhs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738be32b380765207f19d56435"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028be32b380765207f19d56435"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518be32b380765207f19d56435"}],"is_playable":true,"name":"blkswn","release_date":"2017-03-14","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:3bTjPEgPzm1XwXsNlMVHhs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ybINI1qPiFbwDXamRtwxD"},"href":"https://api.spotify.com/v1/artists/1ybINI1qPiFbwDXamRtwxD","id":"1ybINI1qPiFbwDXamRtwxD","name":"Smino","type":"artist","uri":"spotify:artist:1ybINI1qPiFbwDXamRtwxD"}],"disc_number":1,"duration_ms":469830,"explicit":true,"external_ids":{"isrc":"USUG11700177"},"external_urls":{"spotify":"https://open.spotify.com/track/3Zau3JcrZcBfw8aVjKGkSX"},"href":"https://api.spotify.com/v1/tracks/3Zau3JcrZcBfw8aVjKGkSX","id":"3Zau3JcrZcBfw8aVjKGkSX","is_local":false,"is_playable":true,"name":"Amphetamine","track_number":18,"type":"track","uri":"spotify:track:3Zau3JcrZcBfw8aVjKGkSX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5L1lO4eRHmJ7a0Q6csE5cT"},"href":"https://api.spotify.com/v1/artists/5L1lO4eRHmJ7a0Q6csE5cT","id":"5L1lO4eRHmJ7a0Q6csE5cT","name":"LISA","type":"artist","uri":"spotify:artist:5L1lO4eRHmJ7a0Q6csE5cT"}],"external_urls":{"spotify":"https://open.spotify.com/album/5eoWRkeplmcCL97afSMJVm"},"href":"https://api.spotify.com/v1/albums/5eoWRkeplmcCL97afSMJVm","id":"5eoWRkeplmcCL97afSMJVm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27395ce3d848f4e452489d4a12c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0295ce3d848f4e452489d4a12c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485195ce3d848f4e452489d4a12c"}],"is_playable":true,"name":"Alter Ego","release_date":"2025-02-28","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:5eoWRkeplmcCL97afSMJVm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5L1lO4eRHmJ7a0Q6csE5cT"},"href":"https://api.spotify.com/v1/artists/5L1lO4eRHmJ7a0Q6csE5cT","id":"5L1lO4eRHmJ7a0Q6csE5cT","name":"LISA","type":"artist","uri":"spotify:artist:5L1lO4eRHmJ7a0Q6csE5cT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7ltDVBr6mKbRvohxheJ9h1"},"href":"https://api.spotify.com/v1/artists/7ltDVBr6mKbRvohxheJ9h1","id":"7ltDVBr6mKbRvohxheJ9h1","name":"ROSAL\u00cdA","type":"artist","uri":"spotify:artist:7ltDVBr6mKbRvohxheJ9h1"}],"disc_number":1,"duration_ms":179789,"explicit":true,"external_ids":{"isrc":"USRC12402243"},"external_urls":{"spotify":"https://open.spotify.com/track/5UmfBGfRJgjZ8CdhgffabQ"},"href":"https://api.spotify.com/v1/tracks/5UmfBGfRJgjZ8CdhgffabQ","id":"5UmfBGfRJgjZ8CdhgffabQ","is_local":false,"is_playable":true,"name":"New Woman (feat. ROSAL\u00cdA)","track_number":5,"type":"track","uri":"spotify:track:5UmfBGfRJgjZ8CdhgffabQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/25uiPmTg16RbhZWAqwLBy5"},"href":"https://api.spotify.com/v1/artists/25uiPmTg16RbhZWAqwLBy5","id":"25uiPmTg16RbhZWAqwLBy5","name":"Charli xcx","type":"artist","uri":"spotify:artist:25uiPmTg16RbhZWAqwLBy5"}],"external_urls":{"spotify":"https://open.spotify.com/album/2lIZef4lzdvZkiiCzvPKj7"},"href":"https://api.spotify.com/v1/albums/2lIZef4lzdvZkiiCzvPKj7","id":"2lIZef4lzdvZkiiCzvPKj7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f88b43d15fd14e9525338b59"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f88b43d15fd14e9525338b59"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f88b43d15fd14e9525338b59"}],"is_playable":true,"name":"BRAT","release_date":"2024-06-07","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:2lIZef4lzdvZkiiCzvPKj7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/25uiPmTg16RbhZWAqwLBy5"},"href":"https://api.spotify.com/v1/artists/25uiPmTg16RbhZWAqwLBy5","id":"25uiPmTg16RbhZWAqwLBy5","name":"Charli xcx","type":"artist","uri":"spotify:artist:25uiPmTg16RbhZWAqwLBy5"}],"disc_number":1,"duration_ms":211352,"explicit":false,"external_ids":{"isrc":"USAT22401348"},"external_urls":{"spotify":"https://open.spotify.com/track/0AkiAfilrTUXV49dleC5SB"},"href":"https://api.spotify.com/v1/tracks/0AkiAfilrTUXV49dleC5SB","id":"0AkiAfilrTUXV49dleC5SB","is_local":false,"is_playable":true,"name":"So I","track_number":9,"type":"track","uri":"spotify:track:0AkiAfilrTUXV49dleC5SB"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5L1lO4eRHmJ7a0Q6csE5cT"},"href":"https://api.spotify.com/v1/artists/5L1lO4eRHmJ7a0Q6csE5cT","id":"5L1lO4eRHmJ7a0Q6csE5cT","name":"LISA","type":"artist","uri":"spotify:artist:5L1lO4eRHmJ7a0Q6csE5cT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7ltDVBr6mKbRvohxheJ9h1"},"href":"https://api.spotify.com/v1/artists/7ltDVBr6mKbRvohxheJ9h1","id":"7ltDVBr6mKbRvohxheJ9h1","name":"ROSAL\u00cdA","type":"artist","uri":"spotify:artist:7ltDVBr6mKbRvohxheJ9h1"}],"external_urls":{"spotify":"https://open.spotify.com/album/2ha4ucrONN0cihLMkP02Ch"},"href":"https://api.spotify.com/v1/albums/2ha4ucrONN0cihLMkP02Ch","id":"2ha4ucrONN0cihLMkP02Ch","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737f560aa479da9db40deb9f4d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027f560aa479da9db40deb9f4d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517f560aa479da9db40deb9f4d"}],"is_playable":true,"name":"New Woman (feat. ROSAL\u00cdA)","release_date":"2024-08-15","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2ha4ucrONN0cihLMkP02Ch"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5L1lO4eRHmJ7a0Q6csE5cT"},"href":"https://api.spotify.com/v1/artists/5L1lO4eRHmJ7a0Q6csE5cT","id":"5L1lO4eRHmJ7a0Q6csE5cT","name":"LISA","type":"artist","uri":"spotify:artist:5L1lO4eRHmJ7a0Q6csE5cT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7ltDVBr6mKbRvohxheJ9h1"},"href":"https://api.spotify.com/v1/artists/7ltDVBr6mKbRvohxheJ9h1","id":"7ltDVBr6mKbRvohxheJ9h1","name":"ROSAL\u00cdA","type":"artist","uri":"spotify:artist:7ltDVBr6mKbRvohxheJ9h1"}],"disc_number":1,"duration_ms":179789,"explicit":true,"external_ids":{"isrc":"USRC12402243"},"external_urls":{"spotify":"https://open.spotify.com/track/7ov3TDp5D00Rnu5R1viX4w"},"href":"https://api.spotify.com/v1/tracks/7ov3TDp5D00Rnu5R1viX4w","id":"7ov3TDp5D00Rnu5R1viX4w","is_local":false,"is_playable":true,"name":"New Woman (feat. ROSAL\u00cdA)","track_number":1,"type":"track","uri":"spotify:track:7ov3TDp5D00Rnu5R1viX4w"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/13ubrt8QOOCPljQ2FL1Kca"},"href":"https://api.spotify.com/v1/artists/13ubrt8QOOCPljQ2FL1Kca","id":"13ubrt8QOOCPljQ2FL1Kca","name":"A$AP Rocky","type":"artist","uri":"spotify:artist:13ubrt8QOOCPljQ2FL1Kca"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l6EPpP9hjQrLb8qNB9eC5"},"href":"https://api.spotify.com/v1/albums/4l6EPpP9hjQrLb8qNB9eC5","id":"4l6EPpP9hjQrLb8qNB9eC5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c8ced8a4d6b6b61eb592f3dd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c8ced8a4d6b6b61eb592f3dd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c8ced8a4d6b6b61eb592f3dd"}],"is_playable":true,"name":"LIVE.LOVE.A$AP","release_date":"2011-10-31","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4l6EPpP9hjQrLb8qNB9eC5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/13ubrt8QOOCPljQ2FL1Kca"},"href":"https://api.spotify.com/v1/artists/13ubrt8QOOCPljQ2FL1Kca","id":"13ubrt8QOOCPljQ2FL1Kca","name":"A$AP Rocky","type":"artist","uri":"spotify:artist:13ubrt8QOOCPljQ2FL1Kca"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3N71zVVdCs6uCgk8w31v26"},"href":"https://api.spotify.com/v1/artists/3N71zVVdCs6uCgk8w31v26","id":"3N71zVVdCs6uCgk8w31v26","name":"Fat Tony","type":"artist","uri":"spotify:artist:3N71zVVdCs6uCgk8w31v26"}],"disc_number":1,"duration_ms":178706,"explicit":true,"external_ids":{"isrc":"USRC12103091"},"external_urls":{"spotify":"https://open.spotify.com/track/4nzmPINOWf5sdKNrTjcM3z"},"href":"https://api.spotify.com/v1/tracks/4nzmPINOWf5sdKNrTjcM3z","id":"4nzmPINOWf5sdKNrTjcM3z","is_local":false,"is_playable":true,"name":"Get Lit (feat. Fat Tony)","track_number":7,"type":"track","uri":"spotify:track:4nzmPINOWf5sdKNrTjcM3z"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Qi71tzx7zrOMtl8tRPhSI"},"href":"https://api.spotify.com/v1/albums/3Qi71tzx7zrOMtl8tRPhSI","id":"3Qi71tzx7zrOMtl8tRPhSI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730ba320293e1c2ea131af3123"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020ba320293e1c2ea131af3123"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510ba320293e1c2ea131af3123"}],"is_playable":true,"name":"Fluxiverse Vol. 1","release_date":"2023-11-16","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:3Qi71tzx7zrOMtl8tRPhSI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"disc_number":1,"duration_ms":196713,"explicit":false,"external_ids":{"isrc":"GBUM92300183"},"external_urls":{"spotify":"https://open.spotify.com/track/0ai5YvHe7fjW1siaDf5LDH"},"href":"https://api.spotify.com/v1/tracks/0ai5YvHe7fjW1siaDf5LDH","id":"0ai5YvHe7fjW1siaDf5LDH","is_local":false,"is_playable":true,"name":"24/7","track_number":2,"type":"track","uri":"spotify:track:0ai5YvHe7fjW1siaDf5LDH"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/5SGtwshMiamRGS0e76Y1jZ"},"href":"https://api.spotify.com/v1/albums/5SGtwshMiamRGS0e76Y1jZ","id":"5SGtwshMiamRGS0e76Y1jZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f67343dff2f778cd8c4367e3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f67343dff2f778cd8c4367e3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f67343dff2f778cd8c4367e3"}],"is_playable":true,"name":"24/7 (Remixes)","release_date":"2024-12-12","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:5SGtwshMiamRGS0e76Y1jZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"disc_number":1,"duration_ms":196713,"explicit":false,"external_ids":{"isrc":"GBUM92300183"},"external_urls":{"spotify":"https://open.spotify.com/track/2jjx1bkZRnYjqjg8HYF7p7"},"href":"https://api.spotify.com/v1/tracks/2jjx1bkZRnYjqjg8HYF7p7","id":"2jjx1bkZRnYjqjg8HYF7p7","is_local":false,"is_playable":true,"name":"24/7","track_number":6,"type":"track","uri":"spotify:track:2jjx1bkZRnYjqjg8HYF7p7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ocnIbhFWM9bSPrd7Hu4zF"},"href":"https://api.spotify.com/v1/artists/1ocnIbhFWM9bSPrd7Hu4zF","id":"1ocnIbhFWM9bSPrd7Hu4zF","name":"Punctual","type":"artist","uri":"spotify:artist:1ocnIbhFWM9bSPrd7Hu4zF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6Z8vLeI1ZMj2kzTNWVOBXr"},"href":"https://api.spotify.com/v1/artists/6Z8vLeI1ZMj2kzTNWVOBXr","id":"6Z8vLeI1ZMj2kzTNWVOBXr","name":"Jordan Shaw","type":"artist","uri":"spotify:artist:6Z8vLeI1ZMj2kzTNWVOBXr"}],"external_urls":{"spotify":"https://open.spotify.com/album/1WIy38HHVBg8KG3hVkCE2V"},"href":"https://api.spotify.com/v1/albums/1WIy38HHVBg8KG3hVkCE2V","id":"1WIy38HHVBg8KG3hVkCE2V","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27348a280c9975ed09b734b5191"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0248a280c9975ed09b734b5191"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485148a280c9975ed09b734b5191"}],"is_playable":true,"name":"Do It All Again","release_date":"2022-02-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1WIy38HHVBg8KG3hVkCE2V"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ocnIbhFWM9bSPrd7Hu4zF"},"href":"https://api.spotify.com/v1/artists/1ocnIbhFWM9bSPrd7Hu4zF","id":"1ocnIbhFWM9bSPrd7Hu4zF","name":"Punctual","type":"artist","uri":"spotify:artist:1ocnIbhFWM9bSPrd7Hu4zF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6Z8vLeI1ZMj2kzTNWVOBXr"},"href":"https://api.spotify.com/v1/artists/6Z8vLeI1ZMj2kzTNWVOBXr","id":"6Z8vLeI1ZMj2kzTNWVOBXr","name":"Jordan Shaw","type":"artist","uri":"spotify:artist:6Z8vLeI1ZMj2kzTNWVOBXr"}],"disc_number":1,"duration_ms":137419,"explicit":false,"external_ids":{"isrc":"CA6D22100888"},"external_urls":{"spotify":"https://open.spotify.com/track/6BwPstqf4RoRMbDidFWNxE"},"href":"https://api.spotify.com/v1/tracks/6BwPstqf4RoRMbDidFWNxE","id":"6BwPstqf4RoRMbDidFWNxE","is_local":false,"is_playable":true,"name":"Do It All Again","track_number":1,"type":"track","uri":"spotify:track:6BwPstqf4RoRMbDidFWNxE"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/24XzT54nBcrfKRPqf4LKMx"},"href":"https://api.spotify.com/v1/albums/24XzT54nBcrfKRPqf4LKMx","id":"24XzT54nBcrfKRPqf4LKMx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739b8da78919d12ee8a3777dfb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029b8da78919d12ee8a3777dfb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519b8da78919d12ee8a3777dfb"}],"is_playable":true,"name":"24/7","release_date":"2023-11-16","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:24XzT54nBcrfKRPqf4LKMx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"disc_number":1,"duration_ms":196713,"explicit":false,"external_ids":{"isrc":"GBUM92300183"},"external_urls":{"spotify":"https://open.spotify.com/track/1LraClqzskY3OMPI0B7I4P"},"href":"https://api.spotify.com/v1/tracks/1LraClqzskY3OMPI0B7I4P","id":"1LraClqzskY3OMPI0B7I4P","is_local":false,"is_playable":true,"name":"24/7","track_number":1,"type":"track","uri":"spotify:track:1LraClqzskY3OMPI0B7I4P"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1JspXUvEv3D9ddMeLNqYWj"},"href":"https://api.spotify.com/v1/artists/1JspXUvEv3D9ddMeLNqYWj","id":"1JspXUvEv3D9ddMeLNqYWj","name":"flowerovlove","type":"artist","uri":"spotify:artist:1JspXUvEv3D9ddMeLNqYWj"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ar9EPv1ddMgvDnOCONH15"},"href":"https://api.spotify.com/v1/albums/3ar9EPv1ddMgvDnOCONH15","id":"3ar9EPv1ddMgvDnOCONH15","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f44ea9c40af5c025149f85d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f44ea9c40af5c025149f85d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f44ea9c40af5c025149f85d7"}],"is_playable":true,"name":"BOYS","release_date":"2024-05-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3ar9EPv1ddMgvDnOCONH15"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1JspXUvEv3D9ddMeLNqYWj"},"href":"https://api.spotify.com/v1/artists/1JspXUvEv3D9ddMeLNqYWj","id":"1JspXUvEv3D9ddMeLNqYWj","name":"flowerovlove","type":"artist","uri":"spotify:artist:1JspXUvEv3D9ddMeLNqYWj"}],"disc_number":1,"duration_ms":145742,"explicit":false,"external_ids":{"isrc":"USUG12402688"},"external_urls":{"spotify":"https://open.spotify.com/track/1U0UUDLyBN8ENq3gjNJq6S"},"href":"https://api.spotify.com/v1/tracks/1U0UUDLyBN8ENq3gjNJq6S","id":"1U0UUDLyBN8ENq3gjNJq6S","is_local":false,"is_playable":true,"name":"BOYS","track_number":1,"type":"track","uri":"spotify:track:1U0UUDLyBN8ENq3gjNJq6S"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=On%20My%20Mind%20Sub%20Focus&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=On%20My%20Mind%20Sub%20Focus&type=track","offset":0,"previous":null,"total":14,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ybINI1qPiFbwDXamRtwxD"},"href":"https://api.spotify.com/v1/artists/1ybINI1qPiFbwDXamRtwxD","id":"1ybINI1qPiFbwDXamRtwxD","name":"Smino","type":"artist","uri":"spotify:artist:1ybINI1qPiFbwDXamRtwxD"}],"external_urls":{"spotify":"https://open.spotify.com/album/3bTjPEgPzm1XwXsNlMVHhs"},"href":"https://api.spotify.com/v1/albums/3bTjPEgPzm1XwXsNlMVHhs","id":"3bTjPEgPzm1XwXsNlMVHhs","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738be32b380765207f19d56435"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028be32b380765207f19d56435"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518be32b380765207f19d56435"}],"is_playable":true,"name":"blkswn","release_date":"2017-03-14","release_date_precision":"day","total_tracks":18,"type":"album","uri":"spotify:album:3bTjPEgPzm1XwXsNlMVHhs"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ybINI1qPiFbwDXamRtwxD"},"href":"https://api.spotify.com/v1/artists/1ybINI1qPiFbwDXamRtwxD","id":"1ybINI1qPiFbwDXamRtwxD","name":"Smino","type":"artist","uri":"spotify:artist:1ybINI1qPiFbwDXamRtwxD"}],"disc_number":1,"duration_ms":469830,"explicit":true,"external_ids":{"isrc":"USUG11700177"},"external_urls":{"spotify":"https://open.spotify.com/track/3Zau3JcrZcBfw8aVjKGkSX"},"href":"https://api.spotify.com/v1/tracks/3Zau3JcrZcBfw8aVjKGkSX","id":"3Zau3JcrZcBfw8aVjKGkSX","is_local":false,"is_playable":true,"name":"Amphetamine","track_number":18,"type":"track","uri":"spotify:track:3Zau3JcrZcBfw8aVjKGkSX"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5L1lO4eRHmJ7a0Q6csE5cT"},"href":"https://api.spotify.com/v1/artists/5L1lO4eRHmJ7a0Q6csE5cT","id":"5L1lO4eRHmJ7a0Q6csE5cT","name":"LISA","type":"artist","uri":"spotify:artist:5L1lO4eRHmJ7a0Q6csE5cT"}],"external_urls":{"spotify":"https://open.spotify.com/album/5eoWRkeplmcCL97afSMJVm"},"href":"https://api.spotify.com/v1/albums/5eoWRkeplmcCL97afSMJVm","id":"5eoWRkeplmcCL97afSMJVm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27395ce3d848f4e452489d4a12c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0295ce3d848f4e452489d4a12c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485195ce3d848f4e452489d4a12c"}],"is_playable":true,"name":"Alter Ego","release_date":"2025-02-28","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:5eoWRkeplmcCL97afSMJVm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5L1lO4eRHmJ7a0Q6csE5cT"},"href":"https://api.spotify.com/v1/artists/5L1lO4eRHmJ7a0Q6csE5cT","id":"5L1lO4eRHmJ7a0Q6csE5cT","name":"LISA","type":"artist","uri":"spotify:artist:5L1lO4eRHmJ7a0Q6csE5cT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7ltDVBr6mKbRvohxheJ9h1"},"href":"https://api.spotify.com/v1/artists/7ltDVBr6mKbRvohxheJ9h1","id":"7ltDVBr6mKbRvohxheJ9h1","name":"ROSAL\u00cdA","type":"artist","uri":"spotify:artist:7ltDVBr6mKbRvohxheJ9h1"}],"disc_number":1,"duration_ms":179789,"explicit":true,"external_ids":{"isrc":"USRC12402243"},"external_urls":{"spotify":"https://open.spotify.com/track/5UmfBGfRJgjZ8CdhgffabQ"},"href":"https://api.spotify.com/v1/tracks/5UmfBGfRJgjZ8CdhgffabQ","id":"5UmfBGfRJgjZ8CdhgffabQ","is_local":false,"is_playable":true,"name":"New Woman (feat. ROSAL\u00cdA)","track_number":5,"type":"track","uri":"spotify:track:5UmfBGfRJgjZ8CdhgffabQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/25uiPmTg16RbhZWAqwLBy5"},"href":"https://api.spotify.com/v1/artists/25uiPmTg16RbhZWAqwLBy5","id":"25uiPmTg16RbhZWAqwLBy5","name":"Charli xcx","type":"artist","uri":"spotify:artist:25uiPmTg16RbhZWAqwLBy5"}],"external_urls":{"spotify":"https://open.spotify.com/album/2lIZef4lzdvZkiiCzvPKj7"},"href":"https://api.spotify.com/v1/albums/2lIZef4lzdvZkiiCzvPKj7","id":"2lIZef4lzdvZkiiCzvPKj7","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f88b43d15fd14e9525338b59"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f88b43d15fd14e9525338b59"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f88b43d15fd14e9525338b59"}],"is_playable":true,"name":"BRAT","release_date":"2024-06-07","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:2lIZef4lzdvZkiiCzvPKj7"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/25uiPmTg16RbhZWAqwLBy5"},"href":"https://api.spotify.com/v1/artists/25uiPmTg16RbhZWAqwLBy5","id":"25uiPmTg16RbhZWAqwLBy5","name":"Charli xcx","type":"artist","uri":"spotify:artist:25uiPmTg16RbhZWAqwLBy5"}],"disc_number":1,"duration_ms":211352,"explicit":false,"external_ids":{"isrc":"USAT22401348"},"external_urls":{"spotify":"https://open.spotify.com/track/0AkiAfilrTUXV49dleC5SB"},"href":"https://api.spotify.com/v1/tracks/0AkiAfilrTUXV49dleC5SB","id":"0AkiAfilrTUXV49dleC5SB","is_local":false,"is_playable":true,"name":"So I","track_number":9,"type":"track","uri":"spotify:track:0AkiAfilrTUXV49dleC5SB"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5L1lO4eRHmJ7a0Q6csE5cT"},"href":"https://api.spotify.com/v1/artists/5L1lO4eRHmJ7a0Q6csE5cT","id":"5L1lO4eRHmJ7a0Q6csE5cT","name":"LISA","type":"artist","uri":"spotify:artist:5L1lO4eRHmJ7a0Q6csE5cT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7ltDVBr6mKbRvohxheJ9h1"},"href":"https://api.spotify.com/v1/artists/7ltDVBr6mKbRvohxheJ9h1","id":"7ltDVBr6mKbRvohxheJ9h1","name":"ROSAL\u00cdA","type":"artist","uri":"spotify:artist:7ltDVBr6mKbRvohxheJ9h1"}],"external_urls":{"spotify":"https://open.spotify.com/album/2ha4ucrONN0cihLMkP02Ch"},"href":"https://api.spotify.com/v1/albums/2ha4ucrONN0cihLMkP02Ch","id":"2ha4ucrONN0cihLMkP02Ch","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737f560aa479da9db40deb9f4d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027f560aa479da9db40deb9f4d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517f560aa479da9db40deb9f4d"}],"is_playable":true,"name":"New Woman (feat. ROSAL\u00cdA)","release_date":"2024-08-15","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2ha4ucrONN0cihLMkP02Ch"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5L1lO4eRHmJ7a0Q6csE5cT"},"href":"https://api.spotify.com/v1/artists/5L1lO4eRHmJ7a0Q6csE5cT","id":"5L1lO4eRHmJ7a0Q6csE5cT","name":"LISA","type":"artist","uri":"spotify:artist:5L1lO4eRHmJ7a0Q6csE5cT"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7ltDVBr6mKbRvohxheJ9h1"},"href":"https://api.spotify.com/v1/artists/7ltDVBr6mKbRvohxheJ9h1","id":"7ltDVBr6mKbRvohxheJ9h1","name":"ROSAL\u00cdA","type":"artist","uri":"spotify:artist:7ltDVBr6mKbRvohxheJ9h1"}],"disc_number":1,"duration_ms":179789,"explicit":true,"external_ids":{"isrc":"USRC12402243"},"external_urls":{"spotify":"https://open.spotify.com/track/7ov3TDp5D00Rnu5R1viX4w"},"href":"https://api.spotify.com/v1/tracks/7ov3TDp5D00Rnu5R1viX4w","id":"7ov3TDp5D00Rnu5R1viX4w","is_local":false,"is_playable":true,"name":"New Woman (feat. ROSAL\u00cdA)","track_number":1,"type":"track","uri":"spotify:track:7ov3TDp5D00Rnu5R1viX4w"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/13ubrt8QOOCPljQ2FL1Kca"},"href":"https://api.spotify.com/v1/artists/13ubrt8QOOCPljQ2FL1Kca","id":"13ubrt8QOOCPljQ2FL1Kca","name":"A$AP Rocky","type":"artist","uri":"spotify:artist:13ubrt8QOOCPljQ2FL1Kca"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l6EPpP9hjQrLb8qNB9eC5"},"href":"https://api.spotify.com/v1/albums/4l6EPpP9hjQrLb8qNB9eC5","id":"4l6EPpP9hjQrLb8qNB9eC5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c8ced8a4d6b6b61eb592f3dd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c8ced8a4d6b6b61eb592f3dd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c8ced8a4d6b6b61eb592f3dd"}],"is_playable":true,"name":"LIVE.LOVE.A$AP","release_date":"2011-10-31","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:4l6EPpP9hjQrLb8qNB9eC5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/13ubrt8QOOCPljQ2FL1Kca"},"href":"https://api.spotify.com/v1/artists/13ubrt8QOOCPljQ2FL1Kca","id":"13ubrt8QOOCPljQ2FL1Kca","name":"A$AP Rocky","type":"artist","uri":"spotify:artist:13ubrt8QOOCPljQ2FL1Kca"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3N71zVVdCs6uCgk8w31v26"},"href":"https://api.spotify.com/v1/artists/3N71zVVdCs6uCgk8w31v26","id":"3N71zVVdCs6uCgk8w31v26","name":"Fat Tony","type":"artist","uri":"spotify:artist:3N71zVVdCs6uCgk8w31v26"}],"disc_number":1,"duration_ms":178706,"explicit":true,"external_ids":{"isrc":"USRC12103091"},"external_urls":{"spotify":"https://open.spotify.com/track/4nzmPINOWf5sdKNrTjcM3z"},"href":"https://api.spotify.com/v1/tracks/4nzmPINOWf5sdKNrTjcM3z","id":"4nzmPINOWf5sdKNrTjcM3z","is_local":false,"is_playable":true,"name":"Get Lit (feat. Fat Tony)","track_number":7,"type":"track","uri":"spotify:track:4nzmPINOWf5sdKNrTjcM3z"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Qi71tzx7zrOMtl8tRPhSI"},"href":"https://api.spotify.com/v1/albums/3Qi71tzx7zrOMtl8tRPhSI","id":"3Qi71tzx7zrOMtl8tRPhSI","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730ba320293e1c2ea131af3123"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020ba320293e1c2ea131af3123"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510ba320293e1c2ea131af3123"}],"is_playable":true,"name":"Fluxiverse Vol. 1","release_date":"2023-11-16","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:3Qi71tzx7zrOMtl8tRPhSI"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"disc_number":1,"duration_ms":196713,"explicit":false,"external_ids":{"isrc":"GBUM92300183"},"external_urls":{"spotify":"https://open.spotify.com/track/0ai5YvHe7fjW1siaDf5LDH"},"href":"https://api.spotify.com/v1/tracks/0ai5YvHe7fjW1siaDf5LDH","id":"0ai5YvHe7fjW1siaDf5LDH","is_local":false,"is_playable":true,"name":"24/7","track_number":2,"type":"track","uri":"spotify:track:0ai5YvHe7fjW1siaDf5LDH"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/5SGtwshMiamRGS0e76Y1jZ"},"href":"https://api.spotify.com/v1/albums/5SGtwshMiamRGS0e76Y1jZ","id":"5SGtwshMiamRGS0e76Y1jZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f67343dff2f778cd8c4367e3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f67343dff2f778cd8c4367e3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f67343dff2f778cd8c4367e3"}],"is_playable":true,"name":"24/7 (Remixes)","release_date":"2024-12-12","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:5SGtwshMiamRGS0e76Y1jZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"disc_number":1,"duration_ms":196713,"explicit":false,"external_ids":{"isrc":"GBUM92300183"},"external_urls":{"spotify":"https://open.spotify.com/track/2jjx1bkZRnYjqjg8HYF7p7"},"href":"https://api.spotify.com/v1/tracks/2jjx1bkZRnYjqjg8HYF7p7","id":"2jjx1bkZRnYjqjg8HYF7p7","is_local":false,"is_playable":true,"name":"24/7","track_number":6,"type":"track","uri":"spotify:track:2jjx1bkZRnYjqjg8HYF7p7"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ocnIbhFWM9bSPrd7Hu4zF"},"href":"https://api.spotify.com/v1/artists/1ocnIbhFWM9bSPrd7Hu4zF","id":"1ocnIbhFWM9bSPrd7Hu4zF","name":"Punctual","type":"artist","uri":"spotify:artist:1ocnIbhFWM9bSPrd7Hu4zF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6Z8vLeI1ZMj2kzTNWVOBXr"},"href":"https://api.spotify.com/v1/artists/6Z8vLeI1ZMj2kzTNWVOBXr","id":"6Z8vLeI1ZMj2kzTNWVOBXr","name":"Jordan Shaw","type":"artist","uri":"spotify:artist:6Z8vLeI1ZMj2kzTNWVOBXr"}],"external_urls":{"spotify":"https://open.spotify.com/album/1WIy38HHVBg8KG3hVkCE2V"},"href":"https://api.spotify.com/v1/albums/1WIy38HHVBg8KG3hVkCE2V","id":"1WIy38HHVBg8KG3hVkCE2V","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27348a280c9975ed09b734b5191"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0248a280c9975ed09b734b5191"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485148a280c9975ed09b734b5191"}],"is_playable":true,"name":"Do It All Again","release_date":"2022-02-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1WIy38HHVBg8KG3hVkCE2V"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1ocnIbhFWM9bSPrd7Hu4zF"},"href":"https://api.spotify.com/v1/artists/1ocnIbhFWM9bSPrd7Hu4zF","id":"1ocnIbhFWM9bSPrd7Hu4zF","name":"Punctual","type":"artist","uri":"spotify:artist:1ocnIbhFWM9bSPrd7Hu4zF"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6Z8vLeI1ZMj2kzTNWVOBXr"},"href":"https://api.spotify.com/v1/artists/6Z8vLeI1ZMj2kzTNWVOBXr","id":"6Z8vLeI1ZMj2kzTNWVOBXr","name":"Jordan Shaw","type":"artist","uri":"spotify:artist:6Z8vLeI1ZMj2kzTNWVOBXr"}],"disc_number":1,"duration_ms":137419,"explicit":false,"external_ids":{"isrc":"CA6D22100888"},"external_urls":{"spotify":"https://open.spotify.com/track/6BwPstqf4RoRMbDidFWNxE"},"href":"https://api.spotify.com/v1/tracks/6BwPstqf4RoRMbDidFWNxE","id":"6BwPstqf4RoRMbDidFWNxE","is_local":false,"is_playable":true,"name":"Do It All Again","track_number":1,"type":"track","uri":"spotify:track:6BwPstqf4RoRMbDidFWNxE"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"external_urls":{"spotify":"https://open.spotify.com/album/24XzT54nBcrfKRPqf4LKMx"},"href":"https://api.spotify.com/v1/albums/24XzT54nBcrfKRPqf4LKMx","id":"24XzT54nBcrfKRPqf4LKMx","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739b8da78919d12ee8a3777dfb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029b8da78919d12ee8a3777dfb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519b8da78919d12ee8a3777dfb"}],"is_playable":true,"name":"24/7","release_date":"2023-11-16","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:24XzT54nBcrfKRPqf4LKMx"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7muzHifhMdnfN1xncRLOqk"},"href":"https://api.spotify.com/v1/artists/7muzHifhMdnfN1xncRLOqk","id":"7muzHifhMdnfN1xncRLOqk","name":"Flux Pavilion","type":"artist","uri":"spotify:artist:7muzHifhMdnfN1xncRLOqk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0tgjwsn1Lpjj8kKEvWm0KQ"},"href":"https://api.spotify.com/v1/artists/0tgjwsn1Lpjj8kKEvWm0KQ","id":"0tgjwsn1Lpjj8kKEvWm0KQ","name":"Doctor P","type":"artist","uri":"spotify:artist:0tgjwsn1Lpjj8kKEvWm0KQ"}],"disc_number":1,"duration_ms":196713,"explicit":false,"external_ids":{"isrc":"GBUM92300183"},"external_urls":{"spotify":"https://open.spotify.com/track/1LraClqzskY3OMPI0B7I4P"},"href":"https://api.spotify.com/v1/tracks/1LraClqzskY3OMPI0B7I4P","id":"1LraClqzskY3OMPI0B7I4P","is_local":false,"is_playable":true,"name":"24/7","track_number":1,"type":"track","uri":"spotify:track:1LraClqzskY3OMPI0B7I4P"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1JspXUvEv3D9ddMeLNqYWj"},"href":"https://api.spotify.com/v1/artists/1JspXUvEv3D9ddMeLNqYWj","id":"1JspXUvEv3D9ddMeLNqYWj","name":"flowerovlove","type":"artist","uri":"spotify:artist:1JspXUvEv3D9ddMeLNqYWj"}],"external_urls":{"spotify":"https://open.spotify.com/album/3ar9EPv1ddMgvDnOCONH15"},"href":"https://api.spotify.com/v1/albums/3ar9EPv1ddMgvDnOCONH15","id":"3ar9EPv1ddMgvDnOCONH15","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f44ea9c40af5c025149f85d7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f44ea9c40af5c025149f85d7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f44ea9c40af5c025149f85d7"}],"is_playable":true,"name":"BOYS","release_date":"2024-05-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3ar9EPv1ddMgvDnOCONH15"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1JspXUvEv3D9ddMeLNqYWj"},"href":"https://api.spotify.com/v1/artists/1JspXUvEv3D9ddMeLNqYWj","id":"1JspXUvEv3D9ddMeLNqYWj","name":"flowerovlove","type":"artist","uri":"spotify:artist:1JspXUvEv3D9ddMeLNqYWj"}],"disc_number":1,"duration_ms":145742,"explicit":false,"external_ids":{"isrc":"USUG12402688"},"external_urls":{"spotify":"https://open.spotify.com/track/1U0UUDLyBN8ENq3gjNJq6S"},"href":"https://api.spotify.com/v1/tracks/1U0UUDLyBN8ENq3gjNJq6S","id":"1U0UUDLyBN8ENq3gjNJq6S","is_local":false,"is_playable":true,"name":"BOYS","track_number":1,"type":"track","uri":"spotify:track:1U0UUDLyBN8ENq3gjNJq6S"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=On+My+Mind+Sub+Focus&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhcmhlYWQlMjIlMjBhcnRpc3QlM0ElMjJQZW5kdWx1bSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhcmhlYWQlMjIlMjBhcnRpc3QlM0ElMjJQZW5kdWx1bSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Warhead%22+artist%3A%22Pendulum%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJlbGlldmUlMjBNZSUyMiUyMGFydGlzdCUzQSUyMkFuZHklMjBDJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wYnJyN3hTMnBjUVo1SEZhY05XdzFOIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBicnI3eFMycGNRWjVIRmFjTld3MU4iLCJpZCI6IjBicnI3eFMycGNRWjVIRmFjTld3MU4iLCJuYW1lIjoiQW5keSBDcm9mdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MGJycjd4UzJwY1FaNUhGYWNOV3cxTiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzRFUndiTDRFdnc1NU94dnRIQklxMXgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy80RVJ3Ykw0RXZ3NTVPeHZ0SEJJcTF4IiwiaWQiOiI0RVJ3Ykw0RXZ3NTVPeHZ0SEJJcTF4IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZw==", + "ZS9hYjY3NjE2ZDAwMDBiMjczZmM4Zjg2MzUyYzdkYzliMjVlZWY5NWJkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZjOGY4NjM1MmM3ZGM5YjI1ZWVmOTViZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmM4Zjg2MzUyYzdkYzliMjVlZWY5NWJkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBCb29nYWxvbyBSYWRpbyBTZXNzaW9ucyIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMDMtMDIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0RVJ3Ykw0RXZ3NTVPeHZ0SEJJcTF4In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMGJycjd4UzJwY1FaNUhGYWNOV3cxTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wYnJyN3hTMnBjUVo1SEZhY05XdzFOIiwiaWQiOiIwYnJyN3hTMnBjUVo1SEZhY05XdzFOIiwibmFtZSI6IkFuZHkgQ3JvZnRzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBicnI3eFMycGNRWjVIRmFjTld3MU4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTM2MjUwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUVpGWVgyMDI0NDE5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81dm9qSDBJMU1VTVM1MVNrV2ZvcEQ2In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNXZvakgwSTFNVU1TNTFTa1dmb3BENiIsImlkIjoiNXZvakgwSTFNVU1TNTFTa1dmb3BENiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJZb3UgU3RpbGwgQmVsaWV2ZSBpbiBNZSIsInRyYWNrX251bWJlciI6MTQsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NXZvakgwSTFNVU1TNTFTa1dmb3BENiJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Believe+Me%22+artist%3A%22Andy+C%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Bad%20Company%20Bad%20Company%20UK&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Bad%20Company%20Bad%20Company%20UK&type=track","offset":0,"previous":null,"total":22,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"},{"external_urls":{"spotify":"https://open.spotify.com/artist/63RlEaEuJxvoGSoO7nBQK3"},"href":"https://api.spotify.com/v1/artists/63RlEaEuJxvoGSoO7nBQK3","id":"63RlEaEuJxvoGSoO7nBQK3","name":"Latte","type":"artist","uri":"spotify:artist:63RlEaEuJxvoGSoO7nBQK3"}],"external_urls":{"spotify":"https://open.spotify.com/album/6lveuYxSFFgdgL1VMOGiJT"},"href":"https://api.spotify.com/v1/albums/6lveuYxSFFgdgL1VMOGiJT","id":"6lveuYxSFFgdgL1VMOGiJT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c915e9c5c8cf4e8c9d44dc88"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c915e9c5c8cf4e8c9d44dc88"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c915e9c5c8cf4e8c9d44dc88"}],"is_playable":true,"name":"Planet Dust (Latte Remix)","release_date":"2026-06-10","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6lveuYxSFFgdgL1VMOGiJT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"},{"external_urls":{"spotify":"https://open.spotify.com/artist/63RlEaEuJxvoGSoO7nBQK3"},"href":"https://api.spotify.com/v1/artists/63RlEaEuJxvoGSoO7nBQK3","id":"63RlEaEuJxvoGSoO7nBQK3","name":"Latte","type":"artist","uri":"spotify:artist:63RlEaEuJxvoGSoO7nBQK3"}],"disc_number":1,"duration_ms":358620,"explicit":false,"external_ids":{"isrc":"GB2LD2610168"},"external_urls":{"spotify":"https://open.spotify.com/track/2mWKhxXzTebK51PqWoDsVv"},"href":"https://api.spotify.com/v1/tracks/2mWKhxXzTebK51PqWoDsVv","id":"2mWKhxXzTebK51PqWoDsVv","is_local":false,"is_playable":true,"name":"Planet Dust - Latte Remix","track_number":1,"type":"track","uri":"spotify:track:2mWKhxXzTebK51PqWoDsVv"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5AEG63ajney2BoDXi0Vb84"},"href":"https://api.spotify.com/v1/artists/5AEG63ajney2BoDXi0Vb84","id":"5AEG63ajney2BoDXi0Vb84","name":"Bad Company","type":"artist","uri":"spotify:artist:5AEG63ajney2BoDXi0Vb84"}],"external_urls":{"spotify":"https://open.spotify.com/album/4fuDpBLCt9ChDlqw48bj7p"},"href":"https://api.spotify.com/v1/albums/4fuDpBLCt9ChDlqw48bj7p","id":"4fuDpBLCt9ChDlqw48bj7p","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739adafd7f9d57380d1d0373af"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029adafd7f9d57380d1d0373af"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519adafd7f9d57380d1d0373af"}],"is_playable":true,"name":"Bad Company (Deluxe)","release_date":"1974","release_date_precision":"year","total_tracks":21,"type":"album","uri":"spotify:album:4fuDpBLCt9ChDlqw48bj7p"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5AEG63ajney2BoDXi0Vb84"},"href":"https://api.spotify.com/v1/artists/5AEG63ajney2BoDXi0Vb84","id":"5AEG63ajney2BoDXi0Vb84","name":"Bad Company","type":"artist","uri":"spotify:artist:5AEG63ajney2BoDXi0Vb84"}],"disc_number":1,"duration_ms":288053,"explicit":false,"external_ids":{"isrc":"USAT21405163"},"external_urls":{"spotify":"https://open.spotify.com/track/36vTL8WP4ZoD1bbUaW0V3E"},"href":"https://api.spotify.com/v1/tracks/36vTL8WP4ZoD1bbUaW0V3E","id":"36vTL8WP4ZoD1bbUaW0V3E","is_local":false,"is_playable":true,"name":"Bad Company - 2015 Remaster","track_number":5,"type":"track","uri":"spotify:track:36vTL8WP4ZoD1bbUaW0V3E"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"external_urls":{"spotify":"https://open.spotify.com/album/6ONi4PuixDHmkogDeUaoNF"},"href":"https://api.spotify.com/v1/albums/6ONi4PuixDHmkogDeUaoNF","id":"6ONi4PuixDHmkogDeUaoNF","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27354c9a25a74ed0e0f0419b3fe"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0254c9a25a74ed0e0f0419b3fe"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485154c9a25a74ed0e0f0419b3fe"}],"is_playable":true,"name":"The Nine (Remastered)","release_date":"2014-01-03","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:6ONi4PuixDHmkogDeUaoNF"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"disc_number":1,"duration_ms":426449,"explicit":false,"external_ids":{"isrc":"GBTEL1400013"},"external_urls":{"spotify":"https://open.spotify.com/track/4SQfru2JwRHATPltjQFLEL"},"href":"https://api.spotify.com/v1/tracks/4SQfru2JwRHATPltjQFLEL","id":"4SQfru2JwRHATPltjQFLEL","is_local":false,"is_playable":true,"name":"The Nine - Remastered","track_number":1,"type":"track","uri":"spotify:track:4SQfru2JwRHATPltjQFLEL"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"external_urls":{"spotify":"https://open.spotify.com/album/3e8t8j74XldGeXD6D5JA1S"},"href":"https://api.spotify.com/v1/albums/3e8t8j74XldGeXD6D5JA1S","id":"3e8t8j74XldGeXD6D5JA1S","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737471386cd923adc956cb6165"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027471386cd923adc956cb6165"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517471386cd923adc956cb6165"}],"is_playable":true,"name":"Book Of The Bad","release_date":"2001","release_date_precision":"year","total_tracks":16,"type":"album","uri":"spotify:album:3e8t8j74XldGeXD6D5JA1S"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"disc_number":1,"duration_ms":430533,"explicit":false,"external_ids":{"isrc":"GB9TP1700303"},"external_urls":{"spotify":"https://open.spotify.com/track/3TUpzy7h0D2nbNr276t5NR"},"href":"https://api.spotify.com/v1/tracks/3TUpzy7h0D2nbNr276t5NR","id":"3TUpzy7h0D2nbNr276t5NR","is_local":false,"is_playable":true,"name":"Planet dust","track_number":8,"type":"track","uri":"spotify:track:3TUpzy7h0D2nbNr276t5NR"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"external_urls":{"spotify":"https://open.spotify.com/album/20xm6MCpr55RbgLDbRumnH"},"href":"https://api.spotify.com/v1/albums/20xm6MCpr55RbgLDbRumnH","id":"20xm6MCpr55RbgLDbRumnH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27333dd915e808ed0553c33444e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0233dd915e808ed0553c33444e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485133dd915e808ed0553c33444e"}],"is_playable":true,"name":"Shot Down on Safari","release_date":"2002","release_date_precision":"year","total_tracks":9,"type":"album","uri":"spotify:album:20xm6MCpr55RbgLDbRumnH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"disc_number":1,"duration_ms":360200,"explicit":false,"external_ids":{"isrc":"GB9TP1700316"},"external_urls":{"spotify":"https://open.spotify.com/track/0IeJzSJP6Yz5219kriLfPd"},"href":"https://api.spotify.com/v1/tracks/0IeJzSJP6Yz5219kriLfPd","id":"0IeJzSJP6Yz5219kriLfPd","is_local":false,"is_playable":true,"name":"Hornet","track_number":2,"type":"track","uri":"spotify:track:0IeJzSJP6Yz5219kriLfPd"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5t28BP42x2axFnqOOMg3CM"},"href":"https://api.spotify.com/v1/artists/5t28BP42x2axFnqOOMg3CM","id":"5t28BP42x2axFnqOOMg3CM","name":"Five Finger Death Punch","type":"artist","uri":"spotify:artist:5t28BP42x2axFnqOOMg3CM"}],"external_urls":{"spotify":"https://open.spotify.com/album/6UVYgnSnY4ytapGgBY4BzZ"},"href":"https://api.spotify.com/v1/albums/6UVYgnSnY4ytapGgBY4BzZ","id":"6UVYgnSnY4ytapGgBY4BzZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273021dd6fc31a42ac4e4ab778c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02021dd6fc31a42ac4e4ab778c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851021dd6fc31a42ac4e4ab778c"}],"is_playable":true,"name":"War is the Answer","release_date":"2009-09-22","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:6UVYgnSnY4ytapGgBY4BzZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5t28BP42x2axFnqOOMg3CM"},"href":"https://api.spotify.com/v1/artists/5t28BP42x2axFnqOOMg3CM","id":"5t28BP42x2axFnqOOMg3CM","name":"Five Finger Death Punch","type":"artist","uri":"spotify:artist:5t28BP42x2axFnqOOMg3CM"}],"disc_number":1,"duration_ms":262440,"explicit":true,"external_ids":{"isrc":"US5Z50900004"},"external_urls":{"spotify":"https://open.spotify.com/track/1UWGkn34CD31VQfdi4D8Zp"},"href":"https://api.spotify.com/v1/tracks/1UWGkn34CD31VQfdi4D8Zp","id":"1UWGkn34CD31VQfdi4D8Zp","is_local":false,"is_playable":true,"name":"Bad Company","track_number":12,"type":"track","uri":"spotify:track:1UWGkn34CD31VQfdi4D8Zp"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LTnf5KB3uMpHKgx29u62C"},"href":"https://api.spotify.com/v1/artists/4LTnf5KB3uMpHKgx29u62C","id":"4LTnf5KB3uMpHKgx29u62C","name":"Rocks of Mars","type":"artist","uri":"spotify:artist:4LTnf5KB3uMpHKgx29u62C"}],"external_urls":{"spotify":"https://open.spotify.com/album/6960d1qaZkm8gtvf9MEZIt"},"href":"https://api.spotify.com/v1/albums/6960d1qaZkm8gtvf9MEZIt","id":"6960d1qaZkm8gtvf9MEZIt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b2bb47bed3df690f6e504193"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b2bb47bed3df690f6e504193"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b2bb47bed3df690f6e504193"}],"is_playable":true,"name":"Bad Company","release_date":"2025-12-15","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6960d1qaZkm8gtvf9MEZIt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LTnf5KB3uMpHKgx29u62C"},"href":"https://api.spotify.com/v1/artists/4LTnf5KB3uMpHKgx29u62C","id":"4LTnf5KB3uMpHKgx29u62C","name":"Rocks of Mars","type":"artist","uri":"spotify:artist:4LTnf5KB3uMpHKgx29u62C"}],"disc_number":1,"duration_ms":102413,"explicit":false,"external_ids":{"isrc":"CBECC2401733"},"external_urls":{"spotify":"https://open.spotify.com/track/3l0gUJeAzXmgk0HlmuqRII"},"href":"https://api.spotify.com/v1/tracks/3l0gUJeAzXmgk0HlmuqRII","id":"3l0gUJeAzXmgk0HlmuqRII","is_local":false,"is_playable":true,"name":"Bad Company","track_number":1,"type":"track","uri":"spotify:track:3l0gUJeAzXmgk0HlmuqRII"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/13ubrt8QOOCPljQ2FL1Kca"},"href":"https://api.spotify.com/v1/artists/13ubrt8QOOCPljQ2FL1Kca","id":"13ubrt8QOOCPljQ2FL1Kca","name":"A$AP Rocky","type":"artist","uri":"spotify:artist:13ubrt8QOOCPljQ2FL1Kca"}],"external_urls":{"spotify":"https://open.spotify.com/album/2IB4u7CExI80gM2KbkDtDp"},"href":"https://api.spotify.com/v1/albums/2IB4u7CExI80gM2KbkDtDp","id":"2IB4u7CExI80gM2KbkDtDp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f669edbfecf19e5725b7af6c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f669edbfecf19e5725b7af6c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f669edbfecf19e5725b7af6c"}],"is_playable":true,"name":"Bad Company (feat. BlocBoy JB)","release_date":"2018-03-28","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2IB4u7CExI80gM2KbkDtDp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/13ubrt8QOOCPljQ2FL1Kca"},"href":"https://api.spotify.com/v1/artists/13ubrt8QOOCPljQ2FL1Kca","id":"13ubrt8QOOCPljQ2FL1Kca","name":"A$AP Rocky","type":"artist","uri":"spotify:artist:13ubrt8QOOCPljQ2FL1Kca"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4TEJudQY2pXxVHPE3gD2EU"},"href":"https://api.spotify.com/v1/artists/4TEJudQY2pXxVHPE3gD2EU","id":"4TEJudQY2pXxVHPE3gD2EU","name":"BlocBoy JB","type":"artist","uri":"spotify:artist:4TEJudQY2pXxVHPE3gD2EU"}],"disc_number":1,"duration_ms":183809,"explicit":true,"external_ids":{"isrc":"USRC11801012"},"external_urls":{"spotify":"https://open.spotify.com/track/3ZYwSDF9knZI0RVlKR4PHC"},"href":"https://api.spotify.com/v1/tracks/3ZYwSDF9knZI0RVlKR4PHC","id":"3ZYwSDF9knZI0RVlKR4PHC","is_local":false,"is_playable":true,"name":"Bad Company (feat. BlocBoy JB)","track_number":1,"type":"track","uri":"spotify:track:3ZYwSDF9knZI0RVlKR4PHC"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4k1ELeJKT1ISyDv8JivPpB"},"href":"https://api.spotify.com/v1/artists/4k1ELeJKT1ISyDv8JivPpB","id":"4k1ELeJKT1ISyDv8JivPpB","name":"The Prodigy","type":"artist","uri":"spotify:artist:4k1ELeJKT1ISyDv8JivPpB"}],"external_urls":{"spotify":"https://open.spotify.com/album/1z4n8pE2pFbf9fYvpqrLEV"},"href":"https://api.spotify.com/v1/albums/1z4n8pE2pFbf9fYvpqrLEV","id":"1z4n8pE2pFbf9fYvpqrLEV","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737492dd94c571f3e63768f47b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027492dd94c571f3e63768f47b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517492dd94c571f3e63768f47b"}],"is_playable":true,"name":"The Day Is My Enemy (Bad Company UK Remix)","release_date":"2016-10-01","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1z4n8pE2pFbf9fYvpqrLEV"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4k1ELeJKT1ISyDv8JivPpB"},"href":"https://api.spotify.com/v1/artists/4k1ELeJKT1ISyDv8JivPpB","id":"4k1ELeJKT1ISyDv8JivPpB","name":"The Prodigy","type":"artist","uri":"spotify:artist:4k1ELeJKT1ISyDv8JivPpB"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4AAf6BI1IJxvkqv98mDHin"},"href":"https://api.spotify.com/v1/artists/4AAf6BI1IJxvkqv98mDHin","id":"4AAf6BI1IJxvkqv98mDHin","name":"Bad Company UK","type":"artist","uri":"spotify:artist:4AAf6BI1IJxvkqv98mDHin"}],"disc_number":1,"duration_ms":242758,"explicit":false,"external_ids":{"isrc":"GBCEJ1600279"},"external_urls":{"spotify":"https://open.spotify.com/track/4NHx4cOfce2T2eMU6j1KIQ"},"href":"https://api.spotify.com/v1/tracks/4NHx4cOfce2T2eMU6j1KIQ","id":"4NHx4cOfce2T2eMU6j1KIQ","is_local":false,"is_playable":true,"name":"The Day Is My Enemy - Bad Company UK Remix","track_number":1,"type":"track","uri":"spotify:track:4NHx4cOfce2T2eMU6j1KIQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"}],"external_urls":{"spotify":"https://open.spotify.com/album/1RM6MGv6bcl6NrAG8PGoZk"},"href":"https://api.spotify.com/v1/albums/1RM6MGv6bcl6NrAG8PGoZk","id":"1RM6MGv6bcl6NrAG8PGoZk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273365b3fb800c19f7ff72602da"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02365b3fb800c19f7ff72602da"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851365b3fb800c19f7ff72602da"}],"is_playable":true,"name":"Confessions (Expanded Edition)","release_date":"2004-03-23","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:1RM6MGv6bcl6NrAG8PGoZk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/23zg3TcAtWQy7J6upgbUnj"},"href":"https://api.spotify.com/v1/artists/23zg3TcAtWQy7J6upgbUnj","id":"23zg3TcAtWQy7J6upgbUnj","name":"USHER","type":"artist","uri":"spotify:artist:23zg3TcAtWQy7J6upgbUnj"}],"disc_number":1,"duration_ms":261800,"explicit":false,"external_ids":{"isrc":"USAR10400214"},"external_urls":{"spotify":"https://open.spotify.com/track/5rPzPAaOUceS8HiAculegz"},"href":"https://api.spotify.com/v1/tracks/5rPzPAaOUceS8HiAculegz","id":"5rPzPAaOUceS8HiAculegz","is_local":false,"is_playable":true,"name":"Bad Girl","track_number":12,"type":"track","uri":"spotify:track:5rPzPAaOUceS8HiAculegz"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1CYWQlMjBDb21wYW55JTIwQmFkJTIwQ29tcGFueSUyMFVLJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9zZWFyY2g/b2Zmc2V0PTEwJmxpbWl0PTEwJnF1ZXJ5PUJhZCUyMENvbXBhbnklMjBCYWQlMjBDb21wYW55JTIwVUsmdHlwZT10cmFjayIsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoyMiwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRBQWY2QkkxSUp4dmtxdjk4bURIaW4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsImlkIjoiNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsIm5hbWUiOiJCYWQgQ29tcGFueSBVSyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0QUFmNkJJMUlKeHZrcXY5OG1ESGluIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzYzUmxFYUV1Snh2b0dTb083bkJRSzMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNjNSbEVhRXVKeHZvR1NvTzduQlFLMyIsImlkIjoiNjNSbEVhRXVKeHZvR1NvTzduQlFLMyIsIm5hbWUiOiJMYXR0ZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2M1JsRWFFdUp4dm9HU29PN25CUUszIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNmx2ZXVZeFNGRmdkZ0wxVk1PR2lKVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZsdmV1WXhTRkZnZGdMMVZNT0dpSlQiLCJpZCI6IjZsdmV1WXhTRkZnZGdMMVZNT0dpSlQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYzkxNWU5YzVjOGNmNGU4YzlkNDRkYzg4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmM5MTVlOWM1YzhjZjRlOGM5ZDQ0ZGM4OCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYzkxNWU5YzVjOGNmNGU4YzlkNDRkYzg4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZQ==", + "LCJuYW1lIjoiUGxhbmV0IER1c3QgKExhdHRlIFJlbWl4KSIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDYtMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZsdmV1WXhTRkZnZGdMMVZNT0dpSlQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80QUFmNkJJMUlKeHZrcXY5OG1ESGluIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRBQWY2QkkxSUp4dmtxdjk4bURIaW4iLCJpZCI6IjRBQWY2QkkxSUp4dmtxdjk4bURIaW4iLCJuYW1lIjoiQmFkIENvbXBhbnkgVUsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEFBZjZCSTFJSnh2a3F2OThtREhpbiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82M1JsRWFFdUp4dm9HU29PN25CUUszIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzYzUmxFYUV1Snh2b0dTb083bkJRSzMiLCJpZCI6IjYzUmxFYUV1Snh2b0dTb083bkJRSzMiLCJuYW1lIjoiTGF0dGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NjNSbEVhRXVKeHZvR1NvTzduQlFLMyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozNTg2MjAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQjJMRDI2MTAxNjgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJtV0toeFh6VGViSzUxUHFXb0RzVnYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8ybVdLaHhYelRlYks1MVBxV29Ec1Z2IiwiaWQiOiIybVdLaHhYelRlYks1MVBxV29Ec1Z2IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlBsYW5ldCBEdXN0IC0gTGF0dGUgUmVtaXgiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mm1XS2h4WHpUZWJLNTFQcVdvRHNWdiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81QUVHNjNham5leTJCb0RYaTBWYjg0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVBRUc2M2FqbmV5MkJvRFhpMFZiODQiLCJpZCI6IjVBRUc2M2FqbmV5MkJvRFhpMFZiODQiLCJuYW1lIjoiQmFkIENvbQ==", + "cGFueSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1QUVHNjNham5leTJCb0RYaTBWYjg0In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNGZ1RHBCTEN0OUNoRGxxdzQ4Ymo3cCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzRmdURwQkxDdDlDaERscXc0OGJqN3AiLCJpZCI6IjRmdURwQkxDdDlDaERscXc0OGJqN3AiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOWFkYWZkN2Y5ZDU3MzgwZDFkMDM3M2FmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjlhZGFmZDdmOWQ1NzM4MGQxZDAzNzNhZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOWFkYWZkN2Y5ZDU3MzgwZDFkMDM3M2FmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhZCBDb21wYW55IChEZWx1eGUpIiwicmVsZWFzZV9kYXRlIjoiMTk3NCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoyMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo0ZnVEcEJMQ3Q5Q2hEbHF3NDhiajdwIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNUFFRzYzYWpuZXkyQm9EWGkwVmI4NCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81QUVHNjNham5leTJCb0RYaTBWYjg0IiwiaWQiOiI1QUVHNjNham5leTJCb0RYaTBWYjg0IiwibmFtZSI6IkJhZCBDb21wYW55IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVBRUc2M2FqbmV5MkJvRFhpMFZiODQifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6Mjg4MDUzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBVDIxNDA1MTYzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zNnZUTDhXUDRab0QxYmJVYVcwVjNFIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMzZ2VEw4V1A0Wm9EMWJiVWFXMFYzRSIsImlkIjoiMzZ2VEw4V1A0Wm9EMWJiVWFXMFYzRSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCYWQgQ29tcGFueSAtIDIwMTUgUmVtYXN0ZXIiLCJ0cmFja19udW1iZQ==", + "ciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozNnZUTDhXUDRab0QxYmJVYVcwVjNFIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80QUFmNkJJMUlKeHZrcXY5OG1ESGluIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRBQWY2QkkxSUp4dmtxdjk4bURIaW4iLCJpZCI6IjRBQWY2QkkxSUp4dmtxdjk4bURIaW4iLCJuYW1lIjoiQmFkIENvbXBhbnkgVUsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEFBZjZCSTFJSnh2a3F2OThtREhpbiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZPTmk0UHVpeERIbWtvZ0RlVWFvTkYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82T05pNFB1aXhESG1rb2dEZVVhb05GIiwiaWQiOiI2T05pNFB1aXhESG1rb2dEZVVhb05GIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzU0YzlhMjVhNzRlZDBlMGYwNDE5YjNmZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI1NGM5YTI1YTc0ZWQwZTBmMDQxOWIzZmUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTU0YzlhMjVhNzRlZDBlMGYwNDE5YjNmZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgTmluZSAoUmVtYXN0ZXJlZCkiLCJyZWxlYXNlX2RhdGUiOiIyMDE0LTAxLTAzIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2T05pNFB1aXhESG1rb2dEZVVhb05GIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEFBZjZCSTFJSnh2a3F2OThtREhpbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80QUFmNkJJMUlKeHZrcXY5OG1ESGluIiwiaWQiOiI0QUFmNkJJMUlKeHZrcXY5OG1ESGluIiwibmFtZSI6IkJhZCBDb21wYW55IFVLIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRBQWY2QkkxSUp4dmtxdjk4bURIaW4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDI2NDQ5LCJleA==", + "cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQlRFTDE0MDAwMTMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRTUWZydTJKd1JIQVRQbHRqUUZMRUwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80U1FmcnUySndSSEFUUGx0alFGTEVMIiwiaWQiOiI0U1FmcnUySndSSEFUUGx0alFGTEVMIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBOaW5lIC0gUmVtYXN0ZXJlZCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0U1FmcnUySndSSEFUUGx0alFGTEVMIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRBQWY2QkkxSUp4dmtxdjk4bURIaW4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsImlkIjoiNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsIm5hbWUiOiJCYWQgQ29tcGFueSBVSyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0QUFmNkJJMUlKeHZrcXY5OG1ESGluIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2U4dDhqNzRYbGRHZVhENkQ1SkExUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNlOHQ4ajc0WGxkR2VYRDZENUpBMVMiLCJpZCI6IjNlOHQ4ajc0WGxkR2VYRDZENUpBMVMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzQ3MTM4NmNkOTIzYWRjOTU2Y2I2MTY1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjc0NzEzODZjZDkyM2FkYzk1NmNiNjE2NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNzQ3MTM4NmNkOTIzYWRjOTU2Y2I2MTY1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJvb2sgT2YgVGhlIEJhZCIsInJlbGVhc2VfZGF0ZSI6IjIwMDEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2U4dDhqNzRYbGRHZVhENkQ1SkExUyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbA==", + "X3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEFBZjZCSTFJSnh2a3F2OThtREhpbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80QUFmNkJJMUlKeHZrcXY5OG1ESGluIiwiaWQiOiI0QUFmNkJJMUlKeHZrcXY5OG1ESGluIiwibmFtZSI6IkJhZCBDb21wYW55IFVLIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRBQWY2QkkxSUp4dmtxdjk4bURIaW4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NDMwNTMzLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0I5VFAxNzAwMzAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zVFVwenk3aDBEMm5iTnIyNzZ0NU5SIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM1RVcHp5N2gwRDJuYk5yMjc2dDVOUiIsImlkIjoiM1RVcHp5N2gwRDJuYk5yMjc2dDVOUiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQbGFuZXQgZHVzdCIsInRyYWNrX251bWJlciI6OCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozVFVwenk3aDBEMm5iTnIyNzZ0NU5SIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRBQWY2QkkxSUp4dmtxdjk4bURIaW4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsImlkIjoiNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsIm5hbWUiOiJCYWQgQ29tcGFueSBVSyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0QUFmNkJJMUlKeHZrcXY5OG1ESGluIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMjB4bTZNQ3ByNTVSYmdMRGJSdW1uSCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzIweG02TUNwcjU1UmJnTERiUnVtbkgiLCJpZCI6IjIweG02TUNwcjU1UmJnTERiUnVtbkgiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzNkZDkxNWU4MDhlZDA1NTNjMzM0NDRlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjMzZGQ5MTVlODA4ZWQwNTUzYzMzNDQ0ZSJ9LHsiaGVpZw==", + "aHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzM2RkOTE1ZTgwOGVkMDU1M2MzMzQ0NGUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU2hvdCBEb3duIG9uIFNhZmFyaSIsInJlbGVhc2VfZGF0ZSI6IjIwMDIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoieWVhciIsInRvdGFsX3RyYWNrcyI6OSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyMHhtNk1DcHI1NVJiZ0xEYlJ1bW5IIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNEFBZjZCSTFJSnh2a3F2OThtREhpbiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80QUFmNkJJMUlKeHZrcXY5OG1ESGluIiwiaWQiOiI0QUFmNkJJMUlKeHZrcXY5OG1ESGluIiwibmFtZSI6IkJhZCBDb21wYW55IFVLIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRBQWY2QkkxSUp4dmtxdjk4bURIaW4ifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzYwMjAwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0I5VFAxNzAwMzE2In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wSWVKelNKUDZZejUyMTlrcmlMZlBkIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMEllSnpTSlA2WXo1MjE5a3JpTGZQZCIsImlkIjoiMEllSnpTSlA2WXo1MjE5a3JpTGZQZCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb3JuZXQiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MEllSnpTSlA2WXo1MjE5a3JpTGZQZCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81dDI4QlA0MngyYXhGbnFPT01nM0NNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV0MjhCUDQyeDJheEZucU9PTWczQ00iLCJpZCI6IjV0MjhCUDQyeDJheEZucU9PTWczQ00iLCJuYW1lIjoiRml2ZSBGaW5nZXIgRGVhdGggUHVuY2giLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXQyOEJQNDJ4MmF4Rm5xT09NZzNDTSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZVVllnblNuWTR5dGFwR2dCWTRCeloifSwiaHJlZiI6Imh0dHBzOg==", + "Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZVVllnblNuWTR5dGFwR2dCWTRCeloiLCJpZCI6IjZVVllnblNuWTR5dGFwR2dCWTRCeloiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDIxZGQ2ZmMzMWE0MmFjNGU0YWI3NzhjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjAyMWRkNmZjMzFhNDJhYzRlNGFiNzc4YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDIxZGQ2ZmMzMWE0MmFjNGU0YWI3NzhjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhciBpcyB0aGUgQW5zd2VyIiwicmVsZWFzZV9kYXRlIjoiMjAwOS0wOS0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZVVllnblNuWTR5dGFwR2dCWTRCeloifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81dDI4QlA0MngyYXhGbnFPT01nM0NNIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV0MjhCUDQyeDJheEZucU9PTWczQ00iLCJpZCI6IjV0MjhCUDQyeDJheEZucU9PTWczQ00iLCJuYW1lIjoiRml2ZSBGaW5nZXIgRGVhdGggUHVuY2giLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXQyOEJQNDJ4MmF4Rm5xT09NZzNDTSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNjI0NDAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTNVo1MDkwMDAwNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVVXR2tuMzRDRDMxVlFmZGk0RDhacCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFVV0drbjM0Q0QzMVZRZmRpNEQ4WnAiLCJpZCI6IjFVV0drbjM0Q0QzMVZRZmRpNEQ4WnAiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmFkIENvbXBhbnkiLCJ0cmFja19udW1iZXIiOjEyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFVV0drbjM0Q0QzMVZRZmRpNEQ4WnAifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0Lw==", + "NExUbmY1S0IzdU1wSEtneDI5dTYyQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80TFRuZjVLQjN1TXBIS2d4Mjl1NjJDIiwiaWQiOiI0TFRuZjVLQjN1TXBIS2d4Mjl1NjJDIiwibmFtZSI6IlJvY2tzIG9mIE1hcnMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NExUbmY1S0IzdU1wSEtneDI5dTYyQyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzY5NjBkMXFhWmttOGd0dmY5TUVaSXQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82OTYwZDFxYVprbThndHZmOU1FWkl0IiwiaWQiOiI2OTYwZDFxYVprbThndHZmOU1FWkl0IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2IyYmI0N2JlZDNkZjY5MGY2ZTUwNDE5MyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiMmJiNDdiZWQzZGY2OTBmNmU1MDQxOTMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWIyYmI0N2JlZDNkZjY5MGY2ZTUwNDE5MyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCYWQgQ29tcGFueSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMTItMTUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjY5NjBkMXFhWmttOGd0dmY5TUVaSXQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80TFRuZjVLQjN1TXBIS2d4Mjl1NjJDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRMVG5mNUtCM3VNcEhLZ3gyOXU2MkMiLCJpZCI6IjRMVG5mNUtCM3VNcEhLZ3gyOXU2MkMiLCJuYW1lIjoiUm9ja3Mgb2YgTWFycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0TFRuZjVLQjN1TXBIS2d4Mjl1NjJDIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEwMjQxMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkNCRUNDMjQwMTczMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2wwZ1VKZUF6WG1nazBIbG11cVJJSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNsMA==", + "Z1VKZUF6WG1nazBIbG11cVJJSSIsImlkIjoiM2wwZ1VKZUF6WG1nazBIbG11cVJJSSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJCYWQgQ29tcGFueSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozbDBnVUplQXpYbWdrMEhsbXVxUklJIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xM3VicnQ4UU9PQ1BsalEyRkwxS2NhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzEzdWJydDhRT09DUGxqUTJGTDFLY2EiLCJpZCI6IjEzdWJydDhRT09DUGxqUTJGTDFLY2EiLCJuYW1lIjoiQSRBUCBSb2NreSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoxM3VicnQ4UU9PQ1BsalEyRkwxS2NhIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMklCNHU3Q0V4STgwZ00yS2JrRHREcCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJJQjR1N0NFeEk4MGdNMktia0R0RHAiLCJpZCI6IjJJQjR1N0NFeEk4MGdNMktia0R0RHAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjY2OWVkYmZlY2YxOWU1NzI1YjdhZjZjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY2NjllZGJmZWNmMTllNTcyNWI3YWY2YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjY2OWVkYmZlY2YxOWU1NzI1YjdhZjZjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJhZCBDb21wYW55IChmZWF0LiBCbG9jQm95IEpCKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDMtMjgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJJQjR1N0NFeEk4MGdNMktia0R0RHAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xM3VicnQ4UU9PQ1BsalEyRkwxS2NhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzEzdWJydDhRT09DUGxqUTJGTDFLY2EiLCJpZCI6IjEzdWJydDhRT09DUGxqUTJGTDFLY2EiLCJuYQ==", + "bWUiOiJBJEFQIFJvY2t5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjEzdWJydDhRT09DUGxqUTJGTDFLY2EifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFRFSnVkUVkycFh4VkhQRTNnRDJFVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80VEVKdWRRWTJwWHhWSFBFM2dEMkVVIiwiaWQiOiI0VEVKdWRRWTJwWHhWSFBFM2dEMkVVIiwibmFtZSI6IkJsb2NCb3kgSkIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFRFSnVkUVkycFh4VkhQRTNnRDJFVSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxODM4MDksImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTUkMxMTgwMTAxMiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM1pZd1NERjlrblpJMFJWbEtSNFBIQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNaWXdTREY5a25aSTBSVmxLUjRQSEMiLCJpZCI6IjNaWXdTREY5a25aSTBSVmxLUjRQSEMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmFkIENvbXBhbnkgKGZlYXQuIEJsb2NCb3kgSkIpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNaWXdTREY5a25aSTBSVmxLUjRQSEMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRrMUVMZUpLVDFJU3lEdjhKaXZQcEIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGsxRUxlSktUMUlTeUR2OEppdlBwQiIsImlkIjoiNGsxRUxlSktUMUlTeUR2OEppdlBwQiIsIm5hbWUiOiJUaGUgUHJvZGlneSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0azFFTGVKS1QxSVN5RHY4Sml2UHBCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMXo0bjhwRTJwRmJmOWZZdnBxckxFViJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzF6NG44cEUycEZiZjlmWXZwcXJMRVYiLCJpZCI6IjF6NG44cEUycEZiZjlmWXZwcXJMRVYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNzQ5MmRkOTRjNTcxZjNlNjM3NjhmNDdiIn0seyJoZQ==", + "aWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNzQ5MmRkOTRjNTcxZjNlNjM3NjhmNDdiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE3NDkyZGQ5NGM1NzFmM2U2Mzc2OGY0N2IifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIERheSBJcyBNeSBFbmVteSAoQmFkIENvbXBhbnkgVUsgUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAxNi0xMC0wMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MXo0bjhwRTJwRmJmOWZZdnBxckxFViJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRrMUVMZUpLVDFJU3lEdjhKaXZQcEIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGsxRUxlSktUMUlTeUR2OEppdlBwQiIsImlkIjoiNGsxRUxlSktUMUlTeUR2OEppdlBwQiIsIm5hbWUiOiJUaGUgUHJvZGlneSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0azFFTGVKS1QxSVN5RHY4Sml2UHBCIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRBQWY2QkkxSUp4dmtxdjk4bURIaW4ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsImlkIjoiNEFBZjZCSTFJSnh2a3F2OThtREhpbiIsIm5hbWUiOiJCYWQgQ29tcGFueSBVSyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0QUFmNkJJMUlKeHZrcXY5OG1ESGluIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0Mjc1OCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQ0VKMTYwMDI3OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNE5IeDRjT2ZjZTJUMmVNVTZqMUtJUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzROSHg0Y09mY2UyVDJlTVU2ajFLSVEiLCJp", + "ZCI6IjROSHg0Y09mY2UyVDJlTVU2ajFLSVEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGhlIERheSBJcyBNeSBFbmVteSAtIEJhZCBDb21wYW55IFVLIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjROSHg0Y09mY2UyVDJlTVU2ajFLSVEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMjN6ZzNUY0F0V1F5N0o2dXBnYlVuaiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yM3pnM1RjQXRXUXk3SjZ1cGdiVW5qIiwiaWQiOiIyM3pnM1RjQXRXUXk3SjZ1cGdiVW5qIiwibmFtZSI6IlVTSEVSIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjIzemczVGNBdFdReTdKNnVwZ2JVbmoifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8xUk02TUd2NmJjbDZOckFHOFBHb1prIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMVJNNk1HdjZiY2w2TnJBRzhQR29aayIsImlkIjoiMVJNNk1HdjZiY2w2TnJBRzhQR29aayIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMzNjViM2ZiODAwYzE5ZjdmZjcyNjAyZGEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMzY1YjNmYjgwMGMxOWY3ZmY3MjYwMmRhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEzNjViM2ZiODAwYzE5ZjdmZjcyNjAyZGEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQ29uZmVzc2lvbnMgKEV4cGFuZGVkIEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAwNC0wMy0yMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjIxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFSTTZNR3Y2YmNsNk5yQUc4UEdvWmsifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yM3pnM1RjQXRXUXk3SjZ1cGdiVW5qIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzIzemczVGNBdFdReTdKNnVwZ2JVbmoiLCJpZCI6IjIzemczVGNBdFdReTdKNnVwZ2JVbmoiLA==", + "Im5hbWUiOiJVU0hFUiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyM3pnM1RjQXRXUXk3SjZ1cGdiVW5qIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI2MTgwMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTQVIxMDQwMDIxNCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNXJQelBBYU9VY2VTOEhpQWN1bGVneiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVyUHpQQWFPVWNlUzhIaUFjdWxlZ3oiLCJpZCI6IjVyUHpQQWFPVWNlUzhIaUFjdWxlZ3oiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmFkIEdpcmwiLCJ0cmFja19udW1iZXIiOjEyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVyUHpQQWFPVWNlUzhIaUFjdWxlZ3oifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Bad+Company+Bad+Company+UK&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Watercolour%22%20artist%3A%22Pendulum%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/3XtEGVx9uh7J46nBzEc1VS"},"href":"https://api.spotify.com/v1/albums/3XtEGVx9uh7J46nBzEc1VS","id":"3XtEGVx9uh7J46nBzEc1VS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27330f8e0f777376780c4077507"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0230f8e0f777376780c4077507"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485130f8e0f777376780c4077507"}],"is_playable":true,"name":"Immersion","release_date":"2010-05-21","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:3XtEGVx9uh7J46nBzEc1VS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":304106,"explicit":false,"external_ids":{"isrc":"GBAHT1000072"},"external_urls":{"spotify":"https://open.spotify.com/track/5ami95W9OOWQPwrBb5tud5"},"href":"https://api.spotify.com/v1/tracks/5ami95W9OOWQPwrBb5tud5","id":"5ami95W9OOWQPwrBb5tud5","is_local":false,"is_playable":true,"name":"Watercolour - Full Version; Single","track_number":3,"type":"track","uri":"spotify:track:5ami95W9OOWQPwrBb5tud5"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/6XeiGNROuqaYVRg7PkTUa3"},"href":"https://api.spotify.com/v1/albums/6XeiGNROuqaYVRg7PkTUa3","id":"6XeiGNROuqaYVRg7PkTUa3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273999d92113e74a5f3461e8a9a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02999d92113e74a5f3461e8a9a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851999d92113e74a5f3461e8a9a"}],"is_playable":true,"name":"Watercolour","release_date":"2010-04-30","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6XeiGNROuqaYVRg7PkTUa3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":304794,"explicit":false,"external_ids":{"isrc":"GBAHT1000072"},"external_urls":{"spotify":"https://open.spotify.com/track/6HNGXmc7A14zeeWTj4gzz8"},"href":"https://api.spotify.com/v1/tracks/6HNGXmc7A14zeeWTj4gzz8","id":"6HNGXmc7A14zeeWTj4gzz8","is_local":false,"is_playable":true,"name":"Watercolour - Full Version; Single","track_number":1,"type":"track","uri":"spotify:track:6HNGXmc7A14zeeWTj4gzz8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QZHRDBNh1GHDY6MCBULQp"},"href":"https://api.spotify.com/v1/albums/3QZHRDBNh1GHDY6MCBULQp","id":"3QZHRDBNh1GHDY6MCBULQp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734ac26e81ee22c927d09c18dc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024ac26e81ee22c927d09c18dc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514ac26e81ee22c927d09c18dc"}],"is_playable":true,"name":"The Reworks","release_date":"2018-06-29","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3QZHRDBNh1GHDY6MCBULQp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"},{"external_urls":{"spotify":"https://open.spotify.com/artist/41iVQ05he8SrfIWbZQ58N7"},"href":"https://api.spotify.com/v1/artists/41iVQ05he8SrfIWbZQ58N7","id":"41iVQ05he8SrfIWbZQ58N7","name":"Matrix & Futurebound","type":"artist","uri":"spotify:artist:41iVQ05he8SrfIWbZQ58N7"}],"disc_number":1,"duration_ms":328275,"explicit":false,"external_ids":{"isrc":"UKNKE1800009"},"external_urls":{"spotify":"https://open.spotify.com/track/2wO8GrXw4ta67wknKqaPTO"},"href":"https://api.spotify.com/v1/tracks/2wO8GrXw4ta67wknKqaPTO","id":"2wO8GrXw4ta67wknKqaPTO","is_local":false,"is_playable":true,"name":"Watercolour - Matrix & Futurebound Remix","track_number":9,"type":"track","uri":"spotify:track:2wO8GrXw4ta67wknKqaPTO"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1FNSyyXMnsXCg5WU2cFQ7F"},"href":"https://api.spotify.com/v1/albums/1FNSyyXMnsXCg5WU2cFQ7F","id":"1FNSyyXMnsXCg5WU2cFQ7F","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a51c6318a1e5118c5a3fd952"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a51c6318a1e5118c5a3fd952"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a51c6318a1e5118c5a3fd952"}],"is_playable":true,"name":"Modern Pop","release_date":"2020-03-13","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:1FNSyyXMnsXCg5WU2cFQ7F"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":207746,"explicit":false,"external_ids":{"isrc":"GBAHT1000071"},"external_urls":{"spotify":"https://open.spotify.com/track/4uzOFxt7vJpvXewOBgyCih"},"href":"https://api.spotify.com/v1/tracks/4uzOFxt7vJpvXewOBgyCih","id":"4uzOFxt7vJpvXewOBgyCih","is_local":false,"is_playable":true,"name":"Watercolour - Radio Edit","track_number":11,"type":"track","uri":"spotify:track:4uzOFxt7vJpvXewOBgyCih"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/3NSc1slK5K2i3FQhKHLY8L"},"href":"https://api.spotify.com/v1/albums/3NSc1slK5K2i3FQhKHLY8L","id":"3NSc1slK5K2i3FQhKHLY8L","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a1c8222986471088be02a09b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a1c8222986471088be02a09b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a1c8222986471088be02a09b"}],"is_playable":true,"name":"Temazos Dance","release_date":"2021-01-08","release_date_precision":"day","total_tracks":29,"type":"album","uri":"spotify:album:3NSc1slK5K2i3FQhKHLY8L"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":366680,"explicit":false,"external_ids":{"isrc":"GBAHT1000116"},"external_urls":{"spotify":"https://open.spotify.com/track/3P2RqavLZflYgDqfZSJbPZ"},"href":"https://api.spotify.com/v1/tracks/3P2RqavLZflYgDqfZSJbPZ","id":"3P2RqavLZflYgDqfZSJbPZ","is_local":false,"is_playable":true,"name":"Watercolour - Deadmau5 Remix","track_number":6,"type":"track","uri":"spotify:track:3P2RqavLZflYgDqfZSJbPZ"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/2aAqZXYXPSyuhLzv7nE5Pv"},"href":"https://api.spotify.com/v1/albums/2aAqZXYXPSyuhLzv7nE5Pv","id":"2aAqZXYXPSyuhLzv7nE5Pv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27362687845b8f59f217342c251"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0262687845b8f59f217342c251"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485162687845b8f59f217342c251"}],"is_playable":true,"name":"Synthesized","release_date":"2020-10-30","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:2aAqZXYXPSyuhLzv7nE5Pv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":207746,"explicit":false,"external_ids":{"isrc":"GBAHT1000071"},"external_urls":{"spotify":"https://open.spotify.com/track/6a6OOyfgG47xC6QksjFXf3"},"href":"https://api.spotify.com/v1/tracks/6a6OOyfgG47xC6QksjFXf3","id":"6a6OOyfgG47xC6QksjFXf3","is_local":false,"is_playable":true,"name":"Watercolour - Radio Edit","track_number":2,"type":"track","uri":"spotify:track:6a6OOyfgG47xC6QksjFXf3"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1gPgc56c3dRzq4f6q5n2Oz"},"href":"https://api.spotify.com/v1/albums/1gPgc56c3dRzq4f6q5n2Oz","id":"1gPgc56c3dRzq4f6q5n2Oz","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f314ba7ff14b6ac4e6e1594e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f314ba7ff14b6ac4e6e1594e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f314ba7ff14b6ac4e6e1594e"}],"is_playable":true,"name":"Definitive Dance Anthems","release_date":"2022-02-04","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:1gPgc56c3dRzq4f6q5n2Oz"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":207746,"explicit":false,"external_ids":{"isrc":"GBAHT1000071"},"external_urls":{"spotify":"https://open.spotify.com/track/1loI7rvXM5RsWxWvoDIz79"},"href":"https://api.spotify.com/v1/tracks/1loI7rvXM5RsWxWvoDIz79","id":"1loI7rvXM5RsWxWvoDIz79","is_local":false,"is_playable":true,"name":"Watercolour - Radio Edit","track_number":27,"type":"track","uri":"spotify:track:1loI7rvXM5RsWxWvoDIz79"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6d8bbJnaImv17um0p5eeCY"},"href":"https://api.spotify.com/v1/albums/6d8bbJnaImv17um0p5eeCY","id":"6d8bbJnaImv17um0p5eeCY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738a867ecfbaa9674a93d9f31e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028a867ecfbaa9674a93d9f31e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518a867ecfbaa9674a93d9f31e"}],"is_playable":true,"name":"Feeling Great!","release_date":"2024-06-04","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:6d8bbJnaImv17um0p5eeCY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":207746,"explicit":false,"external_ids":{"isrc":"GBAHT1000071"},"external_urls":{"spotify":"https://open.spotify.com/track/4KyPlTuzM1DOafLgGGNea1"},"href":"https://api.spotify.com/v1/tracks/4KyPlTuzM1DOafLgGGNea1","id":"4KyPlTuzM1DOafLgGGNea1","is_local":false,"is_playable":true,"name":"Watercolour - Radio Edit","track_number":22,"type":"track","uri":"spotify:track:4KyPlTuzM1DOafLgGGNea1"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0KUj2fGugDbUoTRuH8RQbZ"},"href":"https://api.spotify.com/v1/albums/0KUj2fGugDbUoTRuH8RQbZ","id":"0KUj2fGugDbUoTRuH8RQbZ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f0d7dbef908b3060e97b4045"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f0d7dbef908b3060e97b4045"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f0d7dbef908b3060e97b4045"}],"is_playable":true,"name":"Throwback Alternative","release_date":"2021-10-22","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:0KUj2fGugDbUoTRuH8RQbZ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":207746,"explicit":false,"external_ids":{"isrc":"GBAHT1000071"},"external_urls":{"spotify":"https://open.spotify.com/track/2n2VEjJgZ3cLPOYs3t1l13"},"href":"https://api.spotify.com/v1/tracks/2n2VEjJgZ3cLPOYs3t1l13","id":"2n2VEjJgZ3cLPOYs3t1l13","is_local":false,"is_playable":true,"name":"Watercolour - Radio Edit","track_number":18,"type":"track","uri":"spotify:track:2n2VEjJgZ3cLPOYs3t1l13"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMldhdGVyY29sb3VyJTIyJTIwYXJ0aXN0JTNBJTIyUGVuZHVsdW0lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjksIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM1h0RUdWeDl1aDdKNDZuQnpFYzFWUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNYdEVHVng5dWg3SjQ2bkJ6RWMxVlMiLCJpZCI6IjNYdEVHVng5dWg3SjQ2bkJ6RWMxVlMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMzBmOGUwZjc3NzM3Njc4MGM0MDc3NTA3In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjMwZjhlMGY3NzczNzY3ODBjNDA3NzUwNyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMzBmOGUwZjc3NzM3Njc4MGM0MDc3NTA3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkltbWVyc2lvbiIsInJlbGVhc2VfZGF0ZSI6IjIwMTAtMDUtMjEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozWHRFR1Z4OXVoN0o0Nm5CekVjMVZTIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwibg==", + "YW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDQxMDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIVDEwMDAwNzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzVhbWk5NVc5T09XUVB3ckJiNXR1ZDUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy81YW1pOTVXOU9PV1FQd3JCYjV0dWQ1IiwiaWQiOiI1YW1pOTVXOU9PV1FQd3JCYjV0dWQ1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhdGVyY29sb3VyIC0gRnVsbCBWZXJzaW9uOyBTaW5nbGUiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NWFtaTk1VzlPT1dRUHdyQmI1dHVkNSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwibmFtZSI6IlBlbmR1bHVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82WGVpR05ST3VxYVlWUmc3UGtUVWEzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNlhlaUdOUk91cWFZVlJnN1BrVFVhMyIsImlkIjoiNlhlaUdOUk91cWFZVlJnN1BrVFVhMyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM5OTlkOTIxMTNlNzRhNWYzNDYxZThhOWEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOTk5ZDkyMTEzZTc0YTVmMzQ2MWU4YTlhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE5OTlkOTIxMTNlNzRhNWYzNDYxZThhOWEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2F0ZXJjb2xvdXIiLCJyZWxlYXNlX2RhdGUiOiIyMDEwLTA0LTMwIiwicg==", + "ZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZYZWlHTlJPdXFhWVZSZzdQa1RVYTMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDQ3OTQsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIVDEwMDAwNzIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZITkdYbWM3QTE0emVlV1RqNGd6ejgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82SE5HWG1jN0ExNHplZVdUajRneno4IiwiaWQiOiI2SE5HWG1jN0ExNHplZVdUajRneno4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhdGVyY29sb3VyIC0gRnVsbCBWZXJzaW9uOyBTaW5nbGUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NkhOR1htYzdBMTR6ZWVXVGo0Z3p6OCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNRWkhSREJOaDFHSERZNk1DQlVMUXAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zUVpIUkRCTmgxR0hEWTZNQ0JVTFFwIiwiaWQiOiIzUVpIUkRCTmgxR0hEWTZNQ0JVTFFwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMA==", + "MDBiMjczNGFjMjZlODFlZTIyYzkyN2QwOWMxOGRjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjRhYzI2ZTgxZWUyMmM5MjdkMDljMThkYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNGFjMjZlODFlZTIyYzkyN2QwOWMxOGRjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRoZSBSZXdvcmtzIiwicmVsZWFzZV9kYXRlIjoiMjAxOC0wNi0yOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEzLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNRWkhSREJOaDFHSERZNk1DQlVMUXAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80MWlWUTA1aGU4U3JmSVdiWlE1OE43In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzQxaVZRMDVoZThTcmZJV2JaUTU4TjciLCJpZCI6IjQxaVZRMDVoZThTcmZJV2JaUTU4TjciLCJuYW1lIjoiTWF0cml4ICYgRnV0dXJlYm91bmQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NDFpVlEwNWhlOFNyZklXYlpRNThONyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMjgyNzUsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVS05LRTE4MDAwMDkifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJ3TzhHclh3NHRhNjd3a25LcWFQVE8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yd084R3JYdzR0YTY3d2tuS3FhUFRPIiwiaWQiOiIyd084R3JYdzR0YTY3d2tuS3FhUFRPIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhdGVyY29sb3VyIC0gTWF0cml4ICYgRnV0dXJlYm91bmQgUmVtaXgiLCJ0cmFja19udW1iZXIiOjksInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MndPOA==", + "R3JYdzR0YTY3d2tuS3FhUFRPIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFGTlN5eVhNbnNYQ2c1V1UyY0ZRN0YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xRk5TeXlYTW5zWENnNVdVMmNGUTdGIiwiaWQiOiIxRk5TeXlYTW5zWENnNVdVMmNGUTdGIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2E1MWM2MzE4YTFlNTExOGM1YTNmZDk1MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhNTFjNjMxOGExZTUxMThjNWEzZmQ5NTIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWE1MWM2MzE4YTFlNTExOGM1YTNmZDk1MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJNb2Rlcm4gUG9wIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0wMy0xMyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFGTlN5eVhNbnNYQ2c1V1UyY0ZRN0YifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDc3NDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIVDEwMDAwNzEifSwiZQ==", + "eHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNHV6T0Z4dDd2SnB2WGV3T0JneUNpaCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzR1ek9GeHQ3dkpwdlhld09CZ3lDaWgiLCJpZCI6IjR1ek9GeHQ3dkpwdlhld09CZ3lDaWgiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2F0ZXJjb2xvdXIgLSBSYWRpbyBFZGl0IiwidHJhY2tfbnVtYmVyIjoxMSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0dXpPRnh0N3ZKcHZYZXdPQmd5Q2loIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNOU2Mxc2xLNUsyaTNGUWhLSExZOEwifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zTlNjMXNsSzVLMmkzRlFoS0hMWThMIiwiaWQiOiIzTlNjMXNsSzVLMmkzRlFoS0hMWThMIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2ExYzgyMjI5ODY0NzEwODhiZTAyYTA5YiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhMWM4MjIyOTg2NDcxMDg4YmUwMmEwOWIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWExYzgyMjI5ODY0NzEwODhiZTAyYTA5YiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUZW1hem9zIERhbmNlIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wMS0wOCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNOU2Mxc2xLNUsyaTNGUWhLSExZOEwifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuYw==", + "b20vYXJ0aXN0LzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjM2NjY4MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhUMTAwMDExNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM1AyUnFhdkxaZmxZZ0RxZlpTSmJQWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNQMlJxYXZMWmZsWWdEcWZaU0piUFoiLCJpZCI6IjNQMlJxYXZMWmZsWWdEcWZaU0piUFoiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2F0ZXJjb2xvdXIgLSBEZWFkbWF1NSBSZW1peCIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazozUDJScWF2TFpmbFlnRHFmWlNKYlBaIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJhQXFaWFlYUFN5dWhMenY3bkU1UHYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yYUFxWlhZWFBTeXVoTHp2N25FNVB2IiwiaWQiOiIyYUFxWlhZWFBTeXVoTHp2N25FNVB2IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzYyNjg3ODQ1YjhmNTlmMjE3MzQyYzI1MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2MjY4Nzg0NWI4ZjU5ZjIxNzM0MmMyNTEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIg==", + "OiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjI2ODc4NDViOGY1OWYyMTczNDJjMjUxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN5bnRoZXNpemVkIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0xMC0zMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJhQXFaWFlYUFN5dWhMenY3bkU1UHYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDc3NDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIVDEwMDAwNzEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZhNk9PeWZnRzQ3eEM2UWtzakZYZjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82YTZPT3lmZ0c0N3hDNlFrc2pGWGYzIiwiaWQiOiI2YTZPT3lmZ0c0N3hDNlFrc2pGWGYzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhdGVyY29sb3VyIC0gUmFkaW8gRWRpdCIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2YTZPT3lmZ0c0N3hDNlFrc2pGWGYzIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzFnUGdjNTZjM2RSenE0ZjZxNW4yT3oifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuYw==", + "b20vdjEvYWxidW1zLzFnUGdjNTZjM2RSenE0ZjZxNW4yT3oiLCJpZCI6IjFnUGdjNTZjM2RSenE0ZjZxNW4yT3oiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjMxNGJhN2ZmMTRiNmFjNGU2ZTE1OTRlIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmYzMTRiYTdmZjE0YjZhYzRlNmUxNTk0ZSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjMxNGJhN2ZmMTRiNmFjNGU2ZTE1OTRlIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRlZmluaXRpdmUgRGFuY2UgQW50aGVtcyIsInJlbGVhc2VfZGF0ZSI6IjIwMjItMDItMDQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxZ1BnYzU2YzNkUnpxNGY2cTVuMk96In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwibmFtZSI6IlBlbmR1bHVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjA3NzQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFQxMDAwMDcxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xbG9JN3J2WE01UnNXeFd2b0RJejc5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMWxvSTdydlhNNVJzV3hXdm9ESXo3OSIsImlkIjoiMWxvSTdydlhNNVJzV3hXdm9ESXo3OSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYXRlcmNvbG91ciAtIFJhZGlvIEVkaXQiLCJ0cmFja19udW1iZXIiOjI3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjFsb0k3cnZYTTVSc1d4V3ZvREl6NzkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5Zg==", + "UVdKVDZuWGFmTFBacXhlOU9mIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJpZCI6IjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YiLCJuYW1lIjoiVmFyaW91cyBBcnRpc3RzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82ZDhiYkpuYUltdjE3dW0wcDVlZUNZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNmQ4YmJKbmFJbXYxN3VtMHA1ZWVDWSIsImlkIjoiNmQ4YmJKbmFJbXYxN3VtMHA1ZWVDWSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4YTg2N2VjZmJhYTk2NzRhOTNkOWYzMWUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOGE4NjdlY2ZiYWE5Njc0YTkzZDlmMzFlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE4YTg2N2VjZmJhYTk2NzRhOTNkOWYzMWUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmVlbGluZyBHcmVhdCEiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTA2LTA0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NmQ4YmJKbmFJbXYxN3VtMHA1ZWVDWSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIwNzc0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhUMTAwMDA3MSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNEt5UGxUdXpNMURPYWZMZ0dHTmVhMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRLeVBsVA==", + "dXpNMURPYWZMZ0dHTmVhMSIsImlkIjoiNEt5UGxUdXpNMURPYWZMZ0dHTmVhMSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXYXRlcmNvbG91ciAtIFJhZGlvIEVkaXQiLCJ0cmFja19udW1iZXIiOjIyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRLeVBsVHV6TTFET2FmTGdHR05lYTEifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMEtVajJmR3VnRGJVb1RSdUg4UlFiWiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBLVWoyZkd1Z0RiVW9UUnVIOFJRYloiLCJpZCI6IjBLVWoyZkd1Z0RiVW9UUnVIOFJRYloiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjBkN2RiZWY5MDhiMzA2MGU5N2I0MDQ1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmYwZDdkYmVmOTA4YjMwNjBlOTdiNDA0NSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjBkN2RiZWY5MDhiMzA2MGU5N2I0MDQ1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRocm93YmFjayBBbHRlcm5hdGl2ZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMTAtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyOCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowS1VqMmZHdWdEYlVvVFJ1SDhSUWJaIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWQ==", + "WWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMDc3NDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIVDEwMDAwNzEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJuMlZFakpnWjNjTFBPWXMzdDFsMTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8ybjJWRWpKZ1ozY0xQT1lzM3QxbDEzIiwiaWQiOiIybjJWRWpKZ1ozY0xQT1lzM3QxbDEzIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IldhdGVyY29sb3VyIC0gUmFkaW8gRWRpdCIsInRyYWNrX251bWJlciI6MTgsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6Mm4yVkVqSmdaM2NMUE9ZczN0MWwxMyJ9XX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Watercolour%22+artist%3A%22Pendulum%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Timewarp%20Bad%20Company%20UK&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LTnf5KB3uMpHKgx29u62C"},"href":"https://api.spotify.com/v1/artists/4LTnf5KB3uMpHKgx29u62C","id":"4LTnf5KB3uMpHKgx29u62C","name":"Rocks of Mars","type":"artist","uri":"spotify:artist:4LTnf5KB3uMpHKgx29u62C"}],"external_urls":{"spotify":"https://open.spotify.com/album/6960d1qaZkm8gtvf9MEZIt"},"href":"https://api.spotify.com/v1/albums/6960d1qaZkm8gtvf9MEZIt","id":"6960d1qaZkm8gtvf9MEZIt","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b2bb47bed3df690f6e504193"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b2bb47bed3df690f6e504193"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b2bb47bed3df690f6e504193"}],"is_playable":true,"name":"Bad Company","release_date":"2025-12-15","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:6960d1qaZkm8gtvf9MEZIt"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4LTnf5KB3uMpHKgx29u62C"},"href":"https://api.spotify.com/v1/artists/4LTnf5KB3uMpHKgx29u62C","id":"4LTnf5KB3uMpHKgx29u62C","name":"Rocks of Mars","type":"artist","uri":"spotify:artist:4LTnf5KB3uMpHKgx29u62C"}],"disc_number":1,"duration_ms":102413,"explicit":false,"external_ids":{"isrc":"CBECC2401733"},"external_urls":{"spotify":"https://open.spotify.com/track/3l0gUJeAzXmgk0HlmuqRII"},"href":"https://api.spotify.com/v1/tracks/3l0gUJeAzXmgk0HlmuqRII","id":"3l0gUJeAzXmgk0HlmuqRII","is_local":false,"is_playable":true,"name":"Bad Company","track_number":1,"type":"track","uri":"spotify:track:3l0gUJeAzXmgk0HlmuqRII"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2LIk90788K0zvyj2JJVwkJ"},"href":"https://api.spotify.com/v1/artists/2LIk90788K0zvyj2JJVwkJ","id":"2LIk90788K0zvyj2JJVwkJ","name":"Jack Harlow","type":"artist","uri":"spotify:artist:2LIk90788K0zvyj2JJVwkJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/5g2INX6dnMIJG0xKygXwF3"},"href":"https://api.spotify.com/v1/albums/5g2INX6dnMIJG0xKygXwF3","id":"5g2INX6dnMIJG0xKygXwF3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c97899926c43255b4238dfa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c97899926c43255b4238dfa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c97899926c43255b4238dfa"}],"is_playable":true,"name":"Thats What They All Say","release_date":"2020-12-11","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:5g2INX6dnMIJG0xKygXwF3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2LIk90788K0zvyj2JJVwkJ"},"href":"https://api.spotify.com/v1/artists/2LIk90788K0zvyj2JJVwkJ","id":"2LIk90788K0zvyj2JJVwkJ","name":"Jack Harlow","type":"artist","uri":"spotify:artist:2LIk90788K0zvyj2JJVwkJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2jku7tDXc6XoB6MO2hFuqg"},"href":"https://api.spotify.com/v1/artists/2jku7tDXc6XoB6MO2hFuqg","id":"2jku7tDXc6XoB6MO2hFuqg","name":"Tory Lanez","type":"artist","uri":"spotify:artist:2jku7tDXc6XoB6MO2hFuqg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4r63FhuTkUYltbVAg5TQnk"},"href":"https://api.spotify.com/v1/artists/4r63FhuTkUYltbVAg5TQnk","id":"4r63FhuTkUYltbVAg5TQnk","name":"DaBaby","type":"artist","uri":"spotify:artist:4r63FhuTkUYltbVAg5TQnk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/55Aa2cqylxrFIXC767Z865"},"href":"https://api.spotify.com/v1/artists/55Aa2cqylxrFIXC767Z865","id":"55Aa2cqylxrFIXC767Z865","name":"Lil Wayne","type":"artist","uri":"spotify:artist:55Aa2cqylxrFIXC767Z865"}],"disc_number":1,"duration_ms":227478,"explicit":true,"external_ids":{"isrc":"USAT22007702"},"external_urls":{"spotify":"https://open.spotify.com/track/0ZLuW8uOXdFNWcI40C0OC2"},"href":"https://api.spotify.com/v1/tracks/0ZLuW8uOXdFNWcI40C0OC2","id":"0ZLuW8uOXdFNWcI40C0OC2","is_local":false,"is_playable":true,"name":"Whats Poppin (feat. DaBaby, Tory Lanez & Lil Wayne) [Remix] - Bonus Track","track_number":15,"type":"track","uri":"spotify:track:0ZLuW8uOXdFNWcI40C0OC2"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2LIk90788K0zvyj2JJVwkJ"},"href":"https://api.spotify.com/v1/artists/2LIk90788K0zvyj2JJVwkJ","id":"2LIk90788K0zvyj2JJVwkJ","name":"Jack Harlow","type":"artist","uri":"spotify:artist:2LIk90788K0zvyj2JJVwkJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/6VPorwjxRiaPK4fdGsWz71"},"href":"https://api.spotify.com/v1/albums/6VPorwjxRiaPK4fdGsWz71","id":"6VPorwjxRiaPK4fdGsWz71","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b90bcd48e610273aa937d061"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b90bcd48e610273aa937d061"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b90bcd48e610273aa937d061"}],"is_playable":true,"name":"Thats What They All Say","release_date":"2020-12-10","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6VPorwjxRiaPK4fdGsWz71"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2LIk90788K0zvyj2JJVwkJ"},"href":"https://api.spotify.com/v1/artists/2LIk90788K0zvyj2JJVwkJ","id":"2LIk90788K0zvyj2JJVwkJ","name":"Jack Harlow","type":"artist","uri":"spotify:artist:2LIk90788K0zvyj2JJVwkJ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2jku7tDXc6XoB6MO2hFuqg"},"href":"https://api.spotify.com/v1/artists/2jku7tDXc6XoB6MO2hFuqg","id":"2jku7tDXc6XoB6MO2hFuqg","name":"Tory Lanez","type":"artist","uri":"spotify:artist:2jku7tDXc6XoB6MO2hFuqg"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4r63FhuTkUYltbVAg5TQnk"},"href":"https://api.spotify.com/v1/artists/4r63FhuTkUYltbVAg5TQnk","id":"4r63FhuTkUYltbVAg5TQnk","name":"DaBaby","type":"artist","uri":"spotify:artist:4r63FhuTkUYltbVAg5TQnk"},{"external_urls":{"spotify":"https://open.spotify.com/artist/55Aa2cqylxrFIXC767Z865"},"href":"https://api.spotify.com/v1/artists/55Aa2cqylxrFIXC767Z865","id":"55Aa2cqylxrFIXC767Z865","name":"Lil Wayne","type":"artist","uri":"spotify:artist:55Aa2cqylxrFIXC767Z865"}],"disc_number":1,"duration_ms":227478,"explicit":false,"external_ids":{"isrc":"USAT22007727"},"external_urls":{"spotify":"https://open.spotify.com/track/1EhJ3rFZE9hAc2vu9Z2hgL"},"href":"https://api.spotify.com/v1/tracks/1EhJ3rFZE9hAc2vu9Z2hgL","id":"1EhJ3rFZE9hAc2vu9Z2hgL","is_local":false,"is_playable":true,"name":"Whats Poppin (feat. DaBaby, Tory Lanez & Lil Wayne) [Remix] - Bonus Track","track_number":15,"type":"track","uri":"spotify:track:1EhJ3rFZE9hAc2vu9Z2hgL"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AUnzIimTh9BMuOMOOs6Cy"},"href":"https://api.spotify.com/v1/artists/2AUnzIimTh9BMuOMOOs6Cy","id":"2AUnzIimTh9BMuOMOOs6Cy","name":"Gassper Qu","type":"artist","uri":"spotify:artist:2AUnzIimTh9BMuOMOOs6Cy"}],"external_urls":{"spotify":"https://open.spotify.com/album/3kHVHp43a7dJz3VCxdxgzu"},"href":"https://api.spotify.com/v1/albums/3kHVHp43a7dJz3VCxdxgzu","id":"3kHVHp43a7dJz3VCxdxgzu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27314aef5698dba08edf9724d18"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0214aef5698dba08edf9724d18"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485114aef5698dba08edf9724d18"}],"is_playable":true,"name":"Time Away","release_date":"2023-12-22","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3kHVHp43a7dJz3VCxdxgzu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2AUnzIimTh9BMuOMOOs6Cy"},"href":"https://api.spotify.com/v1/artists/2AUnzIimTh9BMuOMOOs6Cy","id":"2AUnzIimTh9BMuOMOOs6Cy","name":"Gassper Qu","type":"artist","uri":"spotify:artist:2AUnzIimTh9BMuOMOOs6Cy"}],"disc_number":1,"duration_ms":68036,"explicit":false,"external_ids":{"isrc":"QZZ972368477"},"external_urls":{"spotify":"https://open.spotify.com/track/0Sx1oCoXw7d39antrAlCnS"},"href":"https://api.spotify.com/v1/tracks/0Sx1oCoXw7d39antrAlCnS","id":"0Sx1oCoXw7d39antrAlCnS","is_local":false,"is_playable":true,"name":"Time Away","track_number":1,"type":"track","uri":"spotify:track:0Sx1oCoXw7d39antrAlCnS"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7h8KuHV4Ny8tX2aV0Y15xp"},"href":"https://api.spotify.com/v1/artists/7h8KuHV4Ny8tX2aV0Y15xp","id":"7h8KuHV4Ny8tX2aV0Y15xp","name":"The Sales Rapper","type":"artist","uri":"spotify:artist:7h8KuHV4Ny8tX2aV0Y15xp"}],"external_urls":{"spotify":"https://open.spotify.com/album/0oJNpZSm8mt99meWMuBN6d"},"href":"https://api.spotify.com/v1/albums/0oJNpZSm8mt99meWMuBN6d","id":"0oJNpZSm8mt99meWMuBN6d","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736d0e0b810dfb2de918a400f3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026d0e0b810dfb2de918a400f3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516d0e0b810dfb2de918a400f3"}],"is_playable":true,"name":"Recession Session","release_date":"2023-05-03","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:0oJNpZSm8mt99meWMuBN6d"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7h8KuHV4Ny8tX2aV0Y15xp"},"href":"https://api.spotify.com/v1/artists/7h8KuHV4Ny8tX2aV0Y15xp","id":"7h8KuHV4Ny8tX2aV0Y15xp","name":"The Sales Rapper","type":"artist","uri":"spotify:artist:7h8KuHV4Ny8tX2aV0Y15xp"}],"disc_number":1,"duration_ms":199620,"explicit":false,"external_ids":{"isrc":"QZHNA2340693"},"external_urls":{"spotify":"https://open.spotify.com/track/55BxluyfGfeLtvSMF57PJb"},"href":"https://api.spotify.com/v1/tracks/55BxluyfGfeLtvSMF57PJb","id":"55BxluyfGfeLtvSMF57PJb","is_local":false,"is_playable":true,"name":"Recession","track_number":1,"type":"track","uri":"spotify:track:55BxluyfGfeLtvSMF57PJb"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1GklwM8HTMYn5VvWrAlav9"},"href":"https://api.spotify.com/v1/artists/1GklwM8HTMYn5VvWrAlav9","id":"1GklwM8HTMYn5VvWrAlav9","name":"D'Dan","type":"artist","uri":"spotify:artist:1GklwM8HTMYn5VvWrAlav9"}],"external_urls":{"spotify":"https://open.spotify.com/album/6rAHlyv0k6YaMGtdyPeuq1"},"href":"https://api.spotify.com/v1/albums/6rAHlyv0k6YaMGtdyPeuq1","id":"6rAHlyv0k6YaMGtdyPeuq1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f482a470cd9a77d9afd988c7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f482a470cd9a77d9afd988c7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f482a470cd9a77d9afd988c7"}],"is_playable":true,"name":"Deya, Vol. 1","release_date":"2023-01-27","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:6rAHlyv0k6YaMGtdyPeuq1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1GklwM8HTMYn5VvWrAlav9"},"href":"https://api.spotify.com/v1/artists/1GklwM8HTMYn5VvWrAlav9","id":"1GklwM8HTMYn5VvWrAlav9","name":"D'Dan","type":"artist","uri":"spotify:artist:1GklwM8HTMYn5VvWrAlav9"}],"disc_number":1,"duration_ms":194000,"explicit":true,"external_ids":{"isrc":"QZFZ42341698"},"external_urls":{"spotify":"https://open.spotify.com/track/2dhJ23LXscbVrnzFTSqOAa"},"href":"https://api.spotify.com/v1/tracks/2dhJ23LXscbVrnzFTSqOAa","id":"2dhJ23LXscbVrnzFTSqOAa","is_local":false,"is_playable":true,"name":"Just Do It","track_number":5,"type":"track","uri":"spotify:track:2dhJ23LXscbVrnzFTSqOAa"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7h8KuHV4Ny8tX2aV0Y15xp"},"href":"https://api.spotify.com/v1/artists/7h8KuHV4Ny8tX2aV0Y15xp","id":"7h8KuHV4Ny8tX2aV0Y15xp","name":"The Sales Rapper","type":"artist","uri":"spotify:artist:7h8KuHV4Ny8tX2aV0Y15xp"}],"external_urls":{"spotify":"https://open.spotify.com/album/2R7hJWb9Y6FqU8iuPuEA1s"},"href":"https://api.spotify.com/v1/albums/2R7hJWb9Y6FqU8iuPuEA1s","id":"2R7hJWb9Y6FqU8iuPuEA1s","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e5950d35831d8850cb58dc9e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e5950d35831d8850cb58dc9e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e5950d35831d8850cb58dc9e"}],"is_playable":true,"name":"Recession","release_date":"2023-04-25","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2R7hJWb9Y6FqU8iuPuEA1s"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7h8KuHV4Ny8tX2aV0Y15xp"},"href":"https://api.spotify.com/v1/artists/7h8KuHV4Ny8tX2aV0Y15xp","id":"7h8KuHV4Ny8tX2aV0Y15xp","name":"The Sales Rapper","type":"artist","uri":"spotify:artist:7h8KuHV4Ny8tX2aV0Y15xp"}],"disc_number":1,"duration_ms":199620,"explicit":true,"external_ids":{"isrc":"QZHNA2340693"},"external_urls":{"spotify":"https://open.spotify.com/track/0jHithee61gBzXvQsiJSIW"},"href":"https://api.spotify.com/v1/tracks/0jHithee61gBzXvQsiJSIW","id":"0jHithee61gBzXvQsiJSIW","is_local":false,"is_playable":true,"name":"Recession","track_number":1,"type":"track","uri":"spotify:track:0jHithee61gBzXvQsiJSIW"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4sm3IxXQOqsMSRq4BdsZ2f"},"href":"https://api.spotify.com/v1/artists/4sm3IxXQOqsMSRq4BdsZ2f","id":"4sm3IxXQOqsMSRq4BdsZ2f","name":"Jason Voorheezy","type":"artist","uri":"spotify:artist:4sm3IxXQOqsMSRq4BdsZ2f"}],"external_urls":{"spotify":"https://open.spotify.com/album/58POL7N1ZYVbrGsiFj9VST"},"href":"https://api.spotify.com/v1/albums/58POL7N1ZYVbrGsiFj9VST","id":"58POL7N1ZYVbrGsiFj9VST","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735e999579a59bd66d9e5e1a43"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025e999579a59bd66d9e5e1a43"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515e999579a59bd66d9e5e1a43"}],"is_playable":true,"name":"DIMENSIONAL BREACH","release_date":"2023-12-25","release_date_precision":"day","total_tracks":23,"type":"album","uri":"spotify:album:58POL7N1ZYVbrGsiFj9VST"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4sm3IxXQOqsMSRq4BdsZ2f"},"href":"https://api.spotify.com/v1/artists/4sm3IxXQOqsMSRq4BdsZ2f","id":"4sm3IxXQOqsMSRq4BdsZ2f","name":"Jason Voorheezy","type":"artist","uri":"spotify:artist:4sm3IxXQOqsMSRq4BdsZ2f"}],"disc_number":1,"duration_ms":1248466,"explicit":true,"external_ids":{"isrc":"QZVEM2386846"},"external_urls":{"spotify":"https://open.spotify.com/track/4GL1NRmdc8jaFtZ0UnxDu2"},"href":"https://api.spotify.com/v1/tracks/4GL1NRmdc8jaFtZ0UnxDu2","id":"4GL1NRmdc8jaFtZ0UnxDu2","is_local":false,"is_playable":true,"name":"20 MINUTE FREESTYLE","track_number":15,"type":"track","uri":"spotify:track:4GL1NRmdc8jaFtZ0UnxDu2"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0tLuInyvDe42qY57KDsqTz"},"href":"https://api.spotify.com/v1/artists/0tLuInyvDe42qY57KDsqTz","id":"0tLuInyvDe42qY57KDsqTz","name":"Wavey","type":"artist","uri":"spotify:artist:0tLuInyvDe42qY57KDsqTz"}],"external_urls":{"spotify":"https://open.spotify.com/album/2YrmNL9GzyBwCD0rvyTx6O"},"href":"https://api.spotify.com/v1/albums/2YrmNL9GzyBwCD0rvyTx6O","id":"2YrmNL9GzyBwCD0rvyTx6O","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738b8de336ef691845b1adf058"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028b8de336ef691845b1adf058"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518b8de336ef691845b1adf058"}],"is_playable":true,"name":"Time","release_date":"2024-06-14","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:2YrmNL9GzyBwCD0rvyTx6O"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0tLuInyvDe42qY57KDsqTz"},"href":"https://api.spotify.com/v1/artists/0tLuInyvDe42qY57KDsqTz","id":"0tLuInyvDe42qY57KDsqTz","name":"Wavey","type":"artist","uri":"spotify:artist:0tLuInyvDe42qY57KDsqTz"}],"disc_number":1,"duration_ms":157894,"explicit":false,"external_ids":{"isrc":"GBKQU2449119"},"external_urls":{"spotify":"https://open.spotify.com/track/0UaR1Ex4DNEbd1z7hHhHEl"},"href":"https://api.spotify.com/v1/tracks/0UaR1Ex4DNEbd1z7hHhHEl","id":"0UaR1Ex4DNEbd1z7hHhHEl","is_local":false,"is_playable":true,"name":"Time","track_number":1,"type":"track","uri":"spotify:track:0UaR1Ex4DNEbd1z7hHhHEl"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1UaW1ld2FycCUyMEJhZCUyMENvbXBhbnklMjBVSyZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRMVG5mNUtCM3VNcEhLZ3gyOXU2MkMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNExUbmY1S0IzdU1wSEtneDI5dTYyQyIsImlkIjoiNExUbmY1S0IzdU1wSEtneDI5dTYyQyIsIm5hbWUiOiJSb2NrcyBvZiBNYXJzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRMVG5mNUtCM3VNcEhLZ3gyOXU2MkMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82OTYwZDFxYVprbThndHZmOU1FWkl0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNjk2MGQxcWFaa204Z3R2ZjlNRVpJdCIsImlkIjoiNjk2MGQxcWFaa204Z3R2ZjlNRVpJdCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiMmJiNDdiZWQzZGY2OTBmNmU1MDQxOTMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjJiYjQ3YmVkM2RmNjkwZjZlNTA0MTkzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiMmJiNDdiZWQzZGY2OTBmNmU1MDQxOTMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmFkIENvbXBhbnkiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTEyLTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2OTYwZDFxYVprbThndHZmOU1FWkl0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNExUbmY1S0IzdU1wSEtneDI5dTYyQyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80TFRuZjVLQjN1TXBIS2d4Mjl1NjJDIiwiaWQiOiI0TFRuZjVLQjN1TXBIS2d4Mjl1NjJDIiwibmFtZSI6IlJvY2tzIG9mIA==", + "TWFycyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0TFRuZjVLQjN1TXBIS2d4Mjl1NjJDIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEwMjQxMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkNCRUNDMjQwMTczMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svM2wwZ1VKZUF6WG1nazBIbG11cVJJSSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzNsMGdVSmVBelhtZ2swSGxtdXFSSUkiLCJpZCI6IjNsMGdVSmVBelhtZ2swSGxtdXFSSUkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQmFkIENvbXBhbnkiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2wwZ1VKZUF6WG1nazBIbG11cVJJSSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTElrOTA3ODhLMHp2eWoySkpWd2tKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJMSWs5MDc4OEswenZ5ajJKSlZ3a0oiLCJpZCI6IjJMSWs5MDc4OEswenZ5ajJKSlZ3a0oiLCJuYW1lIjoiSmFjayBIYXJsb3ciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkxJazkwNzg4SzB6dnlqMkpKVndrSiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVnMklOWDZkbk1JSkcweEt5Z1h3RjMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81ZzJJTlg2ZG5NSUpHMHhLeWdYd0YzIiwiaWQiOiI1ZzJJTlg2ZG5NSUpHMHhLeWdYd0YzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZjOTc4OTk5MjZjNDMyNTViNDIzOGRmYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2Yzk3ODk5OTI2YzQzMjU1YjQyMzhkZmEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZjOTc4OTk5MjZjNDMyNTViNDIzOGRmYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGF0cyBXaGF0IFRoZXkgQWxsIFNheSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTItMTEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaQ==", + "b24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjVnMklOWDZkbk1JSkcweEt5Z1h3RjMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTElrOTA3ODhLMHp2eWoySkpWd2tKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJMSWs5MDc4OEswenZ5ajJKSlZ3a0oiLCJpZCI6IjJMSWs5MDc4OEswenZ5ajJKSlZ3a0oiLCJuYW1lIjoiSmFjayBIYXJsb3ciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkxJazkwNzg4SzB6dnlqMkpKVndrSiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yamt1N3REWGM2WG9CNk1PMmhGdXFnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJqa3U3dERYYzZYb0I2TU8yaEZ1cWciLCJpZCI6IjJqa3U3dERYYzZYb0I2TU8yaEZ1cWciLCJuYW1lIjoiVG9yeSBMYW5leiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyamt1N3REWGM2WG9CNk1PMmhGdXFnIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRyNjNGaHVUa1VZbHRiVkFnNVRRbmsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHI2M0ZodVRrVVlsdGJWQWc1VFFuayIsImlkIjoiNHI2M0ZodVRrVVlsdGJWQWc1VFFuayIsIm5hbWUiOiJEYUJhYnkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHI2M0ZodVRrVVlsdGJWQWc1VFFuayJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81NUFhMmNxeWx4ckZJWEM3NjdaODY1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU1QWEyY3F5bHhyRklYQzc2N1o4NjUiLCJpZCI6IjU1QWEyY3F5bHhyRklYQzc2N1o4NjUiLCJuYW1lIjoiTGlsIFdheW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU1QWEyY3F5bHhyRklYQzc2N1o4NjUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI3NDc4LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0FUMjIwMDc3MDIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBaTHVXOHVPWGRGTldjSTQwQzBPQzIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcw==", + "LzBaTHVXOHVPWGRGTldjSTQwQzBPQzIiLCJpZCI6IjBaTHVXOHVPWGRGTldjSTQwQzBPQzIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiV2hhdHMgUG9wcGluIChmZWF0LiBEYUJhYnksIFRvcnkgTGFuZXogJiBMaWwgV2F5bmUpIFtSZW1peF0gLSBCb251cyBUcmFjayIsInRyYWNrX251bWJlciI6MTUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MFpMdVc4dU9YZEZOV2NJNDBDME9DMiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yTElrOTA3ODhLMHp2eWoySkpWd2tKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJMSWs5MDc4OEswenZ5ajJKSlZ3a0oiLCJpZCI6IjJMSWs5MDc4OEswenZ5ajJKSlZ3a0oiLCJuYW1lIjoiSmFjayBIYXJsb3ciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkxJazkwNzg4SzB6dnlqMkpKVndrSiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZWUG9yd2p4UmlhUEs0ZmRHc1d6NzEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82VlBvcndqeFJpYVBLNGZkR3NXejcxIiwiaWQiOiI2VlBvcndqeFJpYVBLNGZkR3NXejcxIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I5MGJjZDQ4ZTYxMDI3M2FhOTM3ZDA2MSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiOTBiY2Q0OGU2MTAyNzNhYTkzN2QwNjEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI5MGJjZDQ4ZTYxMDI3M2FhOTM3ZDA2MSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGF0cyBXaGF0IFRoZXkgQWxsIFNheSIsInJlbGVhc2VfZGF0ZSI6IjIwMjAtMTItMTAiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2VlBvcndqeFJpYVBLNGZkR3NXejcxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMkxJazkwNzg4SzB6dnlqMkpKVndrSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aQ==", + "c3RzLzJMSWs5MDc4OEswenZ5ajJKSlZ3a0oiLCJpZCI6IjJMSWs5MDc4OEswenZ5ajJKSlZ3a0oiLCJuYW1lIjoiSmFjayBIYXJsb3ciLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MkxJazkwNzg4SzB6dnlqMkpKVndrSiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yamt1N3REWGM2WG9CNk1PMmhGdXFnIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzJqa3U3dERYYzZYb0I2TU8yaEZ1cWciLCJpZCI6IjJqa3U3dERYYzZYb0I2TU8yaEZ1cWciLCJuYW1lIjoiVG9yeSBMYW5leiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyamt1N3REWGM2WG9CNk1PMmhGdXFnIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRyNjNGaHVUa1VZbHRiVkFnNVRRbmsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHI2M0ZodVRrVVlsdGJWQWc1VFFuayIsImlkIjoiNHI2M0ZodVRrVVlsdGJWQWc1VFFuayIsIm5hbWUiOiJEYUJhYnkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHI2M0ZodVRrVVlsdGJWQWc1VFFuayJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81NUFhMmNxeWx4ckZJWEM3NjdaODY1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzU1QWEyY3F5bHhyRklYQzc2N1o4NjUiLCJpZCI6IjU1QWEyY3F5bHhyRklYQzc2N1o4NjUiLCJuYW1lIjoiTGlsIFdheW5lIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjU1QWEyY3F5bHhyRklYQzc2N1o4NjUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI3NDc4LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBVDIyMDA3NzI3In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8xRWhKM3JGWkU5aEFjMnZ1OVoyaGdMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMUVoSjNyRlpFOWhBYzJ2dTlaMmhnTCIsImlkIjoiMUVoSjNyRlpFOWhBYzJ2dTlaMmhnTCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJXaGF0cyBQb3BwaW4gKGZlYXQuIERhQmFieSwgVG9yeSBMYW5leiAmIExpbCBXYXluZSkgW1JlbWl4XSAtIEJvbnVzIFRyYWNrIiwidHJhY2tfbnVtYmVyIjoxNSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cg==", + "YWNrOjFFaEozckZaRTloQWMydnU5WjJoZ0wifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJBVW56SWltVGg5Qk11T01PT3M2Q3kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkFVbnpJaW1UaDlCTXVPTU9PczZDeSIsImlkIjoiMkFVbnpJaW1UaDlCTXVPTU9PczZDeSIsIm5hbWUiOiJHYXNzcGVyIFF1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVW56SWltVGg5Qk11T01PT3M2Q3kifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8za0hWSHA0M2E3ZEp6M1ZDeGR4Z3p1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2tIVkhwNDNhN2RKejNWQ3hkeGd6dSIsImlkIjoiM2tIVkhwNDNhN2RKejNWQ3hkeGd6dSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNGFlZjU2OThkYmEwOGVkZjk3MjRkMTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTRhZWY1Njk4ZGJhMDhlZGY5NzI0ZDE4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExNGFlZjU2OThkYmEwOGVkZjk3MjRkMTgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGltZSBBd2F5IiwicmVsZWFzZV9kYXRlIjoiMjAyMy0xMi0yMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2tIVkhwNDNhN2RKejNWQ3hkeGd6dSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzJBVW56SWltVGg5Qk11T01PT3M2Q3kifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMkFVbnpJaW1UaDlCTXVPTU9PczZDeSIsImlkIjoiMkFVbnpJaW1UaDlCTXVPTU9PczZDeSIsIm5hbWUiOiJHYXNzcGVyIFF1IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjJBVW56SWltVGg5Qk11T01PT3M2Q3kifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6NjgwMzYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWlo5NzIzNjg0NzcifSwiZXh0ZQ==", + "cm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMFN4MW9Db1h3N2QzOWFudHJBbENuUyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBTeDFvQ29YdzdkMzlhbnRyQWxDblMiLCJpZCI6IjBTeDFvQ29YdzdkMzlhbnRyQWxDblMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGltZSBBd2F5IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBTeDFvQ29YdzdkMzlhbnRyQWxDblMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN2g4S3VIVjROeTh0WDJhVjBZMTV4cCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83aDhLdUhWNE55OHRYMmFWMFkxNXhwIiwiaWQiOiI3aDhLdUhWNE55OHRYMmFWMFkxNXhwIiwibmFtZSI6IlRoZSBTYWxlcyBSYXBwZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N2g4S3VIVjROeTh0WDJhVjBZMTV4cCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBvSk5wWlNtOG10OTltZVdNdUJONmQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wb0pOcFpTbThtdDk5bWVXTXVCTjZkIiwiaWQiOiIwb0pOcFpTbThtdDk5bWVXTXVCTjZkIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzZkMGUwYjgxMGRmYjJkZTkxOGE0MDBmMyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI2ZDBlMGI4MTBkZmIyZGU5MThhNDAwZjMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTZkMGUwYjgxMGRmYjJkZTkxOGE0MDBmMyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWNlc3Npb24gU2Vzc2lvbiIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDUtMDMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBvSk5wWlNtOG10OTltZVdNdUJONmQifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83aDhLdUhWNE55OA==", + "dFgyYVYwWTE1eHAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2g4S3VIVjROeTh0WDJhVjBZMTV4cCIsImlkIjoiN2g4S3VIVjROeTh0WDJhVjBZMTV4cCIsIm5hbWUiOiJUaGUgU2FsZXMgUmFwcGVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdoOEt1SFY0Tnk4dFgyYVYwWTE1eHAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk5NjIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUVpITkEyMzQwNjkzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81NUJ4bHV5ZkdmZUx0dlNNRjU3UEpiIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNTVCeGx1eWZHZmVMdHZTTUY1N1BKYiIsImlkIjoiNTVCeGx1eWZHZmVMdHZTTUY1N1BKYiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSZWNlc3Npb24iLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NTVCeGx1eWZHZmVMdHZTTUY1N1BKYiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xR2tsd004SFRNWW41VnZXckFsYXY5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFHa2x3TThIVE1ZbjVWdldyQWxhdjkiLCJpZCI6IjFHa2x3TThIVE1ZbjVWdldyQWxhdjkiLCJuYW1lIjoiRCdEYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUdrbHdNOEhUTVluNVZ2V3JBbGF2OSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZyQUhseXYwazZZYU1HdGR5UGV1cTEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82ckFIbHl2MGs2WWFNR3RkeVBldXExIiwiaWQiOiI2ckFIbHl2MGs2WWFNR3RkeVBldXExIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2Y0ODJhNDcwY2Q5YTc3ZDlhZmQ5ODhjNyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJmNDgyYTQ3MGNkOWE3N2Q5YWZkOTg4YzcifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWY0ODJhNA==", + "NzBjZDlhNzdkOWFmZDk4OGM3In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRleWEsIFZvbC4gMSIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDEtMjciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo5LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZyQUhseXYwazZZYU1HdGR5UGV1cTEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xR2tsd004SFRNWW41VnZXckFsYXY5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFHa2x3TThIVE1ZbjVWdldyQWxhdjkiLCJpZCI6IjFHa2x3TThIVE1ZbjVWdldyQWxhdjkiLCJuYW1lIjoiRCdEYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MUdrbHdNOEhUTVluNVZ2V3JBbGF2OSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTQwMDAsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaRlo0MjM0MTY5OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMmRoSjIzTFhzY2JWcm56RlRTcU9BYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJkaEoyM0xYc2NiVnJuekZUU3FPQWEiLCJpZCI6IjJkaEoyM0xYc2NiVnJuekZUU3FPQWEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSnVzdCBEbyBJdCIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyZGhKMjNMWHNjYlZybnpGVFNxT0FhIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83aDhLdUhWNE55OHRYMmFWMFkxNXhwIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdoOEt1SFY0Tnk4dFgyYVYwWTE1eHAiLCJpZCI6IjdoOEt1SFY0Tnk4dFgyYVYwWTE1eHAiLCJuYW1lIjoiVGhlIFNhbGVzIFJhcHBlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3aDhLdUhWNE55OHRYMmFWMFkxNXhwIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlI3aEpXYjlZNkZxVThpdVB1RUExcyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJSN2hKV2I5WTZGcVU4aXVQdUVBMXMiLCJpZCI6IjJSN2hKV2I5WTZGcVU4aXVQdUVBMXMiLCJpbQ==", + "YWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlNTk1MGQzNTgzMWQ4ODUwY2I1OGRjOWUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTU5NTBkMzU4MzFkODg1MGNiNThkYzllIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlNTk1MGQzNTgzMWQ4ODUwY2I1OGRjOWUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmVjZXNzaW9uIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wNC0yNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MlI3aEpXYjlZNkZxVThpdVB1RUExcyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdoOEt1SFY0Tnk4dFgyYVYwWTE1eHAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN2g4S3VIVjROeTh0WDJhVjBZMTV4cCIsImlkIjoiN2g4S3VIVjROeTh0WDJhVjBZMTV4cCIsIm5hbWUiOiJUaGUgU2FsZXMgUmFwcGVyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdoOEt1SFY0Tnk4dFgyYVYwWTE1eHAifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk5NjIwLCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJRWkhOQTIzNDA2OTMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBqSGl0aGVlNjFnQnpYdlFzaUpTSVcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wakhpdGhlZTYxZ0J6WHZRc2lKU0lXIiwiaWQiOiIwakhpdGhlZTYxZ0J6WHZRc2lKU0lXIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJlY2Vzc2lvbiIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowakhpdGhlZTYxZ0J6WHZRc2lKU0lXIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRzbTNJeFhRT3FzTVNScTRCZHNaMmYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHNtM0l4WFFPcXNNU1JxNEJkc1oyZiIsImlkIjoiNHNtM0l4WA==", + "UU9xc01TUnE0QmRzWjJmIiwibmFtZSI6Ikphc29uIFZvb3JoZWV6eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0c20zSXhYUU9xc01TUnE0QmRzWjJmIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNThQT0w3TjFaWVZickdzaUZqOVZTVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzU4UE9MN04xWllWYnJHc2lGajlWU1QiLCJpZCI6IjU4UE9MN04xWllWYnJHc2lGajlWU1QiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNWU5OTk1NzlhNTliZDY2ZDllNWUxYTQzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjVlOTk5NTc5YTU5YmQ2NmQ5ZTVlMWE0MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNWU5OTk1NzlhNTliZDY2ZDllNWUxYTQzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkRJTUVOU0lPTkFMIEJSRUFDSCIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMTItMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1OFBPTDdOMVpZVmJyR3NpRmo5VlNUIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHNtM0l4WFFPcXNNU1JxNEJkc1oyZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80c20zSXhYUU9xc01TUnE0QmRzWjJmIiwiaWQiOiI0c20zSXhYUU9xc01TUnE0QmRzWjJmIiwibmFtZSI6Ikphc29uIFZvb3JoZWV6eSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0c20zSXhYUU9xc01TUnE0QmRzWjJmIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEyNDg0NjYsImV4cGxpY2l0Ijp0cnVlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaVkVNMjM4Njg0NiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNEdMMU5SbWRjOGphRnRaMFVueER1MiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzRHTDFOUm1kYzhqYUZ0WjBVbnhEdTIiLCJpZCI6IjRHTDFOUm1kYzhqYUZ0WjBVbnhEdTIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIg==", + "OiIyMCBNSU5VVEUgRlJFRVNUWUxFIiwidHJhY2tfbnVtYmVyIjoxNSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo0R0wxTlJtZGM4amFGdFowVW54RHUyIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wdEx1SW55dkRlNDJxWTU3S0RzcVR6In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzB0THVJbnl2RGU0MnFZNTdLRHNxVHoiLCJpZCI6IjB0THVJbnl2RGU0MnFZNTdLRHNxVHoiLCJuYW1lIjoiV2F2ZXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MHRMdUlueXZEZTQycVk1N0tEc3FUeiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJZcm1OTDlHenlCd0NEMHJ2eVR4Nk8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yWXJtTkw5R3p5QndDRDBydnlUeDZPIiwiaWQiOiIyWXJtTkw5R3p5QndDRDBydnlUeDZPIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzhiOGRlMzM2ZWY2OTE4NDViMWFkZjA1OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4YjhkZTMzNmVmNjkxODQ1YjFhZGYwNTgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MThiOGRlMzM2ZWY2OTE4NDViMWFkZjA1OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaW1lIiwicmVsZWFzZV9kYXRlIjoiMjAyNC0wNi0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MllybU5MOUd6eUJ3Q0QwcnZ5VHg2TyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzB0THVJbnl2RGU0MnFZNTdLRHNxVHoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3Yx", + "L2FydGlzdHMvMHRMdUlueXZEZTQycVk1N0tEc3FUeiIsImlkIjoiMHRMdUlueXZEZTQycVk1N0tEc3FUeiIsIm5hbWUiOiJXYXZleSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowdEx1SW55dkRlNDJxWTU3S0RzcVR6In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE1Nzg5NCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCS1FVMjQ0OTExOSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMFVhUjFFeDRETkViZDF6N2hIaEhFbCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBVYVIxRXg0RE5FYmQxejdoSGhIRWwiLCJpZCI6IjBVYVIxRXg0RE5FYmQxejdoSGhIRWwiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGltZSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowVWFSMUV4NERORWJkMXo3aEhoSEVsIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Timewarp+Bad+Company+UK&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Propane%20Nightmares%22%20artist%3A%22Pendulum%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/6eRDE48ttoLqN2VfkEpPOJ"},"href":"https://api.spotify.com/v1/albums/6eRDE48ttoLqN2VfkEpPOJ","id":"6eRDE48ttoLqN2VfkEpPOJ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27361d099fde6c64dc5a90742a4"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0261d099fde6c64dc5a90742a4"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485161d099fde6c64dc5a90742a4"}],"is_playable":true,"name":"In Silico","release_date":"2008-05-09","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:6eRDE48ttoLqN2VfkEpPOJ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":313346,"explicit":false,"external_ids":{"isrc":"GBAHT0800150"},"external_urls":{"spotify":"https://open.spotify.com/track/6tC2iHfUlzB2W4ntXXL2BH"},"href":"https://api.spotify.com/v1/tracks/6tC2iHfUlzB2W4ntXXL2BH","id":"6tC2iHfUlzB2W4ntXXL2BH","is_local":false,"is_playable":true,"name":"Propane Nightmares","track_number":3,"type":"track","uri":"spotify:track:6tC2iHfUlzB2W4ntXXL2BH"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/31OWhckCo87EVGJLA0F8g0"},"href":"https://api.spotify.com/v1/albums/31OWhckCo87EVGJLA0F8g0","id":"31OWhckCo87EVGJLA0F8g0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b7aaa358feb8613789c5a372"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b7aaa358feb8613789c5a372"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b7aaa358feb8613789c5a372"}],"is_playable":true,"name":"Propane Nightmares","release_date":"2008-04-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:31OWhckCo87EVGJLA0F8g0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4BKyei61gtyDFxlKhcvBJJ"},"href":"https://api.spotify.com/v1/artists/4BKyei61gtyDFxlKhcvBJJ","id":"4BKyei61gtyDFxlKhcvBJJ","name":"Celldweller","type":"artist","uri":"spotify:artist:4BKyei61gtyDFxlKhcvBJJ"}],"disc_number":1,"duration_ms":334040,"explicit":false,"external_ids":{"isrc":"GBAHT0800174"},"external_urls":{"spotify":"https://open.spotify.com/track/2UA9iibITypfdDZekeGcIx"},"href":"https://api.spotify.com/v1/tracks/2UA9iibITypfdDZekeGcIx","id":"2UA9iibITypfdDZekeGcIx","is_local":false,"is_playable":true,"name":"Propane Nightmares - Celldweller Remix","track_number":1,"type":"track","uri":"spotify:track:2UA9iibITypfdDZekeGcIx"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/3QZHRDBNh1GHDY6MCBULQp"},"href":"https://api.spotify.com/v1/albums/3QZHRDBNh1GHDY6MCBULQp","id":"3QZHRDBNh1GHDY6MCBULQp","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734ac26e81ee22c927d09c18dc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024ac26e81ee22c927d09c18dc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514ac26e81ee22c927d09c18dc"}],"is_playable":true,"name":"The Reworks","release_date":"2018-06-29","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:3QZHRDBNh1GHDY6MCBULQp"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4fv1OFJywZ7DHCz3mVQQ45"},"href":"https://api.spotify.com/v1/artists/4fv1OFJywZ7DHCz3mVQQ45","id":"4fv1OFJywZ7DHCz3mVQQ45","name":"Grabbitz","type":"artist","uri":"spotify:artist:4fv1OFJywZ7DHCz3mVQQ45"}],"disc_number":1,"duration_ms":230516,"explicit":false,"external_ids":{"isrc":"UKNKE1800005"},"external_urls":{"spotify":"https://open.spotify.com/track/0YxYgMCDfkshRehdupnoaH"},"href":"https://api.spotify.com/v1/tracks/0YxYgMCDfkshRehdupnoaH","id":"0YxYgMCDfkshRehdupnoaH","is_local":false,"is_playable":true,"name":"Propane Nightmares - Grabbitz Remix","track_number":5,"type":"track","uri":"spotify:track:0YxYgMCDfkshRehdupnoaH"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/1mxR8Xa8GRQCMk4CGnH4Q6"},"href":"https://api.spotify.com/v1/albums/1mxR8Xa8GRQCMk4CGnH4Q6","id":"1mxR8Xa8GRQCMk4CGnH4Q6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27386939f66c195213519927f0d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0286939f66c195213519927f0d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485186939f66c195213519927f0d"}],"is_playable":true,"name":"Propane Nightmares","release_date":"2008-04-18","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:1mxR8Xa8GRQCMk4CGnH4Q6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":322120,"explicit":false,"external_ids":{"isrc":"GBAHT0800013"},"external_urls":{"spotify":"https://open.spotify.com/track/0dN0pwNcE9qVNmi9UI6xqE"},"href":"https://api.spotify.com/v1/tracks/0dN0pwNcE9qVNmi9UI6xqE","id":"0dN0pwNcE9qVNmi9UI6xqE","is_local":false,"is_playable":true,"name":"Propane Nightmares - V.I.P.","track_number":2,"type":"track","uri":"spotify:track:0dN0pwNcE9qVNmi9UI6xqE"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/3bdC6SSUENC7jNrybImFDu"},"href":"https://api.spotify.com/v1/albums/3bdC6SSUENC7jNrybImFDu","id":"3bdC6SSUENC7jNrybImFDu","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bf2c154096868347485bfeaa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bf2c154096868347485bfeaa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bf2c154096868347485bfeaa"}],"is_playable":true,"name":"Live at Brixton Academy","release_date":"2009-06-12","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:3bdC6SSUENC7jNrybImFDu"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":364320,"explicit":false,"external_ids":{"isrc":"GBAHT0900248"},"external_urls":{"spotify":"https://open.spotify.com/track/2lVGHCEhoaCWNtiRPoV0SA"},"href":"https://api.spotify.com/v1/tracks/2lVGHCEhoaCWNtiRPoV0SA","id":"2lVGHCEhoaCWNtiRPoV0SA","is_local":false,"is_playable":true,"name":"Propane Nightmares - Live at Brixton Academy","track_number":6,"type":"track","uri":"spotify:track:2lVGHCEhoaCWNtiRPoV0SA"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/7FiMYcaFW3H42287fTDWq3"},"href":"https://api.spotify.com/v1/albums/7FiMYcaFW3H42287fTDWq3","id":"7FiMYcaFW3H42287fTDWq3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e0968cff4d1b0538096db76c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e0968cff4d1b0538096db76c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e0968cff4d1b0538096db76c"}],"is_playable":true,"name":"Propane Nightmares","release_date":"2008-04-12","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7FiMYcaFW3H42287fTDWq3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":313866,"explicit":false,"external_ids":{"isrc":"GBAHT0700918"},"external_urls":{"spotify":"https://open.spotify.com/track/6B9mcMqfCvjoB9GD3xxL1Z"},"href":"https://api.spotify.com/v1/tracks/6B9mcMqfCvjoB9GD3xxL1Z","id":"6B9mcMqfCvjoB9GD3xxL1Z","is_local":false,"is_playable":true,"name":"Propane Nightmares","track_number":1,"type":"track","uri":"spotify:track:6B9mcMqfCvjoB9GD3xxL1Z"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"external_urls":{"spotify":"https://open.spotify.com/album/1mxR8Xa8GRQCMk4CGnH4Q6"},"href":"https://api.spotify.com/v1/albums/1mxR8Xa8GRQCMk4CGnH4Q6","id":"1mxR8Xa8GRQCMk4CGnH4Q6","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27386939f66c195213519927f0d"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0286939f66c195213519927f0d"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485186939f66c195213519927f0d"}],"is_playable":true,"name":"Propane Nightmares","release_date":"2008-04-18","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:1mxR8Xa8GRQCMk4CGnH4Q6"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":313866,"explicit":false,"external_ids":{"isrc":"GBAHT0700918"},"external_urls":{"spotify":"https://open.spotify.com/track/0kigbEx1sw4PJsPvRvyXMO"},"href":"https://api.spotify.com/v1/tracks/0kigbEx1sw4PJsPvRvyXMO","id":"0kigbEx1sw4PJsPvRvyXMO","is_local":false,"is_playable":true,"name":"Propane Nightmares","track_number":1,"type":"track","uri":"spotify:track:0kigbEx1sw4PJsPvRvyXMO"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/74FvZUNETek0uR0KyuZLz0"},"href":"https://api.spotify.com/v1/albums/74FvZUNETek0uR0KyuZLz0","id":"74FvZUNETek0uR0KyuZLz0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fcb206d9ddb5e49d7f081caf"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fcb206d9ddb5e49d7f081caf"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fcb206d9ddb5e49d7f081caf"}],"is_playable":true,"name":"Top Hits 2000","release_date":"2024-06-04","release_date_precision":"day","total_tracks":26,"type":"album","uri":"spotify:album:74FvZUNETek0uR0KyuZLz0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":313866,"explicit":false,"external_ids":{"isrc":"GBAHT0700918"},"external_urls":{"spotify":"https://open.spotify.com/track/0pLYM2k7YyRFPjU8KMqT13"},"href":"https://api.spotify.com/v1/tracks/0pLYM2k7YyRFPjU8KMqT13","id":"0pLYM2k7YyRFPjU8KMqT13","is_local":false,"is_playable":true,"name":"Propane Nightmares","track_number":17,"type":"track","uri":"spotify:track:0pLYM2k7YyRFPjU8KMqT13"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0p6kXgATc9sivAeFa43C0P"},"href":"https://api.spotify.com/v1/albums/0p6kXgATc9sivAeFa43C0P","id":"0p6kXgATc9sivAeFa43C0P","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273f6b3da151f5448248c492b90"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02f6b3da151f5448248c492b90"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851f6b3da151f5448248c492b90"}],"is_playable":true,"name":"00's Club Hits","release_date":"2020-11-20","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:0p6kXgATc9sivAeFa43C0P"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":313346,"explicit":false,"external_ids":{"isrc":"GBAHT0800150"},"external_urls":{"spotify":"https://open.spotify.com/track/5MflAsLU4YD2sMGJmXXsG9"},"href":"https://api.spotify.com/v1/tracks/5MflAsLU4YD2sMGJmXXsG9","id":"5MflAsLU4YD2sMGJmXXsG9","is_local":false,"is_playable":true,"name":"Propane Nightmares","track_number":3,"type":"track","uri":"spotify:track:5MflAsLU4YD2sMGJmXXsG9"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5ukHShErxvsK0In0LIYlHe"},"href":"https://api.spotify.com/v1/albums/5ukHShErxvsK0In0LIYlHe","id":"5ukHShErxvsK0In0LIYlHe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736d22e6b4ed9dfd030b3f6403"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026d22e6b4ed9dfd030b3f6403"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516d22e6b4ed9dfd030b3f6403"}],"is_playable":true,"name":"00's Teen Party","release_date":"2021-06-04","release_date_precision":"day","total_tracks":32,"type":"album","uri":"spotify:album:5ukHShErxvsK0In0LIYlHe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7MqnCTCAX6SsIYYdJCQj9B"},"href":"https://api.spotify.com/v1/artists/7MqnCTCAX6SsIYYdJCQj9B","id":"7MqnCTCAX6SsIYYdJCQj9B","name":"Pendulum","type":"artist","uri":"spotify:artist:7MqnCTCAX6SsIYYdJCQj9B"}],"disc_number":1,"duration_ms":313346,"explicit":false,"external_ids":{"isrc":"GBAHT0800150"},"external_urls":{"spotify":"https://open.spotify.com/track/4RdZhbJBgPOphIf6jvk3jh"},"href":"https://api.spotify.com/v1/tracks/4RdZhbJBgPOphIf6jvk3jh","id":"4RdZhbJBgPOphIf6jvk3jh","is_local":false,"is_playable":true,"name":"Propane Nightmares","track_number":17,"type":"track","uri":"spotify:track:4RdZhbJBgPOphIf6jvk3jh"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlByb3BhbmUlMjBOaWdodG1hcmVzJTIyJTIwYXJ0aXN0JTNBJTIyUGVuZHVsdW0lMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNmVSREU0OHR0b0xxTjJWZmtFcFBPSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzZlUkRFNDh0dG9McU4yVmZrRXBQT0oiLCJpZCI6IjZlUkRFNDh0dG9McU4yVmZrRXBQT0oiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNjFkMDk5ZmRlNmM2NGRjNWE5MDc0MmE0In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjYxZDA5OWZkZTZjNjRkYzVhOTA3NDJhNCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNjFkMDk5ZmRlNmM2NGRjNWE5MDc0MmE0In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkluIFNpbGljbyIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMDUtMDkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo2ZVJERTQ4dHRvTHFOMlZma0VwUE9KIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSg==", + "Q1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMTMzNDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIVDA4MDAxNTAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZ0QzJpSGZVbHpCMlc0bnRYWEwyQkgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82dEMyaUhmVWx6QjJXNG50WFhMMkJIIiwiaWQiOiI2dEMyaUhmVWx6QjJXNG50WFhMMkJIIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlByb3BhbmUgTmlnaHRtYXJlcyIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2dEMyaUhmVWx6QjJXNG50WFhMMkJIIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzMxT1doY2tDbzg3RVZHSkxBMEY4ZzAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zMU9XaGNrQ284N0VWR0pMQTBGOGcwIiwiaWQiOiIzMU9XaGNrQ284N0VWR0pMQTBGOGcwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2I3YWFhMzU4ZmViODYxMzc4OWM1YTM3MiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiN2FhYTM1OGZlYjg2MTM3ODljNWEzNzIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWI3YWFhMzU4ZmViODYxMzc4OWM1YTM3MiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQcm9wYW5lIE5pZ2h0bWFyZXMiLCJyZWxlYXNlX2RhdGUiOiIyMDA4LTA0LTE4Iiwicg==", + "ZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjMxT1doY2tDbzg3RVZHSkxBMEY4ZzAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80Qkt5ZWk2MWd0eURGeGxLaGN2QkpKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRCS3llaTYxZ3R5REZ4bEtoY3ZCSkoiLCJpZCI6IjRCS3llaTYxZ3R5REZ4bEtoY3ZCSkoiLCJuYW1lIjoiQ2VsbGR3ZWxsZXIiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NEJLeWVpNjFndHlERnhsS2hjdkJKSiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMzQwNDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIVDA4MDAxNzQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJVQTlpaWJJVHlwZmREWmVrZUdjSXgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yVUE5aWliSVR5cGZkRFpla2VHY0l4IiwiaWQiOiIyVUE5aWliSVR5cGZkRFpla2VHY0l4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlByb3BhbmUgTmlnaHRtYXJlcyAtIENlbGxkd2VsbGVyIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjJVQTlpaWJJVHlwZmREWmVrZUdjSXgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwibmFtZSI6IlBlbmR1bHVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNcW5DVENBWDZTcw==", + "SVlZZEpDUWo5QiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzNRWkhSREJOaDFHSERZNk1DQlVMUXAifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zUVpIUkRCTmgxR0hEWTZNQ0JVTFFwIiwiaWQiOiIzUVpIUkRCTmgxR0hEWTZNQ0JVTFFwIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRhYzI2ZTgxZWUyMmM5MjdkMDljMThkYyJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0YWMyNmU4MWVlMjJjOTI3ZDA5YzE4ZGMifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRhYzI2ZTgxZWUyMmM5MjdkMDljMThkYyJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUaGUgUmV3b3JrcyIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDYtMjkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozUVpIUkRCTmgxR0hEWTZNQ0JVTFFwIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwibmFtZSI6IlBlbmR1bHVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGZ2MU9GSnl3WjdESEN6M21WUVE0NSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80ZnYxT0ZKeXdaN0RIQ3ozbVZRUTQ1IiwiaWQiOiI0ZnYxT0ZKeXdaN0RIQ3ozbVZRUTQ1IiwibmFtZSI6IkdyYWJiaXR6IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRmdjFPRkp5d1o3REhDejNtVlFRNDUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMwNTE2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVUtOS0UxODAwMDA1In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wWXhZZw==", + "TUNEZmtzaFJlaGR1cG5vYUgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wWXhZZ01DRGZrc2hSZWhkdXBub2FIIiwiaWQiOiIwWXhZZ01DRGZrc2hSZWhkdXBub2FIIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlByb3BhbmUgTmlnaHRtYXJlcyAtIEdyYWJiaXR6IFJlbWl4IiwidHJhY2tfbnVtYmVyIjo1LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBZeFlnTUNEZmtzaFJlaGR1cG5vYUgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMW14UjhYYThHUlFDTWs0Q0duSDRRNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFteFI4WGE4R1JRQ01rNENHbkg0UTYiLCJpZCI6IjFteFI4WGE4R1JRQ01rNENHbkg0UTYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODY5MzlmNjZjMTk1MjEzNTE5OTI3ZjBkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjg2OTM5ZjY2YzE5NTIxMzUxOTkyN2YwZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODY5MzlmNjZjMTk1MjEzNTE5OTI3ZjBkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlByb3BhbmUgTmlnaHRtYXJlcyIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMDQtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFteFI4WGE4R1JRQ01rNENHbkg0UTYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aQ==", + "ZnkuY29tL3YxL2FydGlzdHMvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMyMjEyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhUMDgwMDAxMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMGROMHB3TmNFOXFWTm1pOVVJNnhxRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBkTjBwd05jRTlxVk5taTlVSTZ4cUUiLCJpZCI6IjBkTjBwd05jRTlxVk5taTlVSTZ4cUUiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUHJvcGFuZSBOaWdodG1hcmVzIC0gVi5JLlAuIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBkTjBwd05jRTlxVk5taTlVSTZ4cUUifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwibmFtZSI6IlBlbmR1bHVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zYmRDNlNTVUVOQzdqTnJ5YkltRkR1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2JkQzZTU1VFTkM3ak5yeWJJbUZEdSIsImlkIjoiM2JkQzZTU1VFTkM3ak5yeWJJbUZEdSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiZjJjMTU0MDk2ODY4MzQ3NDg1YmZlYWEifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmYyYzE1NDA5Njg2ODM0NzQ4NWJmZWFhIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiZjJjMTU0MDk2ODY4MzQ3NDg1YmZlYWEifV0sImlzXw==", + "cGxheWFibGUiOnRydWUsIm5hbWUiOiJMaXZlIGF0IEJyaXh0b24gQWNhZGVteSIsInJlbGVhc2VfZGF0ZSI6IjIwMDktMDYtMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozYmRDNlNTVUVOQzdqTnJ5YkltRkR1In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwibmFtZSI6IlBlbmR1bHVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzY0MzIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFQwOTAwMjQ4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8ybFZHSENFaG9hQ1dOdGlSUG9WMFNBIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMmxWR0hDRWhvYUNXTnRpUlBvVjBTQSIsImlkIjoiMmxWR0hDRWhvYUNXTnRpUlBvVjBTQSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQcm9wYW5lIE5pZ2h0bWFyZXMgLSBMaXZlIGF0IEJyaXh0b24gQWNhZGVteSIsInRyYWNrX251bWJlciI6NiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoybFZHSENFaG9hQ1dOdGlSUG9WMFNBIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzdGaU1ZY2FGVzNINDIyODdmVERXcTMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83RmlNWWNhRlczSDQyMjg3ZlREV3EzIiwiaWQiOiI3RmlNWWNhRlczSA==", + "NDIyODdmVERXcTMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZTA5NjhjZmY0ZDFiMDUzODA5NmRiNzZjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmUwOTY4Y2ZmNGQxYjA1MzgwOTZkYjc2YyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZTA5NjhjZmY0ZDFiMDUzODA5NmRiNzZjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlByb3BhbmUgTmlnaHRtYXJlcyIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMDQtMTIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjdGaU1ZY2FGVzNINDIyODdmVERXcTMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMTM4NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIVDA3MDA5MTgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZCOW1jTXFmQ3Zqb0I5R0QzeHhMMVoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82QjltY01xZkN2am9COUdEM3h4TDFaIiwiaWQiOiI2QjltY01xZkN2am9COUdEM3h4TDFaIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlByb3BhbmUgTmlnaHRtYXJlcyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2QjltY01xZkN2am9COUdEM3h4TDFaIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWA==", + "NlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMW14UjhYYThHUlFDTWs0Q0duSDRRNiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFteFI4WGE4R1JRQ01rNENHbkg0UTYiLCJpZCI6IjFteFI4WGE4R1JRQ01rNENHbkg0UTYiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODY5MzlmNjZjMTk1MjEzNTE5OTI3ZjBkIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjg2OTM5ZjY2YzE5NTIxMzUxOTkyN2YwZCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODY5MzlmNjZjMTk1MjEzNTE5OTI3ZjBkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlByb3BhbmUgTmlnaHRtYXJlcyIsInJlbGVhc2VfZGF0ZSI6IjIwMDgtMDQtMTgiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFteFI4WGE4R1JRQ01rNENHbkg0UTYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJpZCI6IjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIiLCJuYW1lIjoiUGVuZHVsdW0iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMTM4NjYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIVDA3MDA5MTgifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBraWdiRXgxc3c0UEpzUHZSdnlYTU8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wa2lnYkV4MXN3NFBKc1B2UnZ5WE1PIiwiaWQiOiIwa2lnYkV4MXN3NFBKc1B2UnZ5WE1PIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZQ==", + "Ijp0cnVlLCJuYW1lIjoiUHJvcGFuZSBOaWdodG1hcmVzIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBraWdiRXgxc3c0UEpzUHZSdnlYTU8ifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzRGdlpVTkVUZWswdVIwS3l1Wkx6MCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzc0RnZaVU5FVGVrMHVSMEt5dVpMejAiLCJpZCI6Ijc0RnZaVU5FVGVrMHVSMEt5dVpMejAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmNiMjA2ZDlkZGI1ZTQ5ZDdmMDgxY2FmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZjYjIwNmQ5ZGRiNWU0OWQ3ZjA4MWNhZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmNiMjA2ZDlkZGI1ZTQ5ZDdmMDgxY2FmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlRvcCBIaXRzIDIwMDAiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTA2LTA0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NzRGdlpVTkVUZWswdVIwS3l1Wkx6MCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLA==", + "ImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzEzODY2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFQwNzAwOTE4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wcExZTTJrN1l5UkZQalU4S01xVDEzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMHBMWU0yazdZeVJGUGpVOEtNcVQxMyIsImlkIjoiMHBMWU0yazdZeVJGUGpVOEtNcVQxMyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQcm9wYW5lIE5pZ2h0bWFyZXMiLCJ0cmFja19udW1iZXIiOjE3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBwTFlNMms3WXlSRlBqVThLTXFUMTMifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMHA2a1hnQVRjOXNpdkFlRmE0M0MwUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBwNmtYZ0FUYzlzaXZBZUZhNDNDMFAiLCJpZCI6IjBwNmtYZ0FUYzlzaXZBZUZhNDNDMFAiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZjZiM2RhMTUxZjU0NDgyNDhjNDkyYjkwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmY2YjNkYTE1MWY1NDQ4MjQ4YzQ5MmI5MCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZjZiM2RhMTUxZjU0NDgyNDhjNDkyYjkwIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjAwJ3MgQ2x1YiBIaXRzIiwicmVsZWFzZV9kYXRlIjoiMjAyMC0xMS0yMCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI4LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYg==", + "dW06MHA2a1hnQVRjOXNpdkFlRmE0M0MwUCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjMxMzM0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhUMDgwMDE1MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNU1mbEFzTFU0WUQyc01HSm1YWHNHOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVNZmxBc0xVNFlEMnNNR0ptWFhzRzkiLCJpZCI6IjVNZmxBc0xVNFlEMnNNR0ptWFhzRzkiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUHJvcGFuZSBOaWdodG1hcmVzIiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVNZmxBc0xVNFlEMnNNR0ptWFhzRzkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNXVrSFNoRXJ4dnNLMEluMExJWWxIZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzV1a0hTaEVyeHZzSzBJbjBMSVlsSGUiLCJpZCI6IjV1", + "a0hTaEVyeHZzSzBJbjBMSVlsSGUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmQyMmU2YjRlZDlkZmQwMzBiM2Y2NDAzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZkMjJlNmI0ZWQ5ZGZkMDMwYjNmNjQwMyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmQyMmU2YjRlZDlkZmQwMzBiM2Y2NDAzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IjAwJ3MgVGVlbiBQYXJ0eSIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMDYtMDQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozMiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1dWtIU2hFcnh2c0swSW4wTElZbEhlIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwibmFtZSI6IlBlbmR1bHVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MzEzMzQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFQwODAwMTUwIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80UmRaaGJKQmdQT3BoSWY2anZrM2poIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNFJkWmhiSkJnUE9waElmNmp2azNqaCIsImlkIjoiNFJkWmhiSkJnUE9waElmNmp2azNqaCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJQcm9wYW5lIE5pZ2h0bWFyZXMiLCJ0cmFja19udW1iZXIiOjE3LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjRSZFpoYkpCZ1BPcGhJZjZqdmszamgifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Propane+Nightmares%22+artist%3A%22Pendulum%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN3ZWV0JTIwVGFsa2VyJTIyJTIwYXJ0aXN0JTNBJTIyU2lnbWElMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlN3ZWV0JTIwVGFsa2VyJTIyJTIwYXJ0aXN0JTNBJTIyU2lnbWElMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjAsIml0ZW1zIjpbXX19" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Sweet+Talker%22+artist%3A%22Sigma%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1XYXJoZWFkJTIwUGVuZHVsdW0mdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjEsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsImlkIjoiN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiIsIm5hbWUiOiJQZW5kdWx1bSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMEFCVmNXRnFldXpsQ0wxZmVKalBqcyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzBBQlZjV0ZxZXV6bENMMWZlSmpQanMiLCJpZCI6IjBBQlZjV0ZxZXV6bENMMWZlSmpQanMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMWExZjkxOTRmNGY5MDZhYWFmYg==", + "Y2I4ZGIifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWExZjkxOTRmNGY5MDZhYWFmYmNiOGRiIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYTFmOTE5NGY0ZjkwNmFhYWZiY2I4ZGIifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSW5lcnRpYSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDgtMjIiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowQUJWY1dGcWV1emxDTDFmZUpqUGpzIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN01xbkNUQ0FYNlNzSVlZZEpDUWo5QiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwiaWQiOiI3TXFuQ1RDQVg2U3NJWVlkSkNRajlCIiwibmFtZSI6IlBlbmR1bHVtIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdNcW5DVENBWDZTc0lZWWRKQ1FqOUIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjMzMTk5LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiUU02TVoyMTEwOTg4In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wMzJFTXk4RHFPcWdLa0Y1d0ptMjF3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMDMyRU15OERxT3FnS2tGNXdKbTIxdyIsImlkIjoiMDMyRU15OERxT3FnS2tGNXdKbTIxdyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDb21lIEFsaXZlIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjAzMkVNeThEcU9xZ0trRjV3Sm0yMXcifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Warhead+Pendulum&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkFpbiUyN3QlMjBOb2JvZHklMjIlMjBhcnRpc3QlM0ElMjJLb3ZlJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkFpbiUyN3QlMjBOb2JvZHklMjIlMjBhcnRpc3QlM0ElMjJLb3ZlJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W119fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Ain%27t+Nobody%22+artist%3A%22Kove%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJvZHklMjBNb3ZlJTIyJTIwYXJ0aXN0JTNBJTIyS292ZSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJvZHklMjBNb3ZlJTIyJTIwYXJ0aXN0JTNBJTIyS292ZSUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Body+Move%22+artist%3A%22Kove%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJyaW5nJTIwWW91JTIwRG93biUyMiUyMGFydGlzdCUzQSUyMldpbGtpbnNvbiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkJyaW5nJTIwWW91JTIwRG93biUyMiUyMGFydGlzdCUzQSUyMldpbGtpbnNvbiUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6MCwiaXRlbXMiOltdfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Bring+You+Down%22+artist%3A%22Wilkinson%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Feel%20The%20Love%22%20artist%3A%22Rudimental%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":9,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/2AOpbitJNMvKhSbsi2YD4F"},"href":"https://api.spotify.com/v1/albums/2AOpbitJNMvKhSbsi2YD4F","id":"2AOpbitJNMvKhSbsi2YD4F","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731468dc3911c9abea1dcf9676"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021468dc3911c9abea1dcf9676"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511468dc3911c9abea1dcf9676"}],"is_playable":true,"name":"Home","release_date":"2013-04-05","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:2AOpbitJNMvKhSbsi2YD4F"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/34v5MVKeQnIo0CWYMbbrPf"},"href":"https://api.spotify.com/v1/artists/34v5MVKeQnIo0CWYMbbrPf","id":"34v5MVKeQnIo0CWYMbbrPf","name":"John Newman","type":"artist","uri":"spotify:artist:34v5MVKeQnIo0CWYMbbrPf"}],"disc_number":1,"duration_ms":245186,"explicit":false,"external_ids":{"isrc":"GBAHS1200174"},"external_urls":{"spotify":"https://open.spotify.com/track/0k73nWaD6RPx2sHFEkGPcn"},"href":"https://api.spotify.com/v1/tracks/0k73nWaD6RPx2sHFEkGPcn","id":"0k73nWaD6RPx2sHFEkGPcn","is_local":false,"is_playable":true,"name":"Feel the Love (feat. John Newman)","track_number":2,"type":"track","uri":"spotify:track:0k73nWaD6RPx2sHFEkGPcn"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/6SRwxmQjAneSSyfhE7fv37"},"href":"https://api.spotify.com/v1/albums/6SRwxmQjAneSSyfhE7fv37","id":"6SRwxmQjAneSSyfhE7fv37","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738391469cee52835d6796ba71"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028391469cee52835d6796ba71"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518391469cee52835d6796ba71"}],"is_playable":true,"name":"Feel the Love (feat. John Newman)","release_date":"2012-05-14","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:6SRwxmQjAneSSyfhE7fv37"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/34v5MVKeQnIo0CWYMbbrPf"},"href":"https://api.spotify.com/v1/artists/34v5MVKeQnIo0CWYMbbrPf","id":"34v5MVKeQnIo0CWYMbbrPf","name":"John Newman","type":"artist","uri":"spotify:artist:34v5MVKeQnIo0CWYMbbrPf"}],"disc_number":1,"duration_ms":245186,"explicit":false,"external_ids":{"isrc":"GBAHS1200174"},"external_urls":{"spotify":"https://open.spotify.com/track/0nypsuS2jtogLaJDcRQ4Ya"},"href":"https://api.spotify.com/v1/tracks/0nypsuS2jtogLaJDcRQ4Ya","id":"0nypsuS2jtogLaJDcRQ4Ya","is_local":false,"is_playable":true,"name":"Feel the Love (feat. John Newman)","track_number":1,"type":"track","uri":"spotify:track:0nypsuS2jtogLaJDcRQ4Ya"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/5hAJKdlLfFblwwmGR0a3Lk"},"href":"https://api.spotify.com/v1/albums/5hAJKdlLfFblwwmGR0a3Lk","id":"5hAJKdlLfFblwwmGR0a3Lk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27339c2108961dbaa88b45554da"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0239c2108961dbaa88b45554da"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485139c2108961dbaa88b45554da"}],"is_playable":true,"name":"Feel the Love (feat. John Newman)","release_date":"2012-06-12","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:5hAJKdlLfFblwwmGR0a3Lk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/34v5MVKeQnIo0CWYMbbrPf"},"href":"https://api.spotify.com/v1/artists/34v5MVKeQnIo0CWYMbbrPf","id":"34v5MVKeQnIo0CWYMbbrPf","name":"John Newman","type":"artist","uri":"spotify:artist:34v5MVKeQnIo0CWYMbbrPf"}],"disc_number":1,"duration_ms":219040,"explicit":false,"external_ids":{"isrc":"GBAHS1200163"},"external_urls":{"spotify":"https://open.spotify.com/track/5crHvEPQ13FbQGQSscm5Ns"},"href":"https://api.spotify.com/v1/tracks/5crHvEPQ13FbQGQSscm5Ns","id":"5crHvEPQ13FbQGQSscm5Ns","is_local":false,"is_playable":true,"name":"Feel the Love (feat. John Newman) - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:5crHvEPQ13FbQGQSscm5Ns"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/6RM05aDNmbqF7AV1xwubac"},"href":"https://api.spotify.com/v1/albums/6RM05aDNmbqF7AV1xwubac","id":"6RM05aDNmbqF7AV1xwubac","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738d879f108f3ef1b2086c67e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028d879f108f3ef1b2086c67e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518d879f108f3ef1b2086c67e8"}],"is_playable":true,"name":"Home (Deluxe Edition)","release_date":"2013-04-05","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6RM05aDNmbqF7AV1xwubac"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/67nwj3Y5sZQLl72VNUHEYE"},"href":"https://api.spotify.com/v1/artists/67nwj3Y5sZQLl72VNUHEYE","id":"67nwj3Y5sZQLl72VNUHEYE","name":"Wale","type":"artist","uri":"spotify:artist:67nwj3Y5sZQLl72VNUHEYE"}],"disc_number":1,"duration_ms":236000,"explicit":false,"external_ids":{"isrc":"GBAHS1300284"},"external_urls":{"spotify":"https://open.spotify.com/track/0ojU4I7FDbtkvh4lnkPI1C"},"href":"https://api.spotify.com/v1/tracks/0ojU4I7FDbtkvh4lnkPI1C","id":"0ojU4I7FDbtkvh4lnkPI1C","is_local":false,"is_playable":true,"name":"Feel the Love (feat. Wale)","track_number":13,"type":"track","uri":"spotify:track:0ojU4I7FDbtkvh4lnkPI1C"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/6RM05aDNmbqF7AV1xwubac"},"href":"https://api.spotify.com/v1/albums/6RM05aDNmbqF7AV1xwubac","id":"6RM05aDNmbqF7AV1xwubac","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738d879f108f3ef1b2086c67e8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028d879f108f3ef1b2086c67e8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518d879f108f3ef1b2086c67e8"}],"is_playable":true,"name":"Home (Deluxe Edition)","release_date":"2013-04-05","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:6RM05aDNmbqF7AV1xwubac"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/34v5MVKeQnIo0CWYMbbrPf"},"href":"https://api.spotify.com/v1/artists/34v5MVKeQnIo0CWYMbbrPf","id":"34v5MVKeQnIo0CWYMbbrPf","name":"John Newman","type":"artist","uri":"spotify:artist:34v5MVKeQnIo0CWYMbbrPf"}],"disc_number":1,"duration_ms":245186,"explicit":false,"external_ids":{"isrc":"GBAHS1200174"},"external_urls":{"spotify":"https://open.spotify.com/track/2VvCoqF4p46cvyVbhbDsaJ"},"href":"https://api.spotify.com/v1/tracks/2VvCoqF4p46cvyVbhbDsaJ","id":"2VvCoqF4p46cvyVbhbDsaJ","is_local":false,"is_playable":true,"name":"Feel the Love (feat. John Newman)","track_number":2,"type":"track","uri":"spotify:track:2VvCoqF4p46cvyVbhbDsaJ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/3k5awyxfflQsiCRuwUfbm3"},"href":"https://api.spotify.com/v1/albums/3k5awyxfflQsiCRuwUfbm3","id":"3k5awyxfflQsiCRuwUfbm3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730b954055be42e23aedfd9cc3"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020b954055be42e23aedfd9cc3"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510b954055be42e23aedfd9cc3"}],"is_playable":true,"name":"Home (10th Anniversary Edition)","release_date":"2013-04-05","release_date_precision":"day","total_tracks":21,"type":"album","uri":"spotify:album:3k5awyxfflQsiCRuwUfbm3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/34v5MVKeQnIo0CWYMbbrPf"},"href":"https://api.spotify.com/v1/artists/34v5MVKeQnIo0CWYMbbrPf","id":"34v5MVKeQnIo0CWYMbbrPf","name":"John Newman","type":"artist","uri":"spotify:artist:34v5MVKeQnIo0CWYMbbrPf"}],"disc_number":1,"duration_ms":245186,"explicit":false,"external_ids":{"isrc":"GBAHS1200174"},"external_urls":{"spotify":"https://open.spotify.com/track/5SGMaAQDbG3KQ6pTzKw4RR"},"href":"https://api.spotify.com/v1/tracks/5SGMaAQDbG3KQ6pTzKw4RR","id":"5SGMaAQDbG3KQ6pTzKw4RR","is_local":false,"is_playable":true,"name":"Feel the Love (feat. John Newman)","track_number":2,"type":"track","uri":"spotify:track:5SGMaAQDbG3KQ6pTzKw4RR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/6vIeMBRykXpML5YZEJxcKk"},"href":"https://api.spotify.com/v1/albums/6vIeMBRykXpML5YZEJxcKk","id":"6vIeMBRykXpML5YZEJxcKk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ec6aa21ed22ca06e0326fc88"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ec6aa21ed22ca06e0326fc88"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ec6aa21ed22ca06e0326fc88"}],"is_playable":true,"name":"Zomerhits Allertijden","release_date":"2023-04-14","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:6vIeMBRykXpML5YZEJxcKk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/34v5MVKeQnIo0CWYMbbrPf"},"href":"https://api.spotify.com/v1/artists/34v5MVKeQnIo0CWYMbbrPf","id":"34v5MVKeQnIo0CWYMbbrPf","name":"John Newman","type":"artist","uri":"spotify:artist:34v5MVKeQnIo0CWYMbbrPf"}],"disc_number":1,"duration_ms":245186,"explicit":false,"external_ids":{"isrc":"GBAHS1200174"},"external_urls":{"spotify":"https://open.spotify.com/track/0l76Z3TYZFzCHjadRq131e"},"href":"https://api.spotify.com/v1/tracks/0l76Z3TYZFzCHjadRq131e","id":"0l76Z3TYZFzCHjadRq131e","is_local":false,"is_playable":true,"name":"Feel the Love","track_number":12,"type":"track","uri":"spotify:track:0l76Z3TYZFzCHjadRq131e"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/38kZxy2XkagYovUNRjCDSW"},"href":"https://api.spotify.com/v1/albums/38kZxy2XkagYovUNRjCDSW","id":"38kZxy2XkagYovUNRjCDSW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d8e2a0d8c854d47007ddc1dc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d8e2a0d8c854d47007ddc1dc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d8e2a0d8c854d47007ddc1dc"}],"is_playable":true,"name":"Feel the Love (feat. John Newman)","release_date":"2013-03-25","release_date_precision":"day","total_tracks":6,"type":"album","uri":"spotify:album:38kZxy2XkagYovUNRjCDSW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/34v5MVKeQnIo0CWYMbbrPf"},"href":"https://api.spotify.com/v1/artists/34v5MVKeQnIo0CWYMbbrPf","id":"34v5MVKeQnIo0CWYMbbrPf","name":"John Newman","type":"artist","uri":"spotify:artist:34v5MVKeQnIo0CWYMbbrPf"}],"disc_number":1,"duration_ms":245186,"explicit":false,"external_ids":{"isrc":"GBAHS1200174"},"external_urls":{"spotify":"https://open.spotify.com/track/4ht1Jl1SpdFrefhq5UOulr"},"href":"https://api.spotify.com/v1/tracks/4ht1Jl1SpdFrefhq5UOulr","id":"4ht1Jl1SpdFrefhq5UOulr","is_local":false,"is_playable":true,"name":"Feel the Love (feat. John Newman)","track_number":1,"type":"track","uri":"spotify:track:4ht1Jl1SpdFrefhq5UOulr"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"}],"external_urls":{"spotify":"https://open.spotify.com/album/20GP9WmumQUDzvXYPOAnpX"},"href":"https://api.spotify.com/v1/albums/20GP9WmumQUDzvXYPOAnpX","id":"20GP9WmumQUDzvXYPOAnpX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273983f3d17ffbb57c2c4cdb1c8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02983f3d17ffbb57c2c4cdb1c8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851983f3d17ffbb57c2c4cdb1c8"}],"is_playable":true,"name":"Home (Deluxe Edition)","release_date":"2013-04-05","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:20GP9WmumQUDzvXYPOAnpX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4WN5naL3ofxrVBgFpguzKo"},"href":"https://api.spotify.com/v1/artists/4WN5naL3ofxrVBgFpguzKo","id":"4WN5naL3ofxrVBgFpguzKo","name":"Rudimental","type":"artist","uri":"spotify:artist:4WN5naL3ofxrVBgFpguzKo"},{"external_urls":{"spotify":"https://open.spotify.com/artist/34v5MVKeQnIo0CWYMbbrPf"},"href":"https://api.spotify.com/v1/artists/34v5MVKeQnIo0CWYMbbrPf","id":"34v5MVKeQnIo0CWYMbbrPf","name":"John Newman","type":"artist","uri":"spotify:artist:34v5MVKeQnIo0CWYMbbrPf"}],"disc_number":1,"duration_ms":245186,"explicit":false,"external_ids":{"isrc":"GBAHS1200174"},"external_urls":{"spotify":"https://open.spotify.com/track/5gwLW5xV9Z1jy8MsUswEQL"},"href":"https://api.spotify.com/v1/tracks/5gwLW5xV9Z1jy8MsUswEQL","id":"5gwLW5xV9Z1jy8MsUswEQL","is_local":false,"is_playable":true,"name":"Feel the Love (feat. John Newman)","track_number":2,"type":"track","uri":"spotify:track:5gwLW5xV9Z1jy8MsUswEQL"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkZlZWwlMjBUaGUlMjBMb3ZlJTIyJTIwYXJ0aXN0JTNBJTIyUnVkaW1lbnRhbCUyMiZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjpudWxsLCJvZmZzZXQiOjAsInByZXZpb3VzIjpudWxsLCJ0b3RhbCI6OSwiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFdONW5hTDNvZnhyVkJnRnBndXpLbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80V041bmFMM29meHJWQmdGcGd1ektvIiwiaWQiOiI0V041bmFMM29meHJWQmdGcGd1ektvIiwibmFtZSI6IlJ1ZGltZW50YWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFdONW5hTDNvZnhyVkJnRnBndXpLbyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzJBT3BiaXRKTk12S2hTYnNpMllENEYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8yQU9wYml0Sk5NdktoU2JzaTJZRDRGIiwiaWQiOiIyQU9wYml0Sk5NdktoU2JzaTJZRDRGIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzE0NjhkYzM5MTFjOWFiZWExZGNmOTY3NiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxNDY4ZGMzOTExYzlhYmVhMWRjZjk2NzYifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTE0NjhkYzM5MTFjOWFiZWExZGNmOTY3NiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb21lIiwicmVsZWFzZV9kYXRlIjoiMjAxMy0wNC0wNSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJBT3BiaXRKTk12S2hTYnNpMllENEYifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80V041bmFMM29meHJWQmdGcGd1ektvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJpZCI6IjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6Sw==", + "byIsIm5hbWUiOiJSdWRpbWVudGFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzR2NU1WS2VRbklvMENXWU1iYnJQZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zNHY1TVZLZVFuSW8wQ1dZTWJiclBmIiwiaWQiOiIzNHY1TVZLZVFuSW8wQ1dZTWJiclBmIiwibmFtZSI6IkpvaG4gTmV3bWFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjM0djVNVktlUW5JbzBDV1lNYmJyUGYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ1MTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFMxMjAwMTc0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8wazczbldhRDZSUHgyc0hGRWtHUGNuIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMGs3M25XYUQ2UlB4MnNIRkVrR1BjbiIsImlkIjoiMGs3M25XYUQ2UlB4MnNIRkVrR1BjbiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGZWVsIHRoZSBMb3ZlIChmZWF0LiBKb2huIE5ld21hbikiLCJ0cmFja19udW1iZXIiOjIsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MGs3M25XYUQ2UlB4MnNIRkVrR1BjbiJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFdONW5hTDNvZnhyVkJnRnBndXpLbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80V041bmFMM29meHJWQmdGcGd1ektvIiwiaWQiOiI0V041bmFMM29meHJWQmdGcGd1ektvIiwibmFtZSI6IlJ1ZGltZW50YWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFdONW5hTDNvZnhyVkJnRnBndXpLbyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZTUnd4bVFqQW5lU1N5ZmhFN2Z2MzcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82U1J3eG1RakFuZVNTeWZoRTdmdjM3IiwiaWQiOiI2U1J3eG1RakFuZVNTeWZoRTdmdjM3IiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzgzOTE0NjljZWU1MjgzNWQ2Nzk2Yg==", + "YTcxIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjgzOTE0NjljZWU1MjgzNWQ2Nzk2YmE3MSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODM5MTQ2OWNlZTUyODM1ZDY3OTZiYTcxIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZlZWwgdGhlIExvdmUgKGZlYXQuIEpvaG4gTmV3bWFuKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTItMDUtMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo1LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZTUnd4bVFqQW5lU1N5ZmhFN2Z2MzcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80V041bmFMM29meHJWQmdGcGd1ektvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJpZCI6IjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJuYW1lIjoiUnVkaW1lbnRhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0V041bmFMM29meHJWQmdGcGd1ektvIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzM0djVNVktlUW5JbzBDV1lNYmJyUGYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzR2NU1WS2VRbklvMENXWU1iYnJQZiIsImlkIjoiMzR2NU1WS2VRbklvMENXWU1iYnJQZiIsIm5hbWUiOiJKb2huIE5ld21hbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozNHY1TVZLZVFuSW8wQ1dZTWJiclBmIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NTE4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMTIwMDE3NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMG55cHN1UzJqdG9nTGFKRGNSUTRZYSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBueXBzdVMyanRvZ0xhSkRjUlE0WWEiLCJpZCI6IjBueXBzdVMyanRvZ0xhSkRjUlE0WWEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmVlbCB0aGUgTG92ZSAoZmVhdC4gSm9obiBOZXdtYW4pIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBueXBzdVMyanRvZ0xhSkRjUlE0WWEifQ==", + "LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFdONW5hTDNvZnhyVkJnRnBndXpLbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80V041bmFMM29meHJWQmdGcGd1ektvIiwiaWQiOiI0V041bmFMM29meHJWQmdGcGd1ektvIiwibmFtZSI6IlJ1ZGltZW50YWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFdONW5hTDNvZnhyVkJnRnBndXpLbyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzVoQUpLZGxMZkZibHd3bUdSMGEzTGsifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81aEFKS2RsTGZGYmx3d21HUjBhM0xrIiwiaWQiOiI1aEFKS2RsTGZGYmx3d21HUjBhM0xrIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzM5YzIxMDg5NjFkYmFhODhiNDU1NTRkYSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzOWMyMTA4OTYxZGJhYTg4YjQ1NTU0ZGEifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTM5YzIxMDg5NjFkYmFhODhiNDU1NTRkYSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGZWVsIHRoZSBMb3ZlIChmZWF0LiBKb2huIE5ld21hbikiLCJyZWxlYXNlX2RhdGUiOiIyMDEyLTA2LTEyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1aEFKS2RsTGZGYmx3d21HUjBhM0xrIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNFdONW5hTDNvZnhyVkJnRnBndXpLbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80V041bmFMM29meHJWQmdGcGd1ektvIiwiaWQiOiI0V041bmFMM29meHJWQmdGcGd1ektvIiwibmFtZSI6IlJ1ZGltZW50YWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFdONW5hTDNvZnhyVkJnRnBndXpLbyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zNHY1TVZLZVFuSW8wQ1dZTWJiclBmIn0sImhyZWYiOiJodHRwczovLw==", + "YXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzR2NU1WS2VRbklvMENXWU1iYnJQZiIsImlkIjoiMzR2NU1WS2VRbklvMENXWU1iYnJQZiIsIm5hbWUiOiJKb2huIE5ld21hbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozNHY1TVZLZVFuSW8wQ1dZTWJiclBmIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIxOTA0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMTIwMDE2MyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWNySHZFUFExM0ZiUUdRU3NjbTVOcyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVjckh2RVBRMTNGYlFHUVNzY201TnMiLCJpZCI6IjVjckh2RVBRMTNGYlFHUVNzY201TnMiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmVlbCB0aGUgTG92ZSAoZmVhdC4gSm9obiBOZXdtYW4pIC0gUmFkaW8gRWRpdCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1Y3JIdkVQUTEzRmJRR1FTc2NtNU5zIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsImlkIjoiNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsIm5hbWUiOiJSdWRpbWVudGFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS82Uk0wNWFETm1icUY3QVYxeHd1YmFjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNlJNMDVhRE5tYnFGN0FWMXh3dWJhYyIsImlkIjoiNlJNMDVhRE5tYnFGN0FWMXh3dWJhYyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM4ZDg3OWYxMDhmM2VmMWIyMDg2YzY3ZTgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyOGQ4NzlmMTA4ZjNlZjFiMjA4NmM2N2U4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NQ==", + "MThkODc5ZjEwOGYzZWYxYjIwODZjNjdlOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb21lIChEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTA0LTA1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlJNMDVhRE5tYnFGN0FWMXh3dWJhYyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsImlkIjoiNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsIm5hbWUiOiJSdWRpbWVudGFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNjdud2ozWTVzWlFMbDcyVk5VSEVZRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82N253ajNZNXNaUUxsNzJWTlVIRVlFIiwiaWQiOiI2N253ajNZNXNaUUxsNzJWTlVIRVlFIiwibmFtZSI6IldhbGUiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Njdud2ozWTVzWlFMbDcyVk5VSEVZRSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyMzYwMDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIUzEzMDAyODQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBvalU0STdGRGJ0a3ZoNGxua1BJMUMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wb2pVNEk3RkRidGt2aDRsbmtQSTFDIiwiaWQiOiIwb2pVNEk3RkRidGt2aDRsbmtQSTFDIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZlZWwgdGhlIExvdmUgKGZlYXQuIFdhbGUpIiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowb2pVNEk3RkRidGt2aDRsbmtQSTFDIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsImlkIg==", + "OiI0V041bmFMM29meHJWQmdGcGd1ektvIiwibmFtZSI6IlJ1ZGltZW50YWwiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NFdONW5hTDNvZnhyVkJnRnBndXpLbyJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzZSTTA1YURObWJxRjdBVjF4d3ViYWMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy82Uk0wNWFETm1icUY3QVYxeHd1YmFjIiwiaWQiOiI2Uk0wNWFETm1icUY3QVYxeHd1YmFjIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzhkODc5ZjEwOGYzZWYxYjIwODZjNjdlOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI4ZDg3OWYxMDhmM2VmMWIyMDg2YzY3ZTgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MThkODc5ZjEwOGYzZWYxYjIwODZjNjdlOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb21lIChEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTA0LTA1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NlJNMDVhRE5tYnFGN0FWMXh3dWJhYyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsImlkIjoiNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsIm5hbWUiOiJSdWRpbWVudGFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzR2NU1WS2VRbklvMENXWU1iYnJQZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zNHY1TVZLZVFuSW8wQ1dZTWJiclBmIiwiaWQiOiIzNHY1TVZLZVFuSW8wQ1dZTWJiclBmIiwibmFtZSI6IkpvaG4gTmV3bWFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjM0djVNVktlUW5JbzBDV1lNYmJyUGYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ1MTg2LCJleHBsaWNpdA==", + "IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkFIUzEyMDAxNzQifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJWdkNvcUY0cDQ2Y3Z5VmJoYkRzYUoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yVnZDb3FGNHA0NmN2eVZiaGJEc2FKIiwiaWQiOiIyVnZDb3FGNHA0NmN2eVZiaGJEc2FKIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZlZWwgdGhlIExvdmUgKGZlYXQuIEpvaG4gTmV3bWFuKSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyVnZDb3FGNHA0NmN2eVZiaGJEc2FKIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsImlkIjoiNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsIm5hbWUiOiJSdWRpbWVudGFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zazVhd3l4ZmZsUXNpQ1J1d1VmYm0zIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2s1YXd5eGZmbFFzaUNSdXdVZmJtMyIsImlkIjoiM2s1YXd5eGZmbFFzaUNSdXdVZmJtMyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMwYjk1NDA1NWJlNDJlMjNhZWRmZDljYzMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMGI5NTQwNTViZTQyZTIzYWVkZmQ5Y2MzIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTEwYjk1NDA1NWJlNDJlMjNhZWRmZDljYzMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSG9tZSAoMTB0aCBBbm5pdmVyc2FyeSBFZGl0aW9uKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDQtMDUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyMSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozazVhd3l4ZmZsUXNpQ1J1d1VmYm0zIg==", + "fSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80V041bmFMM29meHJWQmdGcGd1ektvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJpZCI6IjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJuYW1lIjoiUnVkaW1lbnRhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0V041bmFMM29meHJWQmdGcGd1ektvIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzM0djVNVktlUW5JbzBDV1lNYmJyUGYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzR2NU1WS2VRbklvMENXWU1iYnJQZiIsImlkIjoiMzR2NU1WS2VRbklvMENXWU1iYnJQZiIsIm5hbWUiOiJKb2huIE5ld21hbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozNHY1TVZLZVFuSW8wQ1dZTWJiclBmIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NTE4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMTIwMDE3NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNVNHTWFBUURiRzNLUTZwVHpLdzRSUiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVTR01hQVFEYkczS1E2cFR6S3c0UlIiLCJpZCI6IjVTR01hQVFEYkczS1E2cFR6S3c0UlIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiRmVlbCB0aGUgTG92ZSAoZmVhdC4gSm9obiBOZXdtYW4pIiwidHJhY2tfbnVtYmVyIjoyLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjVTR01hQVFEYkczS1E2cFR6S3c0UlIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNnZJZU1CUnlrWHBNTDVZWkVKeGNLaw==", + "In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNnZJZU1CUnlrWHBNTDVZWkVKeGNLayIsImlkIjoiNnZJZU1CUnlrWHBNTDVZWkVKeGNLayIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlYzZhYTIxZWQyMmNhMDZlMDMyNmZjODgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZWM2YWEyMWVkMjJjYTA2ZTAzMjZmYzg4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlYzZhYTIxZWQyMmNhMDZlMDMyNmZjODgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWm9tZXJoaXRzIEFsbGVydGlqZGVuIiwicmVsZWFzZV9kYXRlIjoiMjAyMy0wNC0xNCIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjQwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjZ2SWVNQlJ5a1hwTUw1WVpFSnhjS2sifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80V041bmFMM29meHJWQmdGcGd1ektvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJpZCI6IjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJuYW1lIjoiUnVkaW1lbnRhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0V041bmFMM29meHJWQmdGcGd1ektvIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzM0djVNVktlUW5JbzBDV1lNYmJyUGYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMzR2NU1WS2VRbklvMENXWU1iYnJQZiIsImlkIjoiMzR2NU1WS2VRbklvMENXWU1iYnJQZiIsIm5hbWUiOiJKb2huIE5ld21hbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozNHY1TVZLZVFuSW8wQ1dZTWJiclBmIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NTE4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQUhTMTIwMDE3NCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMGw3NlozVFlaRnpDSGphZFJxMTMxZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBsNzZaM1RZWkZ6Q0hqYWRScQ==", + "MTMxZSIsImlkIjoiMGw3NlozVFlaRnpDSGphZFJxMTMxZSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGZWVsIHRoZSBMb3ZlIiwidHJhY2tfbnVtYmVyIjoxMiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowbDc2WjNUWVpGekNIamFkUnExMzFlIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80V041bmFMM29meHJWQmdGcGd1ektvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJpZCI6IjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJuYW1lIjoiUnVkaW1lbnRhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0V041bmFMM29meHJWQmdGcGd1ektvIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMzhrWnh5MlhrYWdZb3ZVTlJqQ0RTVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzM4a1p4eTJYa2FnWW92VU5SakNEU1ciLCJpZCI6IjM4a1p4eTJYa2FnWW92VU5SakNEU1ciLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZDhlMmEwZDhjODU0ZDQ3MDA3ZGRjMWRjIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmQ4ZTJhMGQ4Yzg1NGQ0NzAwN2RkYzFkYyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZDhlMmEwZDhjODU0ZDQ3MDA3ZGRjMWRjIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkZlZWwgdGhlIExvdmUgKGZlYXQuIEpvaG4gTmV3bWFuKSIsInJlbGVhc2VfZGF0ZSI6IjIwMTMtMDMtMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjM4a1p4eTJYa2FnWW92VU5SakNEU1cifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80V041bmFMM29meHJWQmdGcGd1ektvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJpZCI6IjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJuYW1lIjoiUnVkaQ==", + "bWVudGFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzR2NU1WS2VRbklvMENXWU1iYnJQZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zNHY1TVZLZVFuSW8wQ1dZTWJiclBmIiwiaWQiOiIzNHY1TVZLZVFuSW8wQ1dZTWJiclBmIiwibmFtZSI6IkpvaG4gTmV3bWFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjM0djVNVktlUW5JbzBDV1lNYmJyUGYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ1MTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFMxMjAwMTc0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80aHQxSmwxU3BkRnJlZmhxNVVPdWxyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNGh0MUpsMVNwZEZyZWZocTVVT3VsciIsImlkIjoiNGh0MUpsMVNwZEZyZWZocTVVT3VsciIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJGZWVsIHRoZSBMb3ZlIChmZWF0LiBKb2huIE5ld21hbikiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NGh0MUpsMVNwZEZyZWZocTVVT3VsciJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80V041bmFMM29meHJWQmdGcGd1ektvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJpZCI6IjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28iLCJuYW1lIjoiUnVkaW1lbnRhbCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0V041bmFMM29meHJWQmdGcGd1ektvIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMjBHUDlXbXVtUVVEenZYWVBPQW5wWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEv", + "YWxidW1zLzIwR1A5V211bVFVRHp2WFlQT0FucFg=", + "IiwiaWQiOiIyMEdQOVdtdW1RVUR6dlhZUE9BbnBYIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3Mzk4M2YzZDE3ZmZiYjU3YzJjNGNkYjFjOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5ODNmM2QxN2ZmYmI1N2MyYzRjZGIxYzgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTk4M2YzZDE3ZmZiYjU3YzJjNGNkYjFjOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIb21lIChEZWx1eGUgRWRpdGlvbikiLCJyZWxlYXNlX2RhdGUiOiIyMDEzLTA0LTA1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MjBHUDlXbXVtUVVEenZYWVBPQW5wWCJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsImlkIjoiNFdONW5hTDNvZnhyVkJnRnBndXpLbyIsIm5hbWUiOiJSdWRpbWVudGFsIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRXTjVuYUwzb2Z4clZCZ0ZwZ3V6S28ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzR2NU1WS2VRbklvMENXWU1iYnJQZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zNHY1TVZLZVFuSW8wQ1dZTWJiclBmIiwiaWQiOiIzNHY1TVZLZVFuSW8wQ1dZTWJiclBmIiwibmFtZSI6IkpvaG4gTmV3bWFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjM0djVNVktlUW5JbzBDV1lNYmJyUGYifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQ1MTg2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JBSFMxMjAwMTc0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay81Z3dMVzV4VjlaMWp5OE1zVXN3RVFMIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNWd3TFc1eFY5WjFqeThNc1Vzd0VRTCIsImlkIjoiNWd3TFc1eFY5WjFqeThNc1Vzd0VRTCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOg==", + "dHJ1ZSwibmFtZSI6IkZlZWwgdGhlIExvdmUgKGZlYXQuIEpvaG4gTmV3bWFuKSIsInRyYWNrX251bWJlciI6MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1Z3dMVzV4VjlaMWp5OE1zVXN3RVFMIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Feel+The+Love%22+artist%3A%22Rudimental%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Sweet%20Talker%20Sigma&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Sweet%20Talker%20Sigma&type=track","offset":0,"previous":null,"total":13,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5vBSrE1xujD2FXYRarbAXc"},"href":"https://api.spotify.com/v1/artists/5vBSrE1xujD2FXYRarbAXc","id":"5vBSrE1xujD2FXYRarbAXc","name":"Olly Alexander (Years & Years)","type":"artist","uri":"spotify:artist:5vBSrE1xujD2FXYRarbAXc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4sTQVOfp9vEMCemLw50sbu"},"href":"https://api.spotify.com/v1/artists/4sTQVOfp9vEMCemLw50sbu","id":"4sTQVOfp9vEMCemLw50sbu","name":"Galantis","type":"artist","uri":"spotify:artist:4sTQVOfp9vEMCemLw50sbu"}],"external_urls":{"spotify":"https://open.spotify.com/album/301gSTTWjmjIa1M6Hx4hPT"},"href":"https://api.spotify.com/v1/albums/301gSTTWjmjIa1M6Hx4hPT","id":"301gSTTWjmjIa1M6Hx4hPT","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734cfe5cdd428a45bc334a8d6b"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024cfe5cdd428a45bc334a8d6b"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514cfe5cdd428a45bc334a8d6b"}],"is_playable":true,"name":"Sweet Talker","release_date":"2021-11-24","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:301gSTTWjmjIa1M6Hx4hPT"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5vBSrE1xujD2FXYRarbAXc"},"href":"https://api.spotify.com/v1/artists/5vBSrE1xujD2FXYRarbAXc","id":"5vBSrE1xujD2FXYRarbAXc","name":"Olly Alexander (Years & Years)","type":"artist","uri":"spotify:artist:5vBSrE1xujD2FXYRarbAXc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4sTQVOfp9vEMCemLw50sbu"},"href":"https://api.spotify.com/v1/artists/4sTQVOfp9vEMCemLw50sbu","id":"4sTQVOfp9vEMCemLw50sbu","name":"Galantis","type":"artist","uri":"spotify:artist:4sTQVOfp9vEMCemLw50sbu"}],"disc_number":1,"duration_ms":176930,"explicit":false,"external_ids":{"isrc":"GBUM72103423"},"external_urls":{"spotify":"https://open.spotify.com/track/6FRxFke9VsjXmibGgSeKki"},"href":"https://api.spotify.com/v1/tracks/6FRxFke9VsjXmibGgSeKki","id":"6FRxFke9VsjXmibGgSeKki","is_local":false,"is_playable":true,"name":"Sweet Talker","track_number":1,"type":"track","uri":"spotify:track:6FRxFke9VsjXmibGgSeKki"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5vBSrE1xujD2FXYRarbAXc"},"href":"https://api.spotify.com/v1/artists/5vBSrE1xujD2FXYRarbAXc","id":"5vBSrE1xujD2FXYRarbAXc","name":"Olly Alexander (Years & Years)","type":"artist","uri":"spotify:artist:5vBSrE1xujD2FXYRarbAXc"}],"external_urls":{"spotify":"https://open.spotify.com/album/5JnUGpLYBxqEDuot5vlfSC"},"href":"https://api.spotify.com/v1/albums/5JnUGpLYBxqEDuot5vlfSC","id":"5JnUGpLYBxqEDuot5vlfSC","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e7523d8a01238dda4e547727"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e7523d8a01238dda4e547727"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e7523d8a01238dda4e547727"}],"is_playable":true,"name":"Night Call (Deluxe)","release_date":"2022-01-21","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5JnUGpLYBxqEDuot5vlfSC"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5vBSrE1xujD2FXYRarbAXc"},"href":"https://api.spotify.com/v1/artists/5vBSrE1xujD2FXYRarbAXc","id":"5vBSrE1xujD2FXYRarbAXc","name":"Olly Alexander (Years & Years)","type":"artist","uri":"spotify:artist:5vBSrE1xujD2FXYRarbAXc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4sTQVOfp9vEMCemLw50sbu"},"href":"https://api.spotify.com/v1/artists/4sTQVOfp9vEMCemLw50sbu","id":"4sTQVOfp9vEMCemLw50sbu","name":"Galantis","type":"artist","uri":"spotify:artist:4sTQVOfp9vEMCemLw50sbu"}],"disc_number":1,"duration_ms":177661,"explicit":false,"external_ids":{"isrc":"GBUM72103423"},"external_urls":{"spotify":"https://open.spotify.com/track/4UrkPTyYTshiX5Kwfbggwm"},"href":"https://api.spotify.com/v1/tracks/4UrkPTyYTshiX5Kwfbggwm","id":"4UrkPTyYTshiX5Kwfbggwm","is_local":false,"is_playable":true,"name":"Sweet Talker","track_number":6,"type":"track","uri":"spotify:track:4UrkPTyYTshiX5Kwfbggwm"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/24XtlMhEMNdi822vi0MhY1"},"href":"https://api.spotify.com/v1/artists/24XtlMhEMNdi822vi0MhY1","id":"24XtlMhEMNdi822vi0MhY1","name":"Taking Back Sunday","type":"artist","uri":"spotify:artist:24XtlMhEMNdi822vi0MhY1"}],"external_urls":{"spotify":"https://open.spotify.com/album/0gBSoXYKsE3HHZNbgMPnEg"},"href":"https://api.spotify.com/v1/albums/0gBSoXYKsE3HHZNbgMPnEg","id":"0gBSoXYKsE3HHZNbgMPnEg","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731fc8bc00af1c877377d1dcf8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021fc8bc00af1c877377d1dcf8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511fc8bc00af1c877377d1dcf8"}],"is_playable":true,"name":"Tell All Your Friends (Remastered)","release_date":"2002-03-26","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:0gBSoXYKsE3HHZNbgMPnEg"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/24XtlMhEMNdi822vi0MhY1"},"href":"https://api.spotify.com/v1/artists/24XtlMhEMNdi822vi0MhY1","id":"24XtlMhEMNdi822vi0MhY1","name":"Taking Back Sunday","type":"artist","uri":"spotify:artist:24XtlMhEMNdi822vi0MhY1"}],"disc_number":1,"duration_ms":212937,"explicit":false,"external_ids":{"isrc":"USC4R1901592"},"external_urls":{"spotify":"https://open.spotify.com/track/6OyKBwLzq4h15XmxeWf5n4"},"href":"https://api.spotify.com/v1/tracks/6OyKBwLzq4h15XmxeWf5n4","id":"6OyKBwLzq4h15XmxeWf5n4","is_local":false,"is_playable":true,"name":"Cute Without The 'E' (Cut From The Team) - Remastered 2019","track_number":3,"type":"track","uri":"spotify:track:6OyKBwLzq4h15XmxeWf5n4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/24XtlMhEMNdi822vi0MhY1"},"href":"https://api.spotify.com/v1/artists/24XtlMhEMNdi822vi0MhY1","id":"24XtlMhEMNdi822vi0MhY1","name":"Taking Back Sunday","type":"artist","uri":"spotify:artist:24XtlMhEMNdi822vi0MhY1"}],"external_urls":{"spotify":"https://open.spotify.com/album/5vXgzBXFBLdsE22WvrkmjG"},"href":"https://api.spotify.com/v1/albums/5vXgzBXFBLdsE22WvrkmjG","id":"5vXgzBXFBLdsE22WvrkmjG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734f4f59a3c87b7fab342b0bb8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024f4f59a3c87b7fab342b0bb8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514f4f59a3c87b7fab342b0bb8"}],"is_playable":true,"name":"Tell All Your Friends (20th Anniversary Edition)","release_date":"2022-05-27","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:5vXgzBXFBLdsE22WvrkmjG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/24XtlMhEMNdi822vi0MhY1"},"href":"https://api.spotify.com/v1/artists/24XtlMhEMNdi822vi0MhY1","id":"24XtlMhEMNdi822vi0MhY1","name":"Taking Back Sunday","type":"artist","uri":"spotify:artist:24XtlMhEMNdi822vi0MhY1"}],"disc_number":1,"duration_ms":211546,"explicit":false,"external_ids":{"isrc":"USVIC0528603"},"external_urls":{"spotify":"https://open.spotify.com/track/0ObyshwXoUY4NTib9v2eji"},"href":"https://api.spotify.com/v1/tracks/0ObyshwXoUY4NTib9v2eji","id":"0ObyshwXoUY4NTib9v2eji","is_local":false,"is_playable":true,"name":"Cute Without The 'E' (Cut From The Team)","track_number":3,"type":"track","uri":"spotify:track:0ObyshwXoUY4NTib9v2eji"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4IJczjB0fJ04gs4uvP0Fli"},"href":"https://api.spotify.com/v1/artists/4IJczjB0fJ04gs4uvP0Fli","id":"4IJczjB0fJ04gs4uvP0Fli","name":"Gym Class Heroes","type":"artist","uri":"spotify:artist:4IJczjB0fJ04gs4uvP0Fli"}],"external_urls":{"spotify":"https://open.spotify.com/album/7oudPjsM2U10YTaWOPRVxm"},"href":"https://api.spotify.com/v1/albums/7oudPjsM2U10YTaWOPRVxm","id":"7oudPjsM2U10YTaWOPRVxm","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2736c3cac3cd03598c43eaf3663"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e026c3cac3cd03598c43eaf3663"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048516c3cac3cd03598c43eaf3663"}],"is_playable":true,"name":"As Cruel as School Children","release_date":"2006-07-25","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:7oudPjsM2U10YTaWOPRVxm"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4IJczjB0fJ04gs4uvP0Fli"},"href":"https://api.spotify.com/v1/artists/4IJczjB0fJ04gs4uvP0Fli","id":"4IJczjB0fJ04gs4uvP0Fli","name":"Gym Class Heroes","type":"artist","uri":"spotify:artist:4IJczjB0fJ04gs4uvP0Fli"}],"disc_number":1,"duration_ms":235480,"explicit":true,"external_ids":{"isrc":"USAT20615049"},"external_urls":{"spotify":"https://open.spotify.com/track/6miqdoICzUXCL5UHCuucjK"},"href":"https://api.spotify.com/v1/tracks/6miqdoICzUXCL5UHCuucjK","id":"6miqdoICzUXCL5UHCuucjK","is_local":false,"is_playable":true,"name":"Clothes Off!!","track_number":4,"type":"track","uri":"spotify:track:6miqdoICzUXCL5UHCuucjK"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5XMOcV8vxoURwfLzyBmLr4"},"href":"https://api.spotify.com/v1/albums/5XMOcV8vxoURwfLzyBmLr4","id":"5XMOcV8vxoURwfLzyBmLr4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b21e1ecf50eacba327b31f90"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b21e1ecf50eacba327b31f90"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b21e1ecf50eacba327b31f90"}],"is_playable":true,"name":"UK Party Hits","release_date":"2026-08-07","release_date_precision":"day","total_tracks":60,"type":"album","uri":"spotify:album:5XMOcV8vxoURwfLzyBmLr4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5vBSrE1xujD2FXYRarbAXc"},"href":"https://api.spotify.com/v1/artists/5vBSrE1xujD2FXYRarbAXc","id":"5vBSrE1xujD2FXYRarbAXc","name":"Olly Alexander (Years & Years)","type":"artist","uri":"spotify:artist:5vBSrE1xujD2FXYRarbAXc"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4sTQVOfp9vEMCemLw50sbu"},"href":"https://api.spotify.com/v1/artists/4sTQVOfp9vEMCemLw50sbu","id":"4sTQVOfp9vEMCemLw50sbu","name":"Galantis","type":"artist","uri":"spotify:artist:4sTQVOfp9vEMCemLw50sbu"}],"disc_number":1,"duration_ms":176930,"explicit":false,"external_ids":{"isrc":"GBUM72103423"},"external_urls":{"spotify":"https://open.spotify.com/track/0NLHYnTsOxQNrw5ClEhd0g"},"href":"https://api.spotify.com/v1/tracks/0NLHYnTsOxQNrw5ClEhd0g","id":"0NLHYnTsOxQNrw5ClEhd0g","is_local":false,"is_playable":true,"name":"Sweet Talker","track_number":52,"type":"track","uri":"spotify:track:0NLHYnTsOxQNrw5ClEhd0g"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hAESk8f3x4WDB21ndXVY9"},"href":"https://api.spotify.com/v1/artists/7hAESk8f3x4WDB21ndXVY9","id":"7hAESk8f3x4WDB21ndXVY9","name":"Sian Murray","type":"artist","uri":"spotify:artist:7hAESk8f3x4WDB21ndXVY9"}],"external_urls":{"spotify":"https://open.spotify.com/album/7uUqUdNNgAmVld0T0CWw6s"},"href":"https://api.spotify.com/v1/albums/7uUqUdNNgAmVld0T0CWw6s","id":"7uUqUdNNgAmVld0T0CWw6s","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273060e1c397a869eb8476bc82f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02060e1c397a869eb8476bc82f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851060e1c397a869eb8476bc82f"}],"is_playable":true,"name":"Your Sweet Love","release_date":"2023-05-05","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7uUqUdNNgAmVld0T0CWw6s"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7hAESk8f3x4WDB21ndXVY9"},"href":"https://api.spotify.com/v1/artists/7hAESk8f3x4WDB21ndXVY9","id":"7hAESk8f3x4WDB21ndXVY9","name":"Sian Murray","type":"artist","uri":"spotify:artist:7hAESk8f3x4WDB21ndXVY9"}],"disc_number":1,"duration_ms":65275,"explicit":false,"external_ids":{"isrc":"QZS642322018"},"external_urls":{"spotify":"https://open.spotify.com/track/2pBTXPkW0GvnNPdyL2AVVU"},"href":"https://api.spotify.com/v1/tracks/2pBTXPkW0GvnNPdyL2AVVU","id":"2pBTXPkW0GvnNPdyL2AVVU","is_local":false,"is_playable":true,"name":"Your Sweet Love","track_number":1,"type":"track","uri":"spotify:track:2pBTXPkW0GvnNPdyL2AVVU"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35P9JN66RmM6oED0Cy1DdP"},"href":"https://api.spotify.com/v1/artists/35P9JN66RmM6oED0Cy1DdP","id":"35P9JN66RmM6oED0Cy1DdP","name":"DJ Nashor","type":"artist","uri":"spotify:artist:35P9JN66RmM6oED0Cy1DdP"}],"external_urls":{"spotify":"https://open.spotify.com/album/1NkAggluMzyj1KI70wrduA"},"href":"https://api.spotify.com/v1/albums/1NkAggluMzyj1KI70wrduA","id":"1NkAggluMzyj1KI70wrduA","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27325922a1cfdcc3f920a461825"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0225922a1cfdcc3f920a461825"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485125922a1cfdcc3f920a461825"}],"is_playable":true,"name":"Sweet Dreams","release_date":"2024-07-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1NkAggluMzyj1KI70wrduA"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/35P9JN66RmM6oED0Cy1DdP"},"href":"https://api.spotify.com/v1/artists/35P9JN66RmM6oED0Cy1DdP","id":"35P9JN66RmM6oED0Cy1DdP","name":"DJ Nashor","type":"artist","uri":"spotify:artist:35P9JN66RmM6oED0Cy1DdP"}],"disc_number":1,"duration_ms":168834,"explicit":false,"external_ids":{"isrc":"GBKQU2468830"},"external_urls":{"spotify":"https://open.spotify.com/track/1xIPU06N4b2R4vBgquaQxV"},"href":"https://api.spotify.com/v1/tracks/1xIPU06N4b2R4vBgquaQxV","id":"1xIPU06N4b2R4vBgquaQxV","is_local":false,"is_playable":true,"name":"Sweet Dreams","track_number":1,"type":"track","uri":"spotify:track:1xIPU06N4b2R4vBgquaQxV"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7BYLAgXd3LygQ9aJupZ6p8"},"href":"https://api.spotify.com/v1/artists/7BYLAgXd3LygQ9aJupZ6p8","id":"7BYLAgXd3LygQ9aJupZ6p8","name":"Autumn Kings","type":"artist","uri":"spotify:artist:7BYLAgXd3LygQ9aJupZ6p8"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5T0Vi8WwwfjX9tmUI9Mae9"},"href":"https://api.spotify.com/v1/artists/5T0Vi8WwwfjX9tmUI9Mae9","id":"5T0Vi8WwwfjX9tmUI9Mae9","name":"Howard Jones","type":"artist","uri":"spotify:artist:5T0Vi8WwwfjX9tmUI9Mae9"}],"external_urls":{"spotify":"https://open.spotify.com/album/2XUiKVDAArlT0zMjz8Uzb1"},"href":"https://api.spotify.com/v1/albums/2XUiKVDAArlT0zMjz8Uzb1","id":"2XUiKVDAArlT0zMjz8Uzb1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731cb216e362fc4039bcf2c14a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021cb216e362fc4039bcf2c14a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511cb216e362fc4039bcf2c14a"}],"is_playable":true,"name":"yOunG BLoOds (feat. Howard Jones)","release_date":"2026-08-06","release_date_precision":"day","total_tracks":7,"type":"album","uri":"spotify:album:2XUiKVDAArlT0zMjz8Uzb1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7BYLAgXd3LygQ9aJupZ6p8"},"href":"https://api.spotify.com/v1/artists/7BYLAgXd3LygQ9aJupZ6p8","id":"7BYLAgXd3LygQ9aJupZ6p8","name":"Autumn Kings","type":"artist","uri":"spotify:artist:7BYLAgXd3LygQ9aJupZ6p8"}],"disc_number":1,"duration_ms":195092,"explicit":false,"external_ids":{"isrc":"USHR22517301"},"external_urls":{"spotify":"https://open.spotify.com/track/3oxSbsLx8jdAmjfYaTCJvI"},"href":"https://api.spotify.com/v1/tracks/3oxSbsLx8jdAmjfYaTCJvI","id":"3oxSbsLx8jdAmjfYaTCJvI","is_local":false,"is_playable":true,"name":"Snake Charmer","track_number":5,"type":"track","uri":"spotify:track:3oxSbsLx8jdAmjfYaTCJvI"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7BYLAgXd3LygQ9aJupZ6p8"},"href":"https://api.spotify.com/v1/artists/7BYLAgXd3LygQ9aJupZ6p8","id":"7BYLAgXd3LygQ9aJupZ6p8","name":"Autumn Kings","type":"artist","uri":"spotify:artist:7BYLAgXd3LygQ9aJupZ6p8"}],"external_urls":{"spotify":"https://open.spotify.com/album/76d8RlxUHZepdUNIr8J1YK"},"href":"https://api.spotify.com/v1/albums/76d8RlxUHZepdUNIr8J1YK","id":"76d8RlxUHZepdUNIr8J1YK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735685a1c29a80222fe1a46be6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025685a1c29a80222fe1a46be6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515685a1c29a80222fe1a46be6"}],"is_playable":true,"name":"Snake Charmer","release_date":"2025-02-13","release_date_precision":"day","total_tracks":3,"type":"album","uri":"spotify:album:76d8RlxUHZepdUNIr8J1YK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7BYLAgXd3LygQ9aJupZ6p8"},"href":"https://api.spotify.com/v1/artists/7BYLAgXd3LygQ9aJupZ6p8","id":"7BYLAgXd3LygQ9aJupZ6p8","name":"Autumn Kings","type":"artist","uri":"spotify:artist:7BYLAgXd3LygQ9aJupZ6p8"}],"disc_number":1,"duration_ms":195092,"explicit":false,"external_ids":{"isrc":"USHR22517301"},"external_urls":{"spotify":"https://open.spotify.com/track/3pB36nmEkDqtOurUCmREUj"},"href":"https://api.spotify.com/v1/tracks/3pB36nmEkDqtOurUCmREUj","id":"3pB36nmEkDqtOurUCmREUj","is_local":false,"is_playable":true,"name":"Snake Charmer","track_number":1,"type":"track","uri":"spotify:track:3pB36nmEkDqtOurUCmREUj"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1Td2VldCUyMFRhbGtlciUyMFNpZ21hJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9zZWFyY2g/b2Zmc2V0PTEwJmxpbWl0PTEwJnF1ZXJ5PVN3ZWV0JTIwVGFsa2VyJTIwU2lnbWEmdHlwZT10cmFjayIsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjoxMywiaXRlbXMiOlt7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzV2QlNyRTF4dWpEMkZYWVJhcmJBWGMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNXZCU3JFMXh1akQyRlhZUmFyYkFYYyIsImlkIjoiNXZCU3JFMXh1akQyRlhZUmFyYkFYYyIsIm5hbWUiOiJPbGx5IEFsZXhhbmRlciAoWWVhcnMgJiBZZWFycykiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NXZCU3JFMXh1akQyRlhZUmFyYkFYYyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80c1RRVk9mcDl2RU1DZW1MdzUwc2J1In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRzVFFWT2ZwOXZFTUNlbUx3NTBzYnUiLCJpZCI6IjRzVFFW", + "T2ZwOXZFTUNlbUx3NTBzYnUiLCJuYW1lIjoiR2FsYW50aXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6NHNUUVZPZnA5dkVNQ2VtTHc1MHNidSJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzMwMWdTVFRXam1qSWExTTZIeDRoUFQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8zMDFnU1RUV2ptaklhMU02SHg0aFBUIiwiaWQiOiIzMDFnU1RUV2ptaklhMU02SHg0aFBUIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzRjZmU1Y2RkNDI4YTQ1YmMzMzRhOGQ2YiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI0Y2ZlNWNkZDQyOGE0NWJjMzM0YThkNmIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTRjZmU1Y2RkNDI4YTQ1YmMzMzRhOGQ2YiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTd2VldCBUYWxrZXIiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTExLTI0IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTozMDFnU1RUV2ptaklhMU02SHg0aFBUIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXZCU3JFMXh1akQyRlhZUmFyYkFYYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81dkJTckUxeHVqRDJGWFlSYXJiQVhjIiwiaWQiOiI1dkJTckUxeHVqRDJGWFlSYXJiQVhjIiwibmFtZSI6Ik9sbHkgQWxleGFuZGVyIChZZWFycyAmIFllYXJzKSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1dkJTckUxeHVqRDJGWFlSYXJiQVhjIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRzVFFWT2ZwOXZFTUNlbUx3NTBzYnUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHNUUVZPZnA5dkVNQ2VtTHc1MHNidSIsImlkIjoiNHNUUVZPZnA5dkVNQ2VtTHc1MHNidSIsIm5hbWUiOiJHYWxhbnRpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0c1RRVk9mcDl2RU1DZW1MdzUwc2J1In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3NjkzMCwiZXhwbGljaXQiOg==", + "ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JVTTcyMTAzNDIzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82RlJ4RmtlOVZzalhtaWJHZ1NlS2tpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNkZSeEZrZTlWc2pYbWliR2dTZUtraSIsImlkIjoiNkZSeEZrZTlWc2pYbWliR2dTZUtraSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTd2VldCBUYWxrZXIiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NkZSeEZrZTlWc2pYbWliR2dTZUtraSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81dkJTckUxeHVqRDJGWFlSYXJiQVhjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV2QlNyRTF4dWpEMkZYWVJhcmJBWGMiLCJpZCI6IjV2QlNyRTF4dWpEMkZYWVJhcmJBWGMiLCJuYW1lIjoiT2xseSBBbGV4YW5kZXIgKFllYXJzICYgWWVhcnMpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV2QlNyRTF4dWpEMkZYWVJhcmJBWGMifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81Sm5VR3BMWUJ4cUVEdW90NXZsZlNDIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNUpuVUdwTFlCeHFFRHVvdDV2bGZTQyIsImlkIjoiNUpuVUdwTFlCeHFFRHVvdDV2bGZTQyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNlNzUyM2Q4YTAxMjM4ZGRhNGU1NDc3MjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyZTc1MjNkOGEwMTIzOGRkYTRlNTQ3NzI3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFlNzUyM2Q4YTAxMjM4ZGRhNGU1NDc3MjcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTmlnaHQgQ2FsbCAoRGVsdXhlKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjItMDEtMjEiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1Sm5VR3BMWUJ4cUVEdW90NXZsZlNDIn0sImFydGlzdHMiOlt7Ig==", + "ZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81dkJTckUxeHVqRDJGWFlSYXJiQVhjIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzV2QlNyRTF4dWpEMkZYWVJhcmJBWGMiLCJpZCI6IjV2QlNyRTF4dWpEMkZYWVJhcmJBWGMiLCJuYW1lIjoiT2xseSBBbGV4YW5kZXIgKFllYXJzICYgWWVhcnMpIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjV2QlNyRTF4dWpEMkZYWVJhcmJBWGMifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNHNUUVZPZnA5dkVNQ2VtTHc1MHNidSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80c1RRVk9mcDl2RU1DZW1MdzUwc2J1IiwiaWQiOiI0c1RRVk9mcDl2RU1DZW1MdzUwc2J1IiwibmFtZSI6IkdhbGFudGlzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRzVFFWT2ZwOXZFTUNlbUx3NTBzYnUifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTc3NjYxLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0JVTTcyMTAzNDIzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay80VXJrUFR5WVRzaGlYNUt3ZmJnZ3dtIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNFVya1BUeVlUc2hpWDVLd2ZiZ2d3bSIsImlkIjoiNFVya1BUeVlUc2hpWDVLd2ZiZ2d3bSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTd2VldCBUYWxrZXIiLCJ0cmFja19udW1iZXIiOjYsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6NFVya1BUeVlUc2hpWDVLd2ZiZ2d3bSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNFh0bE1oRU1OZGk4MjJ2aTBNaFkxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0WHRsTWhFTU5kaTgyMnZpME1oWTEiLCJpZCI6IjI0WHRsTWhFTU5kaTgyMnZpME1oWTEiLCJuYW1lIjoiVGFraW5nIEJhY2sgU3VuZGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0WHRsTWhFTU5kaTgyMnZpME1oWTEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8wZ0JTb1hZS3NFM0hIWk5iZ01QbkVnIn0sImhyZWYiOiJodHRwczovL2FwaQ==", + "LnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wZ0JTb1hZS3NFM0hIWk5iZ01QbkVnIiwiaWQiOiIwZ0JTb1hZS3NFM0hIWk5iZ01QbkVnIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzFmYzhiYzAwYWYxYzg3NzM3N2QxZGNmOCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIxZmM4YmMwMGFmMWM4NzczNzdkMWRjZjgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTFmYzhiYzAwYWYxYzg3NzM3N2QxZGNmOCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJUZWxsIEFsbCBZb3VyIEZyaWVuZHMgKFJlbWFzdGVyZWQpIiwicmVsZWFzZV9kYXRlIjoiMjAwMi0wMy0yNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEwLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjBnQlNvWFlLc0UzSEhaTmJnTVBuRWcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNFh0bE1oRU1OZGk4MjJ2aTBNaFkxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0WHRsTWhFTU5kaTgyMnZpME1oWTEiLCJpZCI6IjI0WHRsTWhFTU5kaTgyMnZpME1oWTEiLCJuYW1lIjoiVGFraW5nIEJhY2sgU3VuZGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0WHRsTWhFTU5kaTgyMnZpME1oWTEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjEyOTM3LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNDNFIxOTAxNTkyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82T3lLQndMenE0aDE1WG14ZVdmNW40In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNk95S0J3THpxNGgxNVhteGVXZjVuNCIsImlkIjoiNk95S0J3THpxNGgxNVhteGVXZjVuNCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDdXRlIFdpdGhvdXQgVGhlICdFJyAoQ3V0IEZyb20gVGhlIFRlYW0pIC0gUmVtYXN0ZXJlZCAyMDE5IiwidHJhY2tfbnVtYmVyIjozLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZPeUtCd0x6cTRoMTVYbXhlV2Y1bjQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybg==", + "YWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNFh0bE1oRU1OZGk4MjJ2aTBNaFkxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0WHRsTWhFTU5kaTgyMnZpME1oWTEiLCJpZCI6IjI0WHRsTWhFTU5kaTgyMnZpME1oWTEiLCJuYW1lIjoiVGFraW5nIEJhY2sgU3VuZGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0WHRsTWhFTU5kaTgyMnZpME1oWTEifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS81dlhnekJYRkJMZHNFMjJXdnJrbWpHIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNXZYZ3pCWEZCTGRzRTIyV3Zya21qRyIsImlkIjoiNXZYZ3pCWEZCTGRzRTIyV3Zya21qRyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM0ZjRmNTlhM2M4N2I3ZmFiMzQyYjBiYjgifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNGY0ZjU5YTNjODdiN2ZhYjM0MmIwYmI4In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE0ZjRmNTlhM2M4N2I3ZmFiMzQyYjBiYjgifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGVsbCBBbGwgWW91ciBGcmllbmRzICgyMHRoIEFubml2ZXJzYXJ5IEVkaXRpb24pIiwicmVsZWFzZV9kYXRlIjoiMjAyMi0wNS0yNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjE0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjV2WGd6QlhGQkxkc0UyMld2cmttakcifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yNFh0bE1oRU1OZGk4MjJ2aTBNaFkxIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI0WHRsTWhFTU5kaTgyMnZpME1oWTEiLCJpZCI6IjI0WHRsTWhFTU5kaTgyMnZpME1oWTEiLCJuYW1lIjoiVGFraW5nIEJhY2sgU3VuZGF5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjI0WHRsTWhFTU5kaTgyMnZpME1oWTEifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjExNTQ2LCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNWSUMwNTI4NjAzIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Ig==", + "aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzBPYnlzaHdYb1VZNE5UaWI5djJlamkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8wT2J5c2h3WG9VWTROVGliOXYyZWppIiwiaWQiOiIwT2J5c2h3WG9VWTROVGliOXYyZWppIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkN1dGUgV2l0aG91dCBUaGUgJ0UnIChDdXQgRnJvbSBUaGUgVGVhbSkiLCJ0cmFja19udW1iZXIiOjMsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6ME9ieXNod1hvVVk0TlRpYjl2MmVqaSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC80SUpjempCMGZKMDRnczR1dlAwRmxpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRJSmN6akIwZkowNGdzNHV2UDBGbGkiLCJpZCI6IjRJSmN6akIwZkowNGdzNHV2UDBGbGkiLCJuYW1lIjoiR3ltIENsYXNzIEhlcm9lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0SUpjempCMGZKMDRnczR1dlAwRmxpIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN291ZFBqc00yVTEwWVRhV09QUlZ4bSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdvdWRQanNNMlUxMFlUYVdPUFJWeG0iLCJpZCI6IjdvdWRQanNNMlUxMFlUYVdPUFJWeG0iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNmMzY2FjM2NkMDM1OThjNDNlYWYzNjYzIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjZjM2NhYzNjZDAzNTk4YzQzZWFmMzY2MyJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNmMzY2FjM2NkMDM1OThjNDNlYWYzNjYzIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFzIENydWVsIGFzIFNjaG9vbCBDaGlsZHJlbiIsInJlbGVhc2VfZGF0ZSI6IjIwMDYtMDctMjUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3b3VkUGpzTTJVMTBZVGFXT1BSVnhtIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbQ==", + "L2FydGlzdC80SUpjempCMGZKMDRnczR1dlAwRmxpIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzRJSmN6akIwZkowNGdzNHV2UDBGbGkiLCJpZCI6IjRJSmN6akIwZkowNGdzNHV2UDBGbGkiLCJuYW1lIjoiR3ltIENsYXNzIEhlcm9lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0SUpjempCMGZKMDRnczR1dlAwRmxpIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIzNTQ4MCwiZXhwbGljaXQiOnRydWUsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNBVDIwNjE1MDQ5In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82bWlxZG9JQ3pVWENMNVVIQ3V1Y2pLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNm1pcWRvSUN6VVhDTDVVSEN1dWNqSyIsImlkIjoiNm1pcWRvSUN6VVhDTDVVSEN1dWNqSyIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJDbG90aGVzIE9mZiEhIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZtaXFkb0lDelVYQ0w1VUhDdXVjaksifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJjb21waWxhdGlvbiIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwiaWQiOiIwTHlmUVdKVDZuWGFmTFBacXhlOU9mIiwibmFtZSI6IlZhcmlvdXMgQXJ0aXN0cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowTHlmUVdKVDZuWGFmTFBacXhlOU9mIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNVhNT2NWOHZ4b1VSd2ZMenlCbUxyNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzVYTU9jVjh2eG9VUndmTHp5Qm1McjQiLCJpZCI6IjVYTU9jVjh2eG9VUndmTHp5Qm1McjQiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYjIxZTFlY2Y1MGVhY2JhMzI3YjMxZjkwIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmIyMWUxZWNmNTBlYWNiYTMyN2IzMWY5MCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovLw==", + "aS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiMjFlMWVjZjUwZWFjYmEzMjdiMzFmOTAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVUsgUGFydHkgSGl0cyIsInJlbGVhc2VfZGF0ZSI6IjIwMjYtMDgtMDciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo2MCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1WE1PY1Y4dnhvVVJ3Zkx6eUJtTHI0In0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNXZCU3JFMXh1akQyRlhZUmFyYkFYYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81dkJTckUxeHVqRDJGWFlSYXJiQVhjIiwiaWQiOiI1dkJTckUxeHVqRDJGWFlSYXJiQVhjIiwibmFtZSI6Ik9sbHkgQWxleGFuZGVyIChZZWFycyAmIFllYXJzKSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1dkJTckUxeHVqRDJGWFlSYXJiQVhjIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRzVFFWT2ZwOXZFTUNlbUx3NTBzYnUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNHNUUVZPZnA5dkVNQ2VtTHc1MHNidSIsImlkIjoiNHNUUVZPZnA5dkVNQ2VtTHc1MHNidSIsIm5hbWUiOiJHYWxhbnRpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0c1RRVk9mcDl2RU1DZW1MdzUwc2J1In1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3NjkzMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCVU03MjEwMzQyMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svME5MSFluVHNPeFFOcnc1Q2xFaGQwZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBOTEhZblRzT3hRTnJ3NUNsRWhkMGciLCJpZCI6IjBOTEhZblRzT3hRTnJ3NUNsRWhkMGciLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3dlZXQgVGFsa2VyIiwidHJhY2tfbnVtYmVyIjo1MiwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowTkxIWW5Uc094UU5ydzVDbEVoZDBnIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83aEFFU2s4ZjN4NFdEQjIxbmRYVlk5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcg==", + "dGlzdHMvN2hBRVNrOGYzeDRXREIyMW5kWFZZOSIsImlkIjoiN2hBRVNrOGYzeDRXREIyMW5kWFZZOSIsIm5hbWUiOiJTaWFuIE11cnJheSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3aEFFU2s4ZjN4NFdEQjIxbmRYVlk5In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN3VVcVVkTk5nQW1WbGQwVDBDV3c2cyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzd1VXFVZE5OZ0FtVmxkMFQwQ1d3NnMiLCJpZCI6Ijd1VXFVZE5OZ0FtVmxkMFQwQ1d3NnMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMDYwZTFjMzk3YTg2OWViODQ3NmJjODJmIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjA2MGUxYzM5N2E4NjllYjg0NzZiYzgyZiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMDYwZTFjMzk3YTg2OWViODQ3NmJjODJmIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IllvdXIgU3dlZXQgTG92ZSIsInJlbGVhc2VfZGF0ZSI6IjIwMjMtMDUtMDUiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjd1VXFVZE5OZ0FtVmxkMFQwQ1d3NnMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83aEFFU2s4ZjN4NFdEQjIxbmRYVlk5In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdoQUVTazhmM3g0V0RCMjFuZFhWWTkiLCJpZCI6IjdoQUVTazhmM3g0V0RCMjFuZFhWWTkiLCJuYW1lIjoiU2lhbiBNdXJyYXkiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N2hBRVNrOGYzeDRXREIyMW5kWFZZOSJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjo2NTI3NSwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlFaUzY0MjMyMjAxOCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMnBCVFhQa1cwR3ZuTlBkeUwyQVZWVSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJwQlRYUGtXMEd2bk5QZHlMMkFWVlUiLCJpZCI6IjJwQlRYUGtXMEd2bk5QZHlMMkFWVlUiLCJpc19sb2NhbCI6Zg==", + "YWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJZb3VyIFN3ZWV0IExvdmUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MnBCVFhQa1cwR3ZuTlBkeUwyQVZWVSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMzVQOUpONjZSbU02b0VEMEN5MURkUCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zNVA5Sk42NlJtTTZvRUQwQ3kxRGRQIiwiaWQiOiIzNVA5Sk42NlJtTTZvRUQwQ3kxRGRQIiwibmFtZSI6IkRKIE5hc2hvciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozNVA5Sk42NlJtTTZvRUQwQ3kxRGRQIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMU5rQWdnbHVNenlqMUtJNzB3cmR1QSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFOa0FnZ2x1TXp5ajFLSTcwd3JkdUEiLCJpZCI6IjFOa0FnZ2x1TXp5ajFLSTcwd3JkdUEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMjU5MjJhMWNmZGNjM2Y5MjBhNDYxODI1In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjI1OTIyYTFjZmRjYzNmOTIwYTQ2MTgyNSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxMjU5MjJhMWNmZGNjM2Y5MjBhNDYxODI1In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN3ZWV0IERyZWFtcyIsInJlbGVhc2VfZGF0ZSI6IjIwMjQtMDctMTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjFOa0FnZ2x1TXp5ajFLSTcwd3JkdUEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zNVA5Sk42NlJtTTZvRUQwQ3kxRGRQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzM1UDlKTjY2Um1NNm9FRDBDeTFEZFAiLCJpZCI6IjM1UDlKTjY2Um1NNm9FRDBDeTFEZFAiLCJuYW1lIjoiREogTmFzaG9yIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjM1UDlKTjY2Um1NNm9FRDBDeTFEZFAifQ==", + "XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxNjg4MzQsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQktRVTI0Njg4MzAifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzF4SVBVMDZONGIyUjR2QmdxdWFReFYifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8xeElQVTA2TjRiMlI0dkJncXVhUXhWIiwiaWQiOiIxeElQVTA2TjRiMlI0dkJncXVhUXhWIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN3ZWV0IERyZWFtcyIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxeElQVTA2TjRiMlI0dkJncXVhUXhWIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83QllMQWdYZDNMeWdROWFKdXBaNnA4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdCWUxBZ1hkM0x5Z1E5YUp1cFo2cDgiLCJpZCI6IjdCWUxBZ1hkM0x5Z1E5YUp1cFo2cDgiLCJuYW1lIjoiQXV0dW1uIEtpbmdzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdCWUxBZ1hkM0x5Z1E5YUp1cFo2cDgifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNVQwVmk4V3d3ZmpYOXRtVUk5TWFlOSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81VDBWaThXd3dmalg5dG1VSTlNYWU5IiwiaWQiOiI1VDBWaThXd3dmalg5dG1VSTlNYWU5IiwibmFtZSI6Ikhvd2FyZCBKb25lcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1VDBWaThXd3dmalg5dG1VSTlNYWU5In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlhVaUtWREFBcmxUMHpNano4VXpiMSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJYVWlLVkRBQXJsVDB6TWp6OFV6YjEiLCJpZCI6IjJYVWlLVkRBQXJsVDB6TWp6OFV6YjEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczMWNiMjE2ZTM2MmZjNDAzOWJjZjJjMTRhIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjFjYjIxNmUzNjJmYzQwMzliY2YyYzE0YQ==", + "In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExY2IyMTZlMzYyZmM0MDM5YmNmMmMxNGEifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoieU91bkcgQkxvT2RzIChmZWF0LiBIb3dhcmQgSm9uZXMpIiwicmVsZWFzZV9kYXRlIjoiMjAyNi0wOC0wNiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjcsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MlhVaUtWREFBcmxUMHpNano4VXpiMSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdCWUxBZ1hkM0x5Z1E5YUp1cFo2cDgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN0JZTEFnWGQzTHlnUTlhSnVwWjZwOCIsImlkIjoiN0JZTEFnWGQzTHlnUTlhSnVwWjZwOCIsIm5hbWUiOiJBdXR1bW4gS2luZ3MiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6N0JZTEFnWGQzTHlnUTlhSnVwWjZwOCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoxOTUwOTIsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0hSMjI1MTczMDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNveFNic0x4OGpkQW1qZllhVENKdkkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zb3hTYnNMeDhqZEFtamZZYVRDSnZJIiwiaWQiOiIzb3hTYnNMeDhqZEFtamZZYVRDSnZJIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNuYWtlIENoYXJtZXIiLCJ0cmFja19udW1iZXIiOjUsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M294U2JzTHg4amRBbWpmWWFUQ0p2SSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6InNpbmdsZSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN0JZTEFnWGQzTHlnUTlhSnVwWjZwOCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83QllMQWdYZDNMeWdROWFKdXBaNnA4IiwiaWQiOiI3QllMQWdYZDNMeWdROWFKdXBaNnA4IiwibmFtZSI6IkF1dHVtbiBLaW5ncyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3QllMQWdYZDNMeWdROWFKdXBaNnA4In1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vNzZkOFJseFVIWmVwZFVOSQ==", + "cjhKMVlLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNzZkOFJseFVIWmVwZFVOSXI4SjFZSyIsImlkIjoiNzZkOFJseFVIWmVwZFVOSXI4SjFZSyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1Njg1YTFjMjlhODAyMjJmZTFhNDZiZTYifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNTY4NWExYzI5YTgwMjIyZmUxYTQ2YmU2In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1Njg1YTFjMjlhODAyMjJmZTFhNDZiZTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU25ha2UgQ2hhcm1lciIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDItMTMiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjozLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjc2ZDhSbHhVSFplcGRVTklyOEoxWUsifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC83QllMQWdYZDNMeWdROWFKdXBaNnA4In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzdCWUxBZ1hkM0x5Z1E5YUp1cFo2cDgiLCJpZCI6IjdCWUxBZ1hkM0x5Z1E5YUp1cFo2cDgiLCJuYW1lIjoiQXV0dW1uIEtpbmdzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdCWUxBZ1hkM0x5Z1E5YUp1cFo2cDgifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTk1MDkyLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiVVNIUjIyNTE3MzAxIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8zcEIzNm5tRWtEcXRPdXJVQ21SRVVqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvM3BCMzZubUVrRHF0T3VyVUNtUkVVaiIsImlkIjoiM3BCMzZubUVrRHF0T3VyVUNtUkVVaiIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJTbmFrZSBDaGFybWVyIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNwQjM2bm1Fa0RxdE91clVDbVJFVWoifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Sweet+Talker+Sigma&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Ain%27t%20Nobody%20Kove&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Ain%27t%20Nobody%20Kove&type=track","offset":0,"previous":null,"total":17,"items":[{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6mQfAAqZGBzIfrmlZCeaYT"},"href":"https://api.spotify.com/v1/artists/6mQfAAqZGBzIfrmlZCeaYT","id":"6mQfAAqZGBzIfrmlZCeaYT","name":"Chaka Khan","type":"artist","uri":"spotify:artist:6mQfAAqZGBzIfrmlZCeaYT"}],"external_urls":{"spotify":"https://open.spotify.com/album/3qeheeurjW0lNtf9d7hJLe"},"href":"https://api.spotify.com/v1/albums/3qeheeurjW0lNtf9d7hJLe","id":"3qeheeurjW0lNtf9d7hJLe","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273895ac2862b5c06e058fa09c8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02895ac2862b5c06e058fa09c8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851895ac2862b5c06e058fa09c8"}],"is_playable":true,"name":"Epiphany: The Best of Chaka Khan, Vol. 1","release_date":"1996-11-08","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:3qeheeurjW0lNtf9d7hJLe"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6mQfAAqZGBzIfrmlZCeaYT"},"href":"https://api.spotify.com/v1/artists/6mQfAAqZGBzIfrmlZCeaYT","id":"6mQfAAqZGBzIfrmlZCeaYT","name":"Chaka Khan","type":"artist","uri":"spotify:artist:6mQfAAqZGBzIfrmlZCeaYT"}],"disc_number":1,"duration_ms":280853,"explicit":false,"external_ids":{"isrc":"USWB19600662"},"external_urls":{"spotify":"https://open.spotify.com/track/2NVpYQqdraEcQwqT7GhUkh"},"href":"https://api.spotify.com/v1/tracks/2NVpYQqdraEcQwqT7GhUkh","id":"2NVpYQqdraEcQwqT7GhUkh","is_local":false,"is_playable":true,"name":"Ain't Nobody","track_number":1,"type":"track","uri":"spotify:track:2NVpYQqdraEcQwqT7GhUkh"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4bL2B6hmLlMWnUEZnorEtG"},"href":"https://api.spotify.com/v1/artists/4bL2B6hmLlMWnUEZnorEtG","id":"4bL2B6hmLlMWnUEZnorEtG","name":"felix jaehn","type":"artist","uri":"spotify:artist:4bL2B6hmLlMWnUEZnorEtG"}],"external_urls":{"spotify":"https://open.spotify.com/album/2S56F6bIk01HboGbJJJ1IQ"},"href":"https://api.spotify.com/v1/albums/2S56F6bIk01HboGbJJJ1IQ","id":"2S56F6bIk01HboGbJJJ1IQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2739713f1939e377cf85a2a5b16"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e029713f1939e377cf85a2a5b16"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048519713f1939e377cf85a2a5b16"}],"is_playable":true,"name":"I","release_date":"2018-02-16","release_date_precision":"day","total_tracks":25,"type":"album","uri":"spotify:album:2S56F6bIk01HboGbJJJ1IQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4bL2B6hmLlMWnUEZnorEtG"},"href":"https://api.spotify.com/v1/artists/4bL2B6hmLlMWnUEZnorEtG","id":"4bL2B6hmLlMWnUEZnorEtG","name":"felix jaehn","type":"artist","uri":"spotify:artist:4bL2B6hmLlMWnUEZnorEtG"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2TL8gYTNgD6nXkyuUdDrMg"},"href":"https://api.spotify.com/v1/artists/2TL8gYTNgD6nXkyuUdDrMg","id":"2TL8gYTNgD6nXkyuUdDrMg","name":"Jasmine Thompson","type":"artist","uri":"spotify:artist:2TL8gYTNgD6nXkyuUdDrMg"}],"disc_number":2,"duration_ms":186146,"explicit":false,"external_ids":{"isrc":"DEUM71500425"},"external_urls":{"spotify":"https://open.spotify.com/track/3c8iiZGfEammKJuWTErE5x"},"href":"https://api.spotify.com/v1/tracks/3c8iiZGfEammKJuWTErE5x","id":"3c8iiZGfEammKJuWTErE5x","is_local":false,"is_playable":true,"name":"Ain't Nobody (Loves Me Better) (feat. Jasmine Thompson)","track_number":1,"type":"track","uri":"spotify:track:3c8iiZGfEammKJuWTErE5x"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3UhIlk54Oe4ja06V962ptU"},"href":"https://api.spotify.com/v1/artists/3UhIlk54Oe4ja06V962ptU","id":"3UhIlk54Oe4ja06V962ptU","name":"Triggerfinger","type":"artist","uri":"spotify:artist:3UhIlk54Oe4ja06V962ptU"}],"external_urls":{"spotify":"https://open.spotify.com/album/39hmSEZwoDilkBh1ALjdy3"},"href":"https://api.spotify.com/v1/albums/39hmSEZwoDilkBh1ALjdy3","id":"39hmSEZwoDilkBh1ALjdy3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735a69162879ec3511299ef8b7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025a69162879ec3511299ef8b7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515a69162879ec3511299ef8b7"}],"is_playable":true,"name":"Tf20 - Vault","release_date":"2019-04-12","release_date_precision":"day","total_tracks":11,"type":"album","uri":"spotify:album:39hmSEZwoDilkBh1ALjdy3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3UhIlk54Oe4ja06V962ptU"},"href":"https://api.spotify.com/v1/artists/3UhIlk54Oe4ja06V962ptU","id":"3UhIlk54Oe4ja06V962ptU","name":"Triggerfinger","type":"artist","uri":"spotify:artist:3UhIlk54Oe4ja06V962ptU"}],"disc_number":1,"duration_ms":245746,"explicit":false,"external_ids":{"isrc":"BEN151800018"},"external_urls":{"spotify":"https://open.spotify.com/track/5j27XPrGlAzL1UaYOFFfZt"},"href":"https://api.spotify.com/v1/tracks/5j27XPrGlAzL1UaYOFFfZt","id":"5j27XPrGlAzL1UaYOFFfZt","is_local":false,"is_playable":true,"name":"Ain't Nobody - Live Session 3fm Radio Netherlands \"De Ochtend Bij Giel\" (Bnnvara)","track_number":3,"type":"track","uri":"spotify:track:5j27XPrGlAzL1UaYOFFfZt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3MCjwjfIor5FkK3h639qkW"},"href":"https://api.spotify.com/v1/artists/3MCjwjfIor5FkK3h639qkW","id":"3MCjwjfIor5FkK3h639qkW","name":"Rufus","type":"artist","uri":"spotify:artist:3MCjwjfIor5FkK3h639qkW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6mQfAAqZGBzIfrmlZCeaYT"},"href":"https://api.spotify.com/v1/artists/6mQfAAqZGBzIfrmlZCeaYT","id":"6mQfAAqZGBzIfrmlZCeaYT","name":"Chaka Khan","type":"artist","uri":"spotify:artist:6mQfAAqZGBzIfrmlZCeaYT"}],"external_urls":{"spotify":"https://open.spotify.com/album/3j0kxKahatiR5d0sPPtTjP"},"href":"https://api.spotify.com/v1/albums/3j0kxKahatiR5d0sPPtTjP","id":"3j0kxKahatiR5d0sPPtTjP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731ab2a1683ee8b7fcbc997510"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021ab2a1683ee8b7fcbc997510"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511ab2a1683ee8b7fcbc997510"}],"is_playable":true,"name":"Stompin' At The Savoy","release_date":"1983","release_date_precision":"year","total_tracks":17,"type":"album","uri":"spotify:album:3j0kxKahatiR5d0sPPtTjP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3MCjwjfIor5FkK3h639qkW"},"href":"https://api.spotify.com/v1/artists/3MCjwjfIor5FkK3h639qkW","id":"3MCjwjfIor5FkK3h639qkW","name":"Rufus","type":"artist","uri":"spotify:artist:3MCjwjfIor5FkK3h639qkW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6mQfAAqZGBzIfrmlZCeaYT"},"href":"https://api.spotify.com/v1/artists/6mQfAAqZGBzIfrmlZCeaYT","id":"6mQfAAqZGBzIfrmlZCeaYT","name":"Chaka Khan","type":"artist","uri":"spotify:artist:6mQfAAqZGBzIfrmlZCeaYT"}],"disc_number":1,"duration_ms":285253,"explicit":false,"external_ids":{"isrc":"USWB10104850"},"external_urls":{"spotify":"https://open.spotify.com/track/53Za5vyGc1x7GxgJVRjRKc"},"href":"https://api.spotify.com/v1/tracks/53Za5vyGc1x7GxgJVRjRKc","id":"53Za5vyGc1x7GxgJVRjRKc","is_local":false,"is_playable":true,"name":"Ain't Nobody","track_number":15,"type":"track","uri":"spotify:track:53Za5vyGc1x7GxgJVRjRKc"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3tFvFDca4inwWMY5vupFbX"},"href":"https://api.spotify.com/v1/artists/3tFvFDca4inwWMY5vupFbX","id":"3tFvFDca4inwWMY5vupFbX","name":"The Cooltrane Quartet","type":"artist","uri":"spotify:artist:3tFvFDca4inwWMY5vupFbX"}],"external_urls":{"spotify":"https://open.spotify.com/album/7lVU4ryKHNVfm2FNYR3kWH"},"href":"https://api.spotify.com/v1/albums/7lVU4ryKHNVfm2FNYR3kWH","id":"7lVU4ryKHNVfm2FNYR3kWH","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27393ff372379627a2afaa3240e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0293ff372379627a2afaa3240e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485193ff372379627a2afaa3240e"}],"is_playable":true,"name":"Ain't Nobody (Loves Me Better)","release_date":"2017-11-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:7lVU4ryKHNVfm2FNYR3kWH"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3tFvFDca4inwWMY5vupFbX"},"href":"https://api.spotify.com/v1/artists/3tFvFDca4inwWMY5vupFbX","id":"3tFvFDca4inwWMY5vupFbX","name":"The Cooltrane Quartet","type":"artist","uri":"spotify:artist:3tFvFDca4inwWMY5vupFbX"}],"disc_number":1,"duration_ms":249153,"explicit":false,"external_ids":{"isrc":"ARF411701833"},"external_urls":{"spotify":"https://open.spotify.com/track/0ZTeyKIXsjjrvmkCYKtSz2"},"href":"https://api.spotify.com/v1/tracks/0ZTeyKIXsjjrvmkCYKtSz2","id":"0ZTeyKIXsjjrvmkCYKtSz2","is_local":false,"is_playable":true,"name":"Ain't Nobody (Loves Me Better)","track_number":1,"type":"track","uri":"spotify:track:0ZTeyKIXsjjrvmkCYKtSz2"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3MCjwjfIor5FkK3h639qkW"},"href":"https://api.spotify.com/v1/artists/3MCjwjfIor5FkK3h639qkW","id":"3MCjwjfIor5FkK3h639qkW","name":"Rufus","type":"artist","uri":"spotify:artist:3MCjwjfIor5FkK3h639qkW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6mQfAAqZGBzIfrmlZCeaYT"},"href":"https://api.spotify.com/v1/artists/6mQfAAqZGBzIfrmlZCeaYT","id":"6mQfAAqZGBzIfrmlZCeaYT","name":"Chaka Khan","type":"artist","uri":"spotify:artist:6mQfAAqZGBzIfrmlZCeaYT"}],"external_urls":{"spotify":"https://open.spotify.com/album/59uNmWAzsPSNL2dthQlPR1"},"href":"https://api.spotify.com/v1/albums/59uNmWAzsPSNL2dthQlPR1","id":"59uNmWAzsPSNL2dthQlPR1","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273bfc3e0cfdfb4cebb231c3988"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02bfc3e0cfdfb4cebb231c3988"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851bfc3e0cfdfb4cebb231c3988"}],"is_playable":true,"name":"Ain't Nobody / Sweet Thing (Live)","release_date":"1983-08-10","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:59uNmWAzsPSNL2dthQlPR1"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3MCjwjfIor5FkK3h639qkW"},"href":"https://api.spotify.com/v1/artists/3MCjwjfIor5FkK3h639qkW","id":"3MCjwjfIor5FkK3h639qkW","name":"Rufus","type":"artist","uri":"spotify:artist:3MCjwjfIor5FkK3h639qkW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6mQfAAqZGBzIfrmlZCeaYT"},"href":"https://api.spotify.com/v1/artists/6mQfAAqZGBzIfrmlZCeaYT","id":"6mQfAAqZGBzIfrmlZCeaYT","name":"Chaka Khan","type":"artist","uri":"spotify:artist:6mQfAAqZGBzIfrmlZCeaYT"}],"disc_number":1,"duration_ms":245133,"explicit":false,"external_ids":{"isrc":"USWB10808469"},"external_urls":{"spotify":"https://open.spotify.com/track/6k8Ckm7e5IRwWSIeAduP4b"},"href":"https://api.spotify.com/v1/tracks/6k8Ckm7e5IRwWSIeAduP4b","id":"6k8Ckm7e5IRwWSIeAduP4b","is_local":false,"is_playable":true,"name":"Ain't Nobody (Live) - 7\" Version","track_number":1,"type":"track","uri":"spotify:track:6k8Ckm7e5IRwWSIeAduP4b"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/28ntgpEkMU9Zm7F3gLDMhZ"},"href":"https://api.spotify.com/v1/artists/28ntgpEkMU9Zm7F3gLDMhZ","id":"28ntgpEkMU9Zm7F3gLDMhZ","name":"oskar med k","type":"artist","uri":"spotify:artist:28ntgpEkMU9Zm7F3gLDMhZ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6LuN9FCkKOj5PcnpouEgny"},"href":"https://api.spotify.com/v1/artists/6LuN9FCkKOj5PcnpouEgny","id":"6LuN9FCkKOj5PcnpouEgny","name":"Khalid","type":"artist","uri":"spotify:artist:6LuN9FCkKOj5PcnpouEgny"}],"external_urls":{"spotify":"https://open.spotify.com/album/3eeriHqB4mrrlzqFwdpjHQ"},"href":"https://api.spotify.com/v1/albums/3eeriHqB4mrrlzqFwdpjHQ","id":"3eeriHqB4mrrlzqFwdpjHQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fb13fb7dbbe53ea674f7bcb8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fb13fb7dbbe53ea674f7bcb8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fb13fb7dbbe53ea674f7bcb8"}],"is_playable":true,"name":"nobody (make me feel)","release_date":"2025-09-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3eeriHqB4mrrlzqFwdpjHQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/28ntgpEkMU9Zm7F3gLDMhZ"},"href":"https://api.spotify.com/v1/artists/28ntgpEkMU9Zm7F3gLDMhZ","id":"28ntgpEkMU9Zm7F3gLDMhZ","name":"oskar med k","type":"artist","uri":"spotify:artist:28ntgpEkMU9Zm7F3gLDMhZ"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6LuN9FCkKOj5PcnpouEgny"},"href":"https://api.spotify.com/v1/artists/6LuN9FCkKOj5PcnpouEgny","id":"6LuN9FCkKOj5PcnpouEgny","name":"Khalid","type":"artist","uri":"spotify:artist:6LuN9FCkKOj5PcnpouEgny"}],"disc_number":1,"duration_ms":165120,"explicit":false,"external_ids":{"isrc":"DEKF22501273"},"external_urls":{"spotify":"https://open.spotify.com/track/72qknjLxZXE6iE6h27sIHY"},"href":"https://api.spotify.com/v1/tracks/72qknjLxZXE6iE6h27sIHY","id":"72qknjLxZXE6iE6h27sIHY","is_local":false,"is_playable":true,"name":"nobody (make me feel)","track_number":1,"type":"track","uri":"spotify:track:72qknjLxZXE6iE6h27sIHY"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1G9G7WwrXka3Z1r7aIDjI7"},"href":"https://api.spotify.com/v1/artists/1G9G7WwrXka3Z1r7aIDjI7","id":"1G9G7WwrXka3Z1r7aIDjI7","name":"Outkast","type":"artist","uri":"spotify:artist:1G9G7WwrXka3Z1r7aIDjI7"}],"external_urls":{"spotify":"https://open.spotify.com/album/2tm3Ht61kqqRZtIYsBjxEj"},"href":"https://api.spotify.com/v1/albums/2tm3Ht61kqqRZtIYsBjxEj","id":"2tm3Ht61kqqRZtIYsBjxEj","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273153b3d6495031cb813a7451c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02153b3d6495031cb813a7451c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851153b3d6495031cb813a7451c"}],"is_playable":true,"name":"Stankonia","release_date":"2000-10-31","release_date_precision":"day","total_tracks":24,"type":"album","uri":"spotify:album:2tm3Ht61kqqRZtIYsBjxEj"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1G9G7WwrXka3Z1r7aIDjI7"},"href":"https://api.spotify.com/v1/artists/1G9G7WwrXka3Z1r7aIDjI7","id":"1G9G7WwrXka3Z1r7aIDjI7","name":"Outkast","type":"artist","uri":"spotify:artist:1G9G7WwrXka3Z1r7aIDjI7"}],"disc_number":1,"duration_ms":240026,"explicit":true,"external_ids":{"isrc":"USLF20000433"},"external_urls":{"spotify":"https://open.spotify.com/track/6glsMWIMIxQ4BedzLqGVi4"},"href":"https://api.spotify.com/v1/tracks/6glsMWIMIxQ4BedzLqGVi4","id":"6glsMWIMIxQ4BedzLqGVi4","is_local":false,"is_playable":true,"name":"So Fresh, So Clean","track_number":4,"type":"track","uri":"spotify:track:6glsMWIMIxQ4BedzLqGVi4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"external_urls":{"spotify":"https://open.spotify.com/album/7D2NdGvBHIavgLhmcwhluK"},"href":"https://api.spotify.com/v1/albums/7D2NdGvBHIavgLhmcwhluK","id":"7D2NdGvBHIavgLhmcwhluK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2731dacfbc31cc873d132958af9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e021dacfbc31cc873d132958af9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048511dacfbc31cc873d132958af9"}],"is_playable":true,"name":"Yeezus","release_date":"2013-06-18","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:7D2NdGvBHIavgLhmcwhluK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5K4W6rqBFWDnAN6FQUkS6x"},"href":"https://api.spotify.com/v1/artists/5K4W6rqBFWDnAN6FQUkS6x","id":"5K4W6rqBFWDnAN6FQUkS6x","name":"Kanye West","type":"artist","uri":"spotify:artist:5K4W6rqBFWDnAN6FQUkS6x"}],"disc_number":1,"duration_ms":229146,"explicit":true,"external_ids":{"isrc":"USUM71307523"},"external_urls":{"spotify":"https://open.spotify.com/track/3sNVsP50132BTNlImLx70i"},"href":"https://api.spotify.com/v1/tracks/3sNVsP50132BTNlImLx70i","id":"3sNVsP50132BTNlImLx70i","is_local":false,"is_playable":true,"name":"Bound 2","track_number":10,"type":"track","uri":"spotify:track:3sNVsP50132BTNlImLx70i"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7mmKYG3GAI9jUF0HIYFl2E"},"href":"https://api.spotify.com/v1/artists/7mmKYG3GAI9jUF0HIYFl2E","id":"7mmKYG3GAI9jUF0HIYFl2E","name":"The Jupiter Heritage","type":"artist","uri":"spotify:artist:7mmKYG3GAI9jUF0HIYFl2E"}],"external_urls":{"spotify":"https://open.spotify.com/album/4SZNAFkqezQDXCzBqdO5bY"},"href":"https://api.spotify.com/v1/albums/4SZNAFkqezQDXCzBqdO5bY","id":"4SZNAFkqezQDXCzBqdO5bY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27339fbd78b44d002dd7b3b53ce"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0239fbd78b44d002dd7b3b53ce"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485139fbd78b44d002dd7b3b53ce"}],"is_playable":true,"name":"Heritage Vol. 3","release_date":"2024-01-05","release_date_precision":"day","total_tracks":28,"type":"album","uri":"spotify:album:4SZNAFkqezQDXCzBqdO5bY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7mmKYG3GAI9jUF0HIYFl2E"},"href":"https://api.spotify.com/v1/artists/7mmKYG3GAI9jUF0HIYFl2E","id":"7mmKYG3GAI9jUF0HIYFl2E","name":"The Jupiter Heritage","type":"artist","uri":"spotify:artist:7mmKYG3GAI9jUF0HIYFl2E"}],"disc_number":1,"duration_ms":108387,"explicit":false,"external_ids":{"isrc":"NLRD52340535"},"external_urls":{"spotify":"https://open.spotify.com/track/0Fc8PXP77wLhSyA2UPhWZq"},"href":"https://api.spotify.com/v1/tracks/0Fc8PXP77wLhSyA2UPhWZq","id":"0Fc8PXP77wLhSyA2UPhWZq","is_local":false,"is_playable":true,"name":"Ain't Nobody","track_number":13,"type":"track","uri":"spotify:track:0Fc8PXP77wLhSyA2UPhWZq"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT1BaW4lMjd0JTIwTm9ib2R5JTIwS292ZSZ0eXBlPXRyYWNrIiwibGltaXQiOjEwLCJuZXh0IjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvc2VhcmNoP29mZnNldD0xMCZsaW1pdD0xMCZxdWVyeT1BaW4lMjd0JTIwTm9ib2R5JTIwS292ZSZ0eXBlPXRyYWNrIiwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjE3LCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImNvbXBpbGF0aW9uIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bVFmQUFxWkdCeklmcm1sWkNlYVlUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZtUWZBQXFaR0J6SWZybWxaQ2VhWVQiLCJpZCI6IjZtUWZBQXFaR0J6SWZybWxaQ2VhWVQiLCJuYW1lIjoiQ2hha2EgS2hhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bVFmQUFxWkdCeklmcm1sWkNlYVlUIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM3FlaGVldXJqVzBsTnRmOWQ3aEpMZSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNxZWhlZXVyalcwbE50ZjlkN2hKTGUiLCJpZCI6IjNxZWhlZXVyalcwbE50ZjlkN2hKTGUiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczODk1YWMyODYyYjVjMDZlMDU4ZmEwOWM4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjg5NWFjMjg2MmI1YzA2ZTA1OGZhMDljOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxODk1YWMyODYyYjVjMDZlMDU4ZmEwOWM4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkVwaXBoYW55OiBUaGUgQmVzdCBvZiBDaGFrYSBLaGFuLCBWb2wuIDEiLCJyZWxlYXNlX2RhdGUiOiIxOTk2LTExLTA4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTYsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M3FlaGVldXJqVzBsTnRmOWQ3aEpMZSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZtUWZBQXFaR0J6SWZybWxaQ2VhWQ==", + "VCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bVFmQUFxWkdCeklmcm1sWkNlYVlUIiwiaWQiOiI2bVFmQUFxWkdCeklmcm1sWkNlYVlUIiwibmFtZSI6IkNoYWthIEtoYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm1RZkFBcVpHQnpJZnJtbFpDZWFZVCJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyODA4NTMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1dCMTk2MDA2NjIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzJOVnBZUXFkcmFFY1F3cVQ3R2hVa2gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yTlZwWVFxZHJhRWNRd3FUN0doVWtoIiwiaWQiOiIyTlZwWVFxZHJhRWNRd3FUN0doVWtoIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFpbid0IE5vYm9keSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyTlZwWVFxZHJhRWNRd3FUN0doVWtoIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzRiTDJCNmhtTGxNV25VRVpub3JFdEcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNGJMMkI2aG1MbE1XblVFWm5vckV0RyIsImlkIjoiNGJMMkI2aG1MbE1XblVFWm5vckV0RyIsIm5hbWUiOiJmZWxpeCBqYWVobiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo0YkwyQjZobUxsTVduVUVabm9yRXRHIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMlM1NkY2YklrMDFIYm9HYkpKSjFJUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzJTNTZGNmJJazAxSGJvR2JKSkoxSVEiLCJpZCI6IjJTNTZGNmJJazAxSGJvR2JKSkoxSVEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczOTcxM2YxOTM5ZTM3N2NmODVhMmE1YjE2In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjk3MTNmMTkzOWUzNzdjZjg1YTJhNWIxNiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxOTcxM2YxOTM5ZTM3Nw==", + "Y2Y4NWEyYTViMTYifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSSIsInJlbGVhc2VfZGF0ZSI6IjIwMTgtMDItMTYiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoyNSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToyUzU2RjZiSWswMUhib0diSkpKMUlRIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNGJMMkI2aG1MbE1XblVFWm5vckV0RyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy80YkwyQjZobUxsTVduVUVabm9yRXRHIiwiaWQiOiI0YkwyQjZobUxsTVduVUVabm9yRXRHIiwibmFtZSI6ImZlbGl4IGphZWhuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjRiTDJCNmhtTGxNV25VRVpub3JFdEcifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMlRMOGdZVE5nRDZuWGt5dVVkRHJNZyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8yVEw4Z1lUTmdENm5Ya3l1VWREck1nIiwiaWQiOiIyVEw4Z1lUTmdENm5Ya3l1VWREck1nIiwibmFtZSI6Ikphc21pbmUgVGhvbXBzb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MlRMOGdZVE5nRDZuWGt5dVVkRHJNZyJ9XSwiZGlzY19udW1iZXIiOjIsImR1cmF0aW9uX21zIjoxODYxNDYsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJERVVNNzE1MDA0MjUifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNjOGlpWkdmRWFtbUtKdVdURXJFNXgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zYzhpaVpHZkVhbW1LSnVXVEVyRTV4IiwiaWQiOiIzYzhpaVpHZkVhbW1LSnVXVEVyRTV4IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkFpbid0IE5vYm9keSAoTG92ZXMgTWUgQmV0dGVyKSAoZmVhdC4gSmFzbWluZSBUaG9tcHNvbikiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6M2M4aWlaR2ZFYW1tS0p1V1RFckU1eCJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVWhJbGs1NE9lNGphMDZWOTYycHRVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNVaElsazU0T2U0amEwNlY5NjJwdA==", + "VSIsImlkIjoiM1VoSWxrNTRPZTRqYTA2Vjk2MnB0VSIsIm5hbWUiOiJUcmlnZ2VyZmluZ2VyIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNVaElsazU0T2U0amEwNlY5NjJwdFUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zOWhtU0Vad29EaWxrQmgxQUxqZHkzIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMzlobVNFWndvRGlsa0JoMUFMamR5MyIsImlkIjoiMzlobVNFWndvRGlsa0JoMUFMamR5MyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1YTY5MTYyODc5ZWMzNTExMjk5ZWY4YjcifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWE2OTE2Mjg3OWVjMzUxMTI5OWVmOGI3In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1YTY5MTYyODc5ZWMzNTExMjk5ZWY4YjcifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiVGYyMCAtIFZhdWx0IiwicmVsZWFzZV9kYXRlIjoiMjAxOS0wNC0xMiIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjExLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjM5aG1TRVp3b0RpbGtCaDFBTGpkeTMifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zVWhJbGs1NE9lNGphMDZWOTYycHRVIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNVaElsazU0T2U0amEwNlY5NjJwdFUiLCJpZCI6IjNVaElsazU0T2U0amEwNlY5NjJwdFUiLCJuYW1lIjoiVHJpZ2dlcmZpbmdlciIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozVWhJbGs1NE9lNGphMDZWOTYycHRVIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NTc0NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkJFTjE1MTgwMDAxOCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNWoyN1hQckdsQXpMMVVhWU9GRmZadCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzVqMjdYUHJHbEF6TDFVYVlPRkZmWnQiLCJpZCI6IjVqMjdYUHJHbEF6TDFVYVlPRkZmWnQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLA==", + "Im5hbWUiOiJBaW4ndCBOb2JvZHkgLSBMaXZlIFNlc3Npb24gM2ZtIFJhZGlvIE5ldGhlcmxhbmRzIFwiRGUgT2NodGVuZCBCaWogR2llbFwiIChCbm52YXJhKSIsInRyYWNrX251bWJlciI6MywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1ajI3WFByR2xBekwxVWFZT0ZGZlp0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzNNQ2p3amZJb3I1RmtLM2g2Mzlxa1cifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvM01DandqZklvcjVGa0szaDYzOXFrVyIsImlkIjoiM01DandqZklvcjVGa0szaDYzOXFrVyIsIm5hbWUiOiJSdWZ1cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozTUNqd2pmSW9yNUZrSzNoNjM5cWtXIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZtUWZBQXFaR0J6SWZybWxaQ2VhWVQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm1RZkFBcVpHQnpJZnJtbFpDZWFZVCIsImlkIjoiNm1RZkFBcVpHQnpJZnJtbFpDZWFZVCIsIm5hbWUiOiJDaGFrYSBLaGFuIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZtUWZBQXFaR0J6SWZybWxaQ2VhWVQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zajBreEthaGF0aVI1ZDBzUFB0VGpQIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2owa3hLYWhhdGlSNWQwc1BQdFRqUCIsImlkIjoiM2owa3hLYWhhdGlSNWQwc1BQdFRqUCIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxYWIyYTE2ODNlZThiN2ZjYmM5OTc1MTAifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWFiMmExNjgzZWU4YjdmY2JjOTk3NTEwIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExYWIyYTE2ODNlZThiN2ZjYmM5OTc1MTAifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3RvbXBpbicgQXQgVGhlIFNhdm95IiwicmVsZWFzZV9kYXRlIjoiMTk4MyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJ5ZWFyIiwidG90YWxfdHJhY2tzIjoxNywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdA==", + "aWZ5OmFsYnVtOjNqMGt4S2FoYXRpUjVkMHNQUHRUalAifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zTUNqd2pmSW9yNUZrSzNoNjM5cWtXIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzNNQ2p3amZJb3I1RmtLM2g2Mzlxa1ciLCJpZCI6IjNNQ2p3amZJb3I1RmtLM2g2Mzlxa1ciLCJuYW1lIjoiUnVmdXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M01DandqZklvcjVGa0szaDYzOXFrVyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bVFmQUFxWkdCeklmcm1sWkNlYVlUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZtUWZBQXFaR0J6SWZybWxaQ2VhWVQiLCJpZCI6IjZtUWZBQXFaR0J6SWZybWxaQ2VhWVQiLCJuYW1lIjoiQ2hha2EgS2hhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bVFmQUFxWkdCeklmcm1sWkNlYVlUIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI4NTI1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTV0IxMDEwNDg1MCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNTNaYTV2eUdjMXg3R3hnSlZSalJLYyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzUzWmE1dnlHYzF4N0d4Z0pWUmpSS2MiLCJpZCI6IjUzWmE1dnlHYzF4N0d4Z0pWUmpSS2MiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWluJ3QgTm9ib2R5IiwidHJhY2tfbnVtYmVyIjoxNSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo1M1phNXZ5R2MxeDdHeGdKVlJqUktjIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8zdEZ2RkRjYTRpbndXTVk1dnVwRmJYIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzN0RnZGRGNhNGlud1dNWTV2dXBGYlgiLCJpZCI6IjN0RnZGRGNhNGlud1dNWTV2dXBGYlgiLCJuYW1lIjoiVGhlIENvb2x0cmFuZSBRdWFydGV0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjN0RnZGRGNhNGlud1dNWTV2dXBGYlgifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83bFZVNHJ5S0hOVmZtMg==", + "Rk5ZUjNrV0gifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy83bFZVNHJ5S0hOVmZtMkZOWVIza1dIIiwiaWQiOiI3bFZVNHJ5S0hOVmZtMkZOWVIza1dIIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzkzZmYzNzIzNzk2MjdhMmFmYWEzMjQwZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI5M2ZmMzcyMzc5NjI3YTJhZmFhMzI0MGUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTkzZmYzNzIzNzk2MjdhMmFmYWEzMjQwZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBaW4ndCBOb2JvZHkgKExvdmVzIE1lIEJldHRlcikiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTExLTE3IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3bFZVNHJ5S0hOVmZtMkZOWVIza1dIIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM3RGdkZEY2E0aW53V01ZNXZ1cEZiWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zdEZ2RkRjYTRpbndXTVk1dnVwRmJYIiwiaWQiOiIzdEZ2RkRjYTRpbndXTVk1dnVwRmJYIiwibmFtZSI6IlRoZSBDb29sdHJhbmUgUXVhcnRldCIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDozdEZ2RkRjYTRpbndXTVk1dnVwRmJYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0OTE1MywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkFSRjQxMTcwMTgzMyJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMFpUZXlLSVhzampydm1rQ1lLdFN6MiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBaVGV5S0lYc2pqcnZta0NZS3RTejIiLCJpZCI6IjBaVGV5S0lYc2pqcnZta0NZS3RTejIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWluJ3QgTm9ib2R5IChMb3ZlcyBNZSBCZXR0ZXIpIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjBaVGV5S0lYc2pqcnZta0NZS3RTejIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcg==", + "bmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM01DandqZklvcjVGa0szaDYzOXFrVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zTUNqd2pmSW9yNUZrSzNoNjM5cWtXIiwiaWQiOiIzTUNqd2pmSW9yNUZrSzNoNjM5cWtXIiwibmFtZSI6IlJ1ZnVzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjNNQ2p3amZJb3I1RmtLM2g2Mzlxa1cifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm1RZkFBcVpHQnpJZnJtbFpDZWFZVCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bVFmQUFxWkdCeklmcm1sWkNlYVlUIiwiaWQiOiI2bVFmQUFxWkdCeklmcm1sWkNlYVlUIiwibmFtZSI6IkNoYWthIEtoYW4iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm1RZkFBcVpHQnpJZnJtbFpDZWFZVCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzU5dU5tV0F6c1BTTkwyZHRoUWxQUjEifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy81OXVObVdBenNQU05MMmR0aFFsUFIxIiwiaWQiOiI1OXVObVdBenNQU05MMmR0aFFsUFIxIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2JmYzNlMGNmZGZiNGNlYmIyMzFjMzk4OCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiZmMzZTBjZmRmYjRjZWJiMjMxYzM5ODgifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWJmYzNlMGNmZGZiNGNlYmIyMzFjMzk4OCJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJBaW4ndCBOb2JvZHkgLyBTd2VldCBUaGluZyAoTGl2ZSkiLCJyZWxlYXNlX2RhdGUiOiIxOTgzLTA4LTEwIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MiwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo1OXVObVdBenNQU05MMmR0aFFsUFIxIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvM01DandqZklvcjVGa0szaDYzOXFrVyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8zTUNqd2pmSW9yNUZrSzNoNjM5cWtXIiwiaWQiOg==", + "IjNNQ2p3amZJb3I1RmtLM2g2Mzlxa1ciLCJuYW1lIjoiUnVmdXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6M01DandqZklvcjVGa0szaDYzOXFrVyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bVFmQUFxWkdCeklmcm1sWkNlYVlUIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZtUWZBQXFaR0J6SWZybWxaQ2VhWVQiLCJpZCI6IjZtUWZBQXFaR0J6SWZybWxaQ2VhWVQiLCJuYW1lIjoiQ2hha2EgS2hhbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bVFmQUFxWkdCeklmcm1sWkNlYVlUIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI0NTEzMywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IlVTV0IxMDgwODQ2OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNms4Q2ttN2U1SVJ3V1NJZUFkdVA0YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzZrOENrbTdlNUlSd1dTSWVBZHVQNGIiLCJpZCI6IjZrOENrbTdlNUlSd1dTSWVBZHVQNGIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWluJ3QgTm9ib2R5IChMaXZlKSAtIDdcIiBWZXJzaW9uIiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjZrOENrbTdlNUlSd1dTSWVBZHVQNGIifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzI4bnRncEVrTVU5Wm03RjNnTERNaFoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMjhudGdwRWtNVTlabTdGM2dMRE1oWiIsImlkIjoiMjhudGdwRWtNVTlabTdGM2dMRE1oWiIsIm5hbWUiOiJvc2thciBtZWQgayIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDoyOG50Z3BFa01VOVptN0YzZ0xETWhaIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZMdU45RkNrS09qNVBjbnBvdUVnbnkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNkx1TjlGQ2tLT2o1UGNucG91RWdueSIsImlkIjoiNkx1TjlGQ2tLT2o1UGNucG91RWdueSIsIm5hbWUiOiJLaGFsaWQiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nkx1TjlGQ2tLT2o1UGNucG91RWdueSJ9XSwiZXh0ZQ==", + "cm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vM2VlcmlIcUI0bXJybHpxRndkcGpIUSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzNlZXJpSHFCNG1ycmx6cUZ3ZHBqSFEiLCJpZCI6IjNlZXJpSHFCNG1ycmx6cUZ3ZHBqSFEiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczZmIxM2ZiN2RiYmU1M2VhNjc0ZjdiY2I4In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmZiMTNmYjdkYmJlNTNlYTY3NGY3YmNiOCJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxZmIxM2ZiN2RiYmU1M2VhNjc0ZjdiY2I4In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Im5vYm9keSAobWFrZSBtZSBmZWVsKSIsInJlbGVhc2VfZGF0ZSI6IjIwMjUtMDktMTkiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjNlZXJpSHFCNG1ycmx6cUZ3ZHBqSFEifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8yOG50Z3BFa01VOVptN0YzZ0xETWhaIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzI4bnRncEVrTVU5Wm03RjNnTERNaFoiLCJpZCI6IjI4bnRncEVrTVU5Wm03RjNnTERNaFoiLCJuYW1lIjoib3NrYXIgbWVkIGsiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MjhudGdwRWtNVTlabTdGM2dMRE1oWiJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82THVOOUZDa0tPajVQY25wb3VFZ255In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZMdU45RkNrS09qNVBjbnBvdUVnbnkiLCJpZCI6IjZMdU45RkNrS09qNVBjbnBvdUVnbnkiLCJuYW1lIjoiS2hhbGlkIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZMdU45RkNrS09qNVBjbnBvdUVnbnkifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MTY1MTIwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiREVLRjIyNTAxMjczIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83MnFrbmpMeFpYRTZpRQ==", + "NmgyN3NJSFkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy83MnFrbmpMeFpYRTZpRTZoMjdzSUhZIiwiaWQiOiI3MnFrbmpMeFpYRTZpRTZoMjdzSUhZIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6Im5vYm9keSAobWFrZSBtZSBmZWVsKSIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo3MnFrbmpMeFpYRTZpRTZoMjdzSUhZIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzFHOUc3V3dyWGthM1oxcjdhSURqSTcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMUc5RzdXd3JYa2EzWjFyN2FJRGpJNyIsImlkIjoiMUc5RzdXd3JYa2EzWjFyN2FJRGpJNyIsIm5hbWUiOiJPdXRrYXN0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFHOUc3V3dyWGthM1oxcjdhSURqSTcifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8ydG0zSHQ2MWtxcVJadElZc0JqeEVqIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMnRtM0h0NjFrcXFSWnRJWXNCanhFaiIsImlkIjoiMnRtM0h0NjFrcXFSWnRJWXNCanhFaiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxNTNiM2Q2NDk1MDMxY2I4MTNhNzQ1MWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMTUzYjNkNjQ5NTAzMWNiODEzYTc0NTFjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExNTNiM2Q2NDk1MDMxY2I4MTNhNzQ1MWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiU3RhbmtvbmlhIiwicmVsZWFzZV9kYXRlIjoiMjAwMC0xMC0zMSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjI0LCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjJ0bTNIdDYxa3FxUlp0SVlzQmp4RWoifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8xRzlHN1d3clhrYTNaMXI3YUlEakk3In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzFHOUc3V3dyWGthM1oxcg==", + "N2FJRGpJNyIsImlkIjoiMUc5RzdXd3JYa2EzWjFyN2FJRGpJNyIsIm5hbWUiOiJPdXRrYXN0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjFHOUc3V3dyWGthM1oxcjdhSURqSTcifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjQwMDI2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU0xGMjAwMDA0MzMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzZnbHNNV0lNSXhRNEJlZHpMcUdWaTQifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy82Z2xzTVdJTUl4UTRCZWR6THFHVmk0IiwiaWQiOiI2Z2xzTVdJTUl4UTRCZWR6THFHVmk0IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlNvIEZyZXNoLCBTbyBDbGVhbiIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazo2Z2xzTVdJTUl4UTRCZWR6THFHVmk0In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiYWxidW0iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVLNFc2cnFCRldEbkFONkZRVWtTNngifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUs0VzZycUJGV0RuQU42RlFVa1M2eCIsImlkIjoiNUs0VzZycUJGV0RuQU42RlFVa1M2eCIsIm5hbWUiOiJLYW55ZSBXZXN0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVLNFc2cnFCRldEbkFONkZRVWtTNngifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83RDJOZEd2QkhJYXZnTGhtY3dobHVLIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN0QyTmRHdkJISWF2Z0xobWN3aGx1SyIsImlkIjoiN0QyTmRHdkJISWF2Z0xobWN3aGx1SyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzMxZGFjZmJjMzFjYzg3M2QxMzI5NThhZjkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyMWRhY2ZiYzMxY2M4NzNkMTMyOTU4YWY5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTExZGFjZmJjMzFjYzg3M2QxMzI5NThhZjkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiWWVlenVzIiwicmVsZWFzZV9kYQ==", + "dGUiOiIyMDEzLTA2LTE4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MTAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N0QyTmRHdkJISWF2Z0xobWN3aGx1SyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzVLNFc2cnFCRldEbkFONkZRVWtTNngifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNUs0VzZycUJGV0RuQU42RlFVa1M2eCIsImlkIjoiNUs0VzZycUJGV0RuQU42RlFVa1M2eCIsIm5hbWUiOiJLYW55ZSBXZXN0IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVLNFc2cnFCRldEbkFONkZRVWtTNngifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjI5MTQ2LCJleHBsaWNpdCI6dHJ1ZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJVU1VNNzEzMDc1MjMifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzNzTlZzUDUwMTMyQlRObEltTHg3MGkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8zc05Wc1A1MDEzMkJUTmxJbUx4NzBpIiwiaWQiOiIzc05Wc1A1MDEzMkJUTmxJbUx4NzBpIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IkJvdW5kIDIiLCJ0cmFja19udW1iZXIiOjEwLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjNzTlZzUDUwMTMyQlRObEltTHg3MGkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvN21tS1lHM0dBSTlqVUYwSElZRmwyRSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy83bW1LWUczR0FJOWpVRjBISVlGbDJFIiwiaWQiOiI3bW1LWUczR0FJOWpVRjBISVlGbDJFIiwibmFtZSI6IlRoZSBKdXBpdGVyIEhlcml0YWdlIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjdtbUtZRzNHQUk5alVGMEhJWUZsMkUifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80U1pOQUZrcWV6UURYQ3pCcWRPNWJZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNFNaTkFGa3FlelFEWEN6QnFkTzViWSIsImlkIjoiNFNaTkFGa3FlelFEWEN6QnFkTzViWSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNg==", + "NzYxNmQwMDAwYjI3MzM5ZmJkNzhiNDRkMDAyZGQ3YjNiNTNjZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDIzOWZiZDc4YjQ0ZDAwMmRkN2IzYjUzY2UifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MTM5ZmJkNzhiNDRkMDAyZGQ3YjNiNTNjZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIZXJpdGFnZSBWb2wuIDMiLCJyZWxlYXNlX2RhdGUiOiIyMDI0LTAxLTA1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MjgsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06NFNaTkFGa3FlelFEWEN6QnFkTzViWSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzdtbUtZRzNHQUk5alVGMEhJWUZsMkUifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvN21tS1lHM0dBSTlqVUYwSElZRmwyRSIsImlkIjoiN21tS1lHM0dBSTlqVUYwSElZRmwyRSIsIm5hbWUiOiJUaGUgSnVwaXRlciBIZXJpdGFnZSIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo3bW1LWUczR0FJOWpVRjBISVlGbDJFIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjEwODM4NywiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6Ik5MUkQ1MjM0MDUzNSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMEZjOFBYUDc3d0xoU3lBMlVQaFdacSJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzBGYzhQWFA3N3dMaFN5QTJVUGhXWnEiLCJpZCI6IjBGYzhQWFA3N3dMaFN5QTJVUGhXWnEiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiQWluJ3QgTm9ib2R5IiwidHJhY2tfbnVtYmVyIjoxMywidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazowRmM4UFhQNzd3TGhTeUEyVVBoV1pxIn1dfX0=" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Ain%27t+Nobody+Kove&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Believe%20Me%20Andy%20C&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Believe%20Me%20Andy%20C&type=track","offset":0,"previous":null,"total":22,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5mFKYdmiYwNJTDtSzgFyQx"},"href":"https://api.spotify.com/v1/artists/5mFKYdmiYwNJTDtSzgFyQx","id":"5mFKYdmiYwNJTDtSzgFyQx","name":"Andy Shauf","type":"artist","uri":"spotify:artist:5mFKYdmiYwNJTDtSzgFyQx"}],"external_urls":{"spotify":"https://open.spotify.com/album/2IXuKQr2JhjocXGfkTmfPG"},"href":"https://api.spotify.com/v1/albums/2IXuKQr2JhjocXGfkTmfPG","id":"2IXuKQr2JhjocXGfkTmfPG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27369d21907cef7670649373de5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0269d21907cef7670649373de5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485169d21907cef7670649373de5"}],"is_playable":true,"name":"Wilds","release_date":"2021-09-24","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:2IXuKQr2JhjocXGfkTmfPG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5mFKYdmiYwNJTDtSzgFyQx"},"href":"https://api.spotify.com/v1/artists/5mFKYdmiYwNJTDtSzgFyQx","id":"5mFKYdmiYwNJTDtSzgFyQx","name":"Andy Shauf","type":"artist","uri":"spotify:artist:5mFKYdmiYwNJTDtSzgFyQx"}],"disc_number":1,"duration_ms":185782,"explicit":false,"external_ids":{"isrc":"USEP42137008"},"external_urls":{"spotify":"https://open.spotify.com/track/3d1RQCyaeRj51nx0wYszra"},"href":"https://api.spotify.com/v1/tracks/3d1RQCyaeRj51nx0wYszra","id":"3d1RQCyaeRj51nx0wYszra","is_local":false,"is_playable":true,"name":"Believe Me","track_number":8,"type":"track","uri":"spotify:track:3d1RQCyaeRj51nx0wYszra"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4EPJlUEBy49EX1wuFOvtjK"},"href":"https://api.spotify.com/v1/artists/4EPJlUEBy49EX1wuFOvtjK","id":"4EPJlUEBy49EX1wuFOvtjK","name":"Becky Hill","type":"artist","uri":"spotify:artist:4EPJlUEBy49EX1wuFOvtjK"}],"external_urls":{"spotify":"https://open.spotify.com/album/70szmVYkj3Y8y1wh3bxkMR"},"href":"https://api.spotify.com/v1/albums/70szmVYkj3Y8y1wh3bxkMR","id":"70szmVYkj3Y8y1wh3bxkMR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d621943311379ba32915a226"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d621943311379ba32915a226"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d621943311379ba32915a226"}],"is_playable":true,"name":"Believe Me Now?","release_date":"2024-05-31","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:70szmVYkj3Y8y1wh3bxkMR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/75HK7rgkmDMTnWwwmcN53N"},"href":"https://api.spotify.com/v1/artists/75HK7rgkmDMTnWwwmcN53N","id":"75HK7rgkmDMTnWwwmcN53N","name":"Andy C","type":"artist","uri":"spotify:artist:75HK7rgkmDMTnWwwmcN53N"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4EPJlUEBy49EX1wuFOvtjK"},"href":"https://api.spotify.com/v1/artists/4EPJlUEBy49EX1wuFOvtjK","id":"4EPJlUEBy49EX1wuFOvtjK","name":"Becky Hill","type":"artist","uri":"spotify:artist:4EPJlUEBy49EX1wuFOvtjK"}],"disc_number":1,"duration_ms":160000,"explicit":false,"external_ids":{"isrc":"GBUM72404796"},"external_urls":{"spotify":"https://open.spotify.com/track/2Sw1H321yhy0PL8bznCVwB"},"href":"https://api.spotify.com/v1/tracks/2Sw1H321yhy0PL8bznCVwB","id":"2Sw1H321yhy0PL8bznCVwB","is_local":false,"is_playable":true,"name":"Indestructible","track_number":15,"type":"track","uri":"spotify:track:2Sw1H321yhy0PL8bznCVwB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1TMrnxBwZfmfRxsGzkNIHw"},"href":"https://api.spotify.com/v1/artists/1TMrnxBwZfmfRxsGzkNIHw","id":"1TMrnxBwZfmfRxsGzkNIHw","name":"Andy Mineo","type":"artist","uri":"spotify:artist:1TMrnxBwZfmfRxsGzkNIHw"}],"external_urls":{"spotify":"https://open.spotify.com/album/1Sb0QnODtzjlYmOO7cgIyn"},"href":"https://api.spotify.com/v1/albums/1Sb0QnODtzjlYmOO7cgIyn","id":"1Sb0QnODtzjlYmOO7cgIyn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e95a0ed06bc2a4f7fa9025c6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e95a0ed06bc2a4f7fa9025c6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e95a0ed06bc2a4f7fa9025c6"}],"is_playable":true,"name":"Uncomfortable","release_date":"2015-09-18","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:1Sb0QnODtzjlYmOO7cgIyn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1TMrnxBwZfmfRxsGzkNIHw"},"href":"https://api.spotify.com/v1/artists/1TMrnxBwZfmfRxsGzkNIHw","id":"1TMrnxBwZfmfRxsGzkNIHw","name":"Andy Mineo","type":"artist","uri":"spotify:artist:1TMrnxBwZfmfRxsGzkNIHw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5X77nNxT45eR0OshjmAvKa"},"href":"https://api.spotify.com/v1/artists/5X77nNxT45eR0OshjmAvKa","id":"5X77nNxT45eR0OshjmAvKa","name":"Mac Powell","type":"artist","uri":"spotify:artist:5X77nNxT45eR0OshjmAvKa"}],"disc_number":1,"duration_ms":263290,"explicit":false,"external_ids":{"isrc":"QMTND1100987"},"external_urls":{"spotify":"https://open.spotify.com/track/4JLW1pfTa9EHnb1Xv9OnhV"},"href":"https://api.spotify.com/v1/tracks/4JLW1pfTa9EHnb1Xv9OnhV","id":"4JLW1pfTa9EHnb1Xv9OnhV","is_local":false,"is_playable":true,"name":"Make Me a Believer","track_number":13,"type":"track","uri":"spotify:track:4JLW1pfTa9EHnb1Xv9OnhV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4EPJlUEBy49EX1wuFOvtjK"},"href":"https://api.spotify.com/v1/artists/4EPJlUEBy49EX1wuFOvtjK","id":"4EPJlUEBy49EX1wuFOvtjK","name":"Becky Hill","type":"artist","uri":"spotify:artist:4EPJlUEBy49EX1wuFOvtjK"}],"external_urls":{"spotify":"https://open.spotify.com/album/3jeO9IzC121zhSRLvn2p8m"},"href":"https://api.spotify.com/v1/albums/3jeO9IzC121zhSRLvn2p8m","id":"3jeO9IzC121zhSRLvn2p8m","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734dadcf132f51619348f059a9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024dadcf132f51619348f059a9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514dadcf132f51619348f059a9"}],"is_playable":true,"name":"Believe Me Now?","release_date":"2024-05-31","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:3jeO9IzC121zhSRLvn2p8m"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/75HK7rgkmDMTnWwwmcN53N"},"href":"https://api.spotify.com/v1/artists/75HK7rgkmDMTnWwwmcN53N","id":"75HK7rgkmDMTnWwwmcN53N","name":"Andy C","type":"artist","uri":"spotify:artist:75HK7rgkmDMTnWwwmcN53N"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4EPJlUEBy49EX1wuFOvtjK"},"href":"https://api.spotify.com/v1/artists/4EPJlUEBy49EX1wuFOvtjK","id":"4EPJlUEBy49EX1wuFOvtjK","name":"Becky Hill","type":"artist","uri":"spotify:artist:4EPJlUEBy49EX1wuFOvtjK"}],"disc_number":1,"duration_ms":160000,"explicit":false,"external_ids":{"isrc":"GBUM72404796"},"external_urls":{"spotify":"https://open.spotify.com/track/63Pgrq1g2IJsnFvzVCKngi"},"href":"https://api.spotify.com/v1/tracks/63Pgrq1g2IJsnFvzVCKngi","id":"63Pgrq1g2IJsnFvzVCKngi","is_local":false,"is_playable":true,"name":"Indestructible","track_number":15,"type":"track","uri":"spotify:track:63Pgrq1g2IJsnFvzVCKngi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2n3uDrupL8UtFSeZhY38MS"},"href":"https://api.spotify.com/v1/artists/2n3uDrupL8UtFSeZhY38MS","id":"2n3uDrupL8UtFSeZhY38MS","name":"Andy Lau","type":"artist","uri":"spotify:artist:2n3uDrupL8UtFSeZhY38MS"}],"external_urls":{"spotify":"https://open.spotify.com/album/1EkpIntkDUPb18KlidyBzD"},"href":"https://api.spotify.com/v1/albums/1EkpIntkDUPb18KlidyBzD","id":"1EkpIntkDUPb18KlidyBzD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273119cf122518d03adfd26b5cc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02119cf122518d03adfd26b5cc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851119cf122518d03adfd26b5cc"}],"is_playable":true,"name":"\u6f14\u2027\u5531","release_date":"2020-12-15","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:1EkpIntkDUPb18KlidyBzD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2n3uDrupL8UtFSeZhY38MS"},"href":"https://api.spotify.com/v1/artists/2n3uDrupL8UtFSeZhY38MS","id":"2n3uDrupL8UtFSeZhY38MS","name":"Andy Lau","type":"artist","uri":"spotify:artist:2n3uDrupL8UtFSeZhY38MS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3KnW2xcQFuY880tJRKViuf"},"href":"https://api.spotify.com/v1/artists/3KnW2xcQFuY880tJRKViuf","id":"3KnW2xcQFuY880tJRKViuf","name":"\u502a\u59ae","type":"artist","uri":"spotify:artist:3KnW2xcQFuY880tJRKViuf"}],"disc_number":1,"duration_ms":245908,"explicit":false,"external_ids":{"isrc":"HKA822000006"},"external_urls":{"spotify":"https://open.spotify.com/track/6DHdMG1RiQbSgBophpVEuu"},"href":"https://api.spotify.com/v1/tracks/6DHdMG1RiQbSgBophpVEuu","id":"6DHdMG1RiQbSgBophpVEuu","is_local":false,"is_playable":true,"name":"\u76f8\u4fe1\u6211 (\u96fb\u5f71\u300a\u62c6\u5f48\u5c08\u5bb62\u300b\u4e3b\u984c\u66f2)","track_number":2,"type":"track","uri":"spotify:track:6DHdMG1RiQbSgBophpVEuu"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5FxD8fkQZ6KcsSYupDVoSO"},"href":"https://api.spotify.com/v1/artists/5FxD8fkQZ6KcsSYupDVoSO","id":"5FxD8fkQZ6KcsSYupDVoSO","name":"Omar Apollo","type":"artist","uri":"spotify:artist:5FxD8fkQZ6KcsSYupDVoSO"}],"external_urls":{"spotify":"https://open.spotify.com/album/5z7TD11Qh81Gbf52hd5zAv"},"href":"https://api.spotify.com/v1/albums/5z7TD11Qh81Gbf52hd5zAv","id":"5z7TD11Qh81Gbf52hd5zAv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a4b3a51e2b3941f5275f052f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a4b3a51e2b3941f5275f052f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a4b3a51e2b3941f5275f052f"}],"is_playable":true,"name":"Ivory","release_date":"2022-04-08","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5z7TD11Qh81Gbf52hd5zAv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5FxD8fkQZ6KcsSYupDVoSO"},"href":"https://api.spotify.com/v1/artists/5FxD8fkQZ6KcsSYupDVoSO","id":"5FxD8fkQZ6KcsSYupDVoSO","name":"Omar Apollo","type":"artist","uri":"spotify:artist:5FxD8fkQZ6KcsSYupDVoSO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"}],"disc_number":1,"duration_ms":216160,"explicit":false,"external_ids":{"isrc":"USWB12200029"},"external_urls":{"spotify":"https://open.spotify.com/track/7jhxagwOk9y1HC5ciRfmkQ"},"href":"https://api.spotify.com/v1/tracks/7jhxagwOk9y1HC5ciRfmkQ","id":"7jhxagwOk9y1HC5ciRfmkQ","is_local":false,"is_playable":true,"name":"Invincible (feat. Daniel Caesar)","track_number":4,"type":"track","uri":"spotify:track:7jhxagwOk9y1HC5ciRfmkQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6l3HvQ5sa6mXTsMTB19rO5"},"href":"https://api.spotify.com/v1/artists/6l3HvQ5sa6mXTsMTB19rO5","id":"6l3HvQ5sa6mXTsMTB19rO5","name":"J. Cole","type":"artist","uri":"spotify:artist:6l3HvQ5sa6mXTsMTB19rO5"}],"external_urls":{"spotify":"https://open.spotify.com/album/4JAvwK4APPArjIsOdGoJXX"},"href":"https://api.spotify.com/v1/albums/4JAvwK4APPArjIsOdGoJXX","id":"4JAvwK4APPArjIsOdGoJXX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27310e6745bb2f179dd3616b85f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0210e6745bb2f179dd3616b85f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485110e6745bb2f179dd3616b85f"}],"is_playable":true,"name":"The Off-Season","release_date":"2021-05-14","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:4JAvwK4APPArjIsOdGoJXX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6l3HvQ5sa6mXTsMTB19rO5"},"href":"https://api.spotify.com/v1/artists/6l3HvQ5sa6mXTsMTB19rO5","id":"6l3HvQ5sa6mXTsMTB19rO5","name":"J. Cole","type":"artist","uri":"spotify:artist:6l3HvQ5sa6mXTsMTB19rO5"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5f7VJjfbwm532GiveGC0ZK"},"href":"https://api.spotify.com/v1/artists/5f7VJjfbwm532GiveGC0ZK","id":"5f7VJjfbwm532GiveGC0ZK","name":"Lil Baby","type":"artist","uri":"spotify:artist:5f7VJjfbwm532GiveGC0ZK"}],"disc_number":1,"duration_ms":218210,"explicit":true,"external_ids":{"isrc":"QMJMT2103642"},"external_urls":{"spotify":"https://open.spotify.com/track/5W8jRrZ6tWrTrqnKRtIQBf"},"href":"https://api.spotify.com/v1/tracks/5W8jRrZ6tWrTrqnKRtIQBf","id":"5W8jRrZ6tWrTrqnKRtIQBf","is_local":false,"is_playable":true,"name":"p r i d e . i s . t h e . d e v i l (with Lil Baby)","track_number":7,"type":"track","uri":"spotify:track:5W8jRrZ6tWrTrqnKRtIQBf"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5me0Irg2ANcsgc93uaYrpb"},"href":"https://api.spotify.com/v1/artists/5me0Irg2ANcsgc93uaYrpb","id":"5me0Irg2ANcsgc93uaYrpb","name":"The Notorious B.I.G.","type":"artist","uri":"spotify:artist:5me0Irg2ANcsgc93uaYrpb"}],"external_urls":{"spotify":"https://open.spotify.com/album/2HTbQ0RHwukKVXAlTmCZP2"},"href":"https://api.spotify.com/v1/albums/2HTbQ0RHwukKVXAlTmCZP2","id":"2HTbQ0RHwukKVXAlTmCZP2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f51e29700232d57fe8a0830"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f51e29700232d57fe8a0830"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f51e29700232d57fe8a0830"}],"is_playable":true,"name":"Ready to Die (The Remaster)","release_date":"1994-09-13","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:2HTbQ0RHwukKVXAlTmCZP2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5me0Irg2ANcsgc93uaYrpb"},"href":"https://api.spotify.com/v1/artists/5me0Irg2ANcsgc93uaYrpb","id":"5me0Irg2ANcsgc93uaYrpb","name":"The Notorious B.I.G.","type":"artist","uri":"spotify:artist:5me0Irg2ANcsgc93uaYrpb"}],"disc_number":1,"duration_ms":252746,"explicit":true,"external_ids":{"isrc":"USBB40580817"},"external_urls":{"spotify":"https://open.spotify.com/track/2g8HN35AnVGIk7B8yMucww"},"href":"https://api.spotify.com/v1/tracks/2g8HN35AnVGIk7B8yMucww","id":"2g8HN35AnVGIk7B8yMucww","is_local":false,"is_playable":true,"name":"Big Poppa - 2005 Remaster","track_number":13,"type":"track","uri":"spotify:track:2g8HN35AnVGIk7B8yMucww"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5tth2a3v0sWwV1C7bApBdX"},"href":"https://api.spotify.com/v1/artists/5tth2a3v0sWwV1C7bApBdX","id":"5tth2a3v0sWwV1C7bApBdX","name":"Lil' Kim","type":"artist","uri":"spotify:artist:5tth2a3v0sWwV1C7bApBdX"}],"external_urls":{"spotify":"https://open.spotify.com/album/6UlNLXBFLqRDiKnyrF4oDE"},"href":"https://api.spotify.com/v1/albums/6UlNLXBFLqRDiKnyrF4oDE","id":"6UlNLXBFLqRDiKnyrF4oDE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b56e1a2581b051bdfe8d0826"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b56e1a2581b051bdfe8d0826"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b56e1a2581b051bdfe8d0826"}],"is_playable":true,"name":"La Bella Mafia","release_date":"2003-03-03","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:6UlNLXBFLqRDiKnyrF4oDE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5tth2a3v0sWwV1C7bApBdX"},"href":"https://api.spotify.com/v1/artists/5tth2a3v0sWwV1C7bApBdX","id":"5tth2a3v0sWwV1C7bApBdX","name":"Lil' Kim","type":"artist","uri":"spotify:artist:5tth2a3v0sWwV1C7bApBdX"}],"disc_number":1,"duration_ms":359973,"explicit":true,"external_ids":{"isrc":"USAT20300282"},"external_urls":{"spotify":"https://open.spotify.com/track/0aULRU35N9kTj6O1xMULRR"},"href":"https://api.spotify.com/v1/tracks/0aULRU35N9kTj6O1xMULRR","id":"0aULRU35N9kTj6O1xMULRR","is_local":false,"is_playable":true,"name":"Magic Stick","track_number":12,"type":"track","uri":"spotify:track:0aULRU35N9kTj6O1xMULRR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Ldum5WYigIxh35xTAEIo4"},"href":"https://api.spotify.com/v1/albums/5Ldum5WYigIxh35xTAEIo4","id":"5Ldum5WYigIxh35xTAEIo4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738de5ef6a0d1b9a6a76aa2b4a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028de5ef6a0d1b9a6a76aa2b4a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518de5ef6a0d1b9a6a76aa2b4a"}],"is_playable":true,"name":"Classic Gym Rap","release_date":"2026-07-27","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:5Ldum5WYigIxh35xTAEIo4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5tth2a3v0sWwV1C7bApBdX"},"href":"https://api.spotify.com/v1/artists/5tth2a3v0sWwV1C7bApBdX","id":"5tth2a3v0sWwV1C7bApBdX","name":"Lil' Kim","type":"artist","uri":"spotify:artist:5tth2a3v0sWwV1C7bApBdX"}],"disc_number":1,"duration_ms":359973,"explicit":true,"external_ids":{"isrc":"USAT20300282"},"external_urls":{"spotify":"https://open.spotify.com/track/4PXZi02DLo9EhYyIJXeGD0"},"href":"https://api.spotify.com/v1/tracks/4PXZi02DLo9EhYyIJXeGD0","id":"4PXZi02DLo9EhYyIJXeGD0","is_local":false,"is_playable":true,"name":"Magic Stick","track_number":30,"type":"track","uri":"spotify:track:4PXZi02DLo9EhYyIJXeGD0"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Believe%20Me%20Andy%20C&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Believe%20Me%20Andy%20C&type=track","offset":0,"previous":null,"total":22,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5mFKYdmiYwNJTDtSzgFyQx"},"href":"https://api.spotify.com/v1/artists/5mFKYdmiYwNJTDtSzgFyQx","id":"5mFKYdmiYwNJTDtSzgFyQx","name":"Andy Shauf","type":"artist","uri":"spotify:artist:5mFKYdmiYwNJTDtSzgFyQx"}],"external_urls":{"spotify":"https://open.spotify.com/album/2IXuKQr2JhjocXGfkTmfPG"},"href":"https://api.spotify.com/v1/albums/2IXuKQr2JhjocXGfkTmfPG","id":"2IXuKQr2JhjocXGfkTmfPG","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27369d21907cef7670649373de5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0269d21907cef7670649373de5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485169d21907cef7670649373de5"}],"is_playable":true,"name":"Wilds","release_date":"2021-09-24","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:2IXuKQr2JhjocXGfkTmfPG"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5mFKYdmiYwNJTDtSzgFyQx"},"href":"https://api.spotify.com/v1/artists/5mFKYdmiYwNJTDtSzgFyQx","id":"5mFKYdmiYwNJTDtSzgFyQx","name":"Andy Shauf","type":"artist","uri":"spotify:artist:5mFKYdmiYwNJTDtSzgFyQx"}],"disc_number":1,"duration_ms":185782,"explicit":false,"external_ids":{"isrc":"USEP42137008"},"external_urls":{"spotify":"https://open.spotify.com/track/3d1RQCyaeRj51nx0wYszra"},"href":"https://api.spotify.com/v1/tracks/3d1RQCyaeRj51nx0wYszra","id":"3d1RQCyaeRj51nx0wYszra","is_local":false,"is_playable":true,"name":"Believe Me","track_number":8,"type":"track","uri":"spotify:track:3d1RQCyaeRj51nx0wYszra"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4EPJlUEBy49EX1wuFOvtjK"},"href":"https://api.spotify.com/v1/artists/4EPJlUEBy49EX1wuFOvtjK","id":"4EPJlUEBy49EX1wuFOvtjK","name":"Becky Hill","type":"artist","uri":"spotify:artist:4EPJlUEBy49EX1wuFOvtjK"}],"external_urls":{"spotify":"https://open.spotify.com/album/70szmVYkj3Y8y1wh3bxkMR"},"href":"https://api.spotify.com/v1/albums/70szmVYkj3Y8y1wh3bxkMR","id":"70szmVYkj3Y8y1wh3bxkMR","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273d621943311379ba32915a226"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02d621943311379ba32915a226"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851d621943311379ba32915a226"}],"is_playable":true,"name":"Believe Me Now?","release_date":"2024-05-31","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:70szmVYkj3Y8y1wh3bxkMR"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/75HK7rgkmDMTnWwwmcN53N"},"href":"https://api.spotify.com/v1/artists/75HK7rgkmDMTnWwwmcN53N","id":"75HK7rgkmDMTnWwwmcN53N","name":"Andy C","type":"artist","uri":"spotify:artist:75HK7rgkmDMTnWwwmcN53N"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4EPJlUEBy49EX1wuFOvtjK"},"href":"https://api.spotify.com/v1/artists/4EPJlUEBy49EX1wuFOvtjK","id":"4EPJlUEBy49EX1wuFOvtjK","name":"Becky Hill","type":"artist","uri":"spotify:artist:4EPJlUEBy49EX1wuFOvtjK"}],"disc_number":1,"duration_ms":160000,"explicit":false,"external_ids":{"isrc":"GBUM72404796"},"external_urls":{"spotify":"https://open.spotify.com/track/2Sw1H321yhy0PL8bznCVwB"},"href":"https://api.spotify.com/v1/tracks/2Sw1H321yhy0PL8bznCVwB","id":"2Sw1H321yhy0PL8bznCVwB","is_local":false,"is_playable":true,"name":"Indestructible","track_number":15,"type":"track","uri":"spotify:track:2Sw1H321yhy0PL8bznCVwB"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1TMrnxBwZfmfRxsGzkNIHw"},"href":"https://api.spotify.com/v1/artists/1TMrnxBwZfmfRxsGzkNIHw","id":"1TMrnxBwZfmfRxsGzkNIHw","name":"Andy Mineo","type":"artist","uri":"spotify:artist:1TMrnxBwZfmfRxsGzkNIHw"}],"external_urls":{"spotify":"https://open.spotify.com/album/1Sb0QnODtzjlYmOO7cgIyn"},"href":"https://api.spotify.com/v1/albums/1Sb0QnODtzjlYmOO7cgIyn","id":"1Sb0QnODtzjlYmOO7cgIyn","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e95a0ed06bc2a4f7fa9025c6"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e95a0ed06bc2a4f7fa9025c6"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e95a0ed06bc2a4f7fa9025c6"}],"is_playable":true,"name":"Uncomfortable","release_date":"2015-09-18","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:1Sb0QnODtzjlYmOO7cgIyn"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1TMrnxBwZfmfRxsGzkNIHw"},"href":"https://api.spotify.com/v1/artists/1TMrnxBwZfmfRxsGzkNIHw","id":"1TMrnxBwZfmfRxsGzkNIHw","name":"Andy Mineo","type":"artist","uri":"spotify:artist:1TMrnxBwZfmfRxsGzkNIHw"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5X77nNxT45eR0OshjmAvKa"},"href":"https://api.spotify.com/v1/artists/5X77nNxT45eR0OshjmAvKa","id":"5X77nNxT45eR0OshjmAvKa","name":"Mac Powell","type":"artist","uri":"spotify:artist:5X77nNxT45eR0OshjmAvKa"}],"disc_number":1,"duration_ms":263290,"explicit":false,"external_ids":{"isrc":"QMTND1100987"},"external_urls":{"spotify":"https://open.spotify.com/track/4JLW1pfTa9EHnb1Xv9OnhV"},"href":"https://api.spotify.com/v1/tracks/4JLW1pfTa9EHnb1Xv9OnhV","id":"4JLW1pfTa9EHnb1Xv9OnhV","is_local":false,"is_playable":true,"name":"Make Me a Believer","track_number":13,"type":"track","uri":"spotify:track:4JLW1pfTa9EHnb1Xv9OnhV"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4EPJlUEBy49EX1wuFOvtjK"},"href":"https://api.spotify.com/v1/artists/4EPJlUEBy49EX1wuFOvtjK","id":"4EPJlUEBy49EX1wuFOvtjK","name":"Becky Hill","type":"artist","uri":"spotify:artist:4EPJlUEBy49EX1wuFOvtjK"}],"external_urls":{"spotify":"https://open.spotify.com/album/3jeO9IzC121zhSRLvn2p8m"},"href":"https://api.spotify.com/v1/albums/3jeO9IzC121zhSRLvn2p8m","id":"3jeO9IzC121zhSRLvn2p8m","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734dadcf132f51619348f059a9"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024dadcf132f51619348f059a9"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514dadcf132f51619348f059a9"}],"is_playable":true,"name":"Believe Me Now?","release_date":"2024-05-31","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:3jeO9IzC121zhSRLvn2p8m"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/75HK7rgkmDMTnWwwmcN53N"},"href":"https://api.spotify.com/v1/artists/75HK7rgkmDMTnWwwmcN53N","id":"75HK7rgkmDMTnWwwmcN53N","name":"Andy C","type":"artist","uri":"spotify:artist:75HK7rgkmDMTnWwwmcN53N"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4EPJlUEBy49EX1wuFOvtjK"},"href":"https://api.spotify.com/v1/artists/4EPJlUEBy49EX1wuFOvtjK","id":"4EPJlUEBy49EX1wuFOvtjK","name":"Becky Hill","type":"artist","uri":"spotify:artist:4EPJlUEBy49EX1wuFOvtjK"}],"disc_number":1,"duration_ms":160000,"explicit":false,"external_ids":{"isrc":"GBUM72404796"},"external_urls":{"spotify":"https://open.spotify.com/track/63Pgrq1g2IJsnFvzVCKngi"},"href":"https://api.spotify.com/v1/tracks/63Pgrq1g2IJsnFvzVCKngi","id":"63Pgrq1g2IJsnFvzVCKngi","is_local":false,"is_playable":true,"name":"Indestructible","track_number":15,"type":"track","uri":"spotify:track:63Pgrq1g2IJsnFvzVCKngi"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2n3uDrupL8UtFSeZhY38MS"},"href":"https://api.spotify.com/v1/artists/2n3uDrupL8UtFSeZhY38MS","id":"2n3uDrupL8UtFSeZhY38MS","name":"Andy Lau","type":"artist","uri":"spotify:artist:2n3uDrupL8UtFSeZhY38MS"}],"external_urls":{"spotify":"https://open.spotify.com/album/1EkpIntkDUPb18KlidyBzD"},"href":"https://api.spotify.com/v1/albums/1EkpIntkDUPb18KlidyBzD","id":"1EkpIntkDUPb18KlidyBzD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273119cf122518d03adfd26b5cc"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02119cf122518d03adfd26b5cc"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851119cf122518d03adfd26b5cc"}],"is_playable":true,"name":"\u6f14\u2027\u5531","release_date":"2020-12-15","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:1EkpIntkDUPb18KlidyBzD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2n3uDrupL8UtFSeZhY38MS"},"href":"https://api.spotify.com/v1/artists/2n3uDrupL8UtFSeZhY38MS","id":"2n3uDrupL8UtFSeZhY38MS","name":"Andy Lau","type":"artist","uri":"spotify:artist:2n3uDrupL8UtFSeZhY38MS"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3KnW2xcQFuY880tJRKViuf"},"href":"https://api.spotify.com/v1/artists/3KnW2xcQFuY880tJRKViuf","id":"3KnW2xcQFuY880tJRKViuf","name":"\u502a\u59ae","type":"artist","uri":"spotify:artist:3KnW2xcQFuY880tJRKViuf"}],"disc_number":1,"duration_ms":245908,"explicit":false,"external_ids":{"isrc":"HKA822000006"},"external_urls":{"spotify":"https://open.spotify.com/track/6DHdMG1RiQbSgBophpVEuu"},"href":"https://api.spotify.com/v1/tracks/6DHdMG1RiQbSgBophpVEuu","id":"6DHdMG1RiQbSgBophpVEuu","is_local":false,"is_playable":true,"name":"\u76f8\u4fe1\u6211 (\u96fb\u5f71\u300a\u62c6\u5f48\u5c08\u5bb62\u300b\u4e3b\u984c\u66f2)","track_number":2,"type":"track","uri":"spotify:track:6DHdMG1RiQbSgBophpVEuu"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5FxD8fkQZ6KcsSYupDVoSO"},"href":"https://api.spotify.com/v1/artists/5FxD8fkQZ6KcsSYupDVoSO","id":"5FxD8fkQZ6KcsSYupDVoSO","name":"Omar Apollo","type":"artist","uri":"spotify:artist:5FxD8fkQZ6KcsSYupDVoSO"}],"external_urls":{"spotify":"https://open.spotify.com/album/5z7TD11Qh81Gbf52hd5zAv"},"href":"https://api.spotify.com/v1/albums/5z7TD11Qh81Gbf52hd5zAv","id":"5z7TD11Qh81Gbf52hd5zAv","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a4b3a51e2b3941f5275f052f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a4b3a51e2b3941f5275f052f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a4b3a51e2b3941f5275f052f"}],"is_playable":true,"name":"Ivory","release_date":"2022-04-08","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:5z7TD11Qh81Gbf52hd5zAv"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5FxD8fkQZ6KcsSYupDVoSO"},"href":"https://api.spotify.com/v1/artists/5FxD8fkQZ6KcsSYupDVoSO","id":"5FxD8fkQZ6KcsSYupDVoSO","name":"Omar Apollo","type":"artist","uri":"spotify:artist:5FxD8fkQZ6KcsSYupDVoSO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/20wkVLutqVOYrc0kxFs7rA"},"href":"https://api.spotify.com/v1/artists/20wkVLutqVOYrc0kxFs7rA","id":"20wkVLutqVOYrc0kxFs7rA","name":"Daniel Caesar","type":"artist","uri":"spotify:artist:20wkVLutqVOYrc0kxFs7rA"}],"disc_number":1,"duration_ms":216160,"explicit":false,"external_ids":{"isrc":"USWB12200029"},"external_urls":{"spotify":"https://open.spotify.com/track/7jhxagwOk9y1HC5ciRfmkQ"},"href":"https://api.spotify.com/v1/tracks/7jhxagwOk9y1HC5ciRfmkQ","id":"7jhxagwOk9y1HC5ciRfmkQ","is_local":false,"is_playable":true,"name":"Invincible (feat. Daniel Caesar)","track_number":4,"type":"track","uri":"spotify:track:7jhxagwOk9y1HC5ciRfmkQ"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6l3HvQ5sa6mXTsMTB19rO5"},"href":"https://api.spotify.com/v1/artists/6l3HvQ5sa6mXTsMTB19rO5","id":"6l3HvQ5sa6mXTsMTB19rO5","name":"J. Cole","type":"artist","uri":"spotify:artist:6l3HvQ5sa6mXTsMTB19rO5"}],"external_urls":{"spotify":"https://open.spotify.com/album/4JAvwK4APPArjIsOdGoJXX"},"href":"https://api.spotify.com/v1/albums/4JAvwK4APPArjIsOdGoJXX","id":"4JAvwK4APPArjIsOdGoJXX","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27310e6745bb2f179dd3616b85f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0210e6745bb2f179dd3616b85f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485110e6745bb2f179dd3616b85f"}],"is_playable":true,"name":"The Off-Season","release_date":"2021-05-14","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:4JAvwK4APPArjIsOdGoJXX"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6l3HvQ5sa6mXTsMTB19rO5"},"href":"https://api.spotify.com/v1/artists/6l3HvQ5sa6mXTsMTB19rO5","id":"6l3HvQ5sa6mXTsMTB19rO5","name":"J. Cole","type":"artist","uri":"spotify:artist:6l3HvQ5sa6mXTsMTB19rO5"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5f7VJjfbwm532GiveGC0ZK"},"href":"https://api.spotify.com/v1/artists/5f7VJjfbwm532GiveGC0ZK","id":"5f7VJjfbwm532GiveGC0ZK","name":"Lil Baby","type":"artist","uri":"spotify:artist:5f7VJjfbwm532GiveGC0ZK"}],"disc_number":1,"duration_ms":218210,"explicit":true,"external_ids":{"isrc":"QMJMT2103642"},"external_urls":{"spotify":"https://open.spotify.com/track/5W8jRrZ6tWrTrqnKRtIQBf"},"href":"https://api.spotify.com/v1/tracks/5W8jRrZ6tWrTrqnKRtIQBf","id":"5W8jRrZ6tWrTrqnKRtIQBf","is_local":false,"is_playable":true,"name":"p r i d e . i s . t h e . d e v i l (with Lil Baby)","track_number":7,"type":"track","uri":"spotify:track:5W8jRrZ6tWrTrqnKRtIQBf"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5me0Irg2ANcsgc93uaYrpb"},"href":"https://api.spotify.com/v1/artists/5me0Irg2ANcsgc93uaYrpb","id":"5me0Irg2ANcsgc93uaYrpb","name":"The Notorious B.I.G.","type":"artist","uri":"spotify:artist:5me0Irg2ANcsgc93uaYrpb"}],"external_urls":{"spotify":"https://open.spotify.com/album/2HTbQ0RHwukKVXAlTmCZP2"},"href":"https://api.spotify.com/v1/albums/2HTbQ0RHwukKVXAlTmCZP2","id":"2HTbQ0RHwukKVXAlTmCZP2","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730f51e29700232d57fe8a0830"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020f51e29700232d57fe8a0830"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510f51e29700232d57fe8a0830"}],"is_playable":true,"name":"Ready to Die (The Remaster)","release_date":"1994-09-13","release_date_precision":"day","total_tracks":19,"type":"album","uri":"spotify:album:2HTbQ0RHwukKVXAlTmCZP2"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5me0Irg2ANcsgc93uaYrpb"},"href":"https://api.spotify.com/v1/artists/5me0Irg2ANcsgc93uaYrpb","id":"5me0Irg2ANcsgc93uaYrpb","name":"The Notorious B.I.G.","type":"artist","uri":"spotify:artist:5me0Irg2ANcsgc93uaYrpb"}],"disc_number":1,"duration_ms":252746,"explicit":true,"external_ids":{"isrc":"USBB40580817"},"external_urls":{"spotify":"https://open.spotify.com/track/2g8HN35AnVGIk7B8yMucww"},"href":"https://api.spotify.com/v1/tracks/2g8HN35AnVGIk7B8yMucww","id":"2g8HN35AnVGIk7B8yMucww","is_local":false,"is_playable":true,"name":"Big Poppa - 2005 Remaster","track_number":13,"type":"track","uri":"spotify:track:2g8HN35AnVGIk7B8yMucww"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5tth2a3v0sWwV1C7bApBdX"},"href":"https://api.spotify.com/v1/artists/5tth2a3v0sWwV1C7bApBdX","id":"5tth2a3v0sWwV1C7bApBdX","name":"Lil' Kim","type":"artist","uri":"spotify:artist:5tth2a3v0sWwV1C7bApBdX"}],"external_urls":{"spotify":"https://open.spotify.com/album/6UlNLXBFLqRDiKnyrF4oDE"},"href":"https://api.spotify.com/v1/albums/6UlNLXBFLqRDiKnyrF4oDE","id":"6UlNLXBFLqRDiKnyrF4oDE","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b56e1a2581b051bdfe8d0826"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b56e1a2581b051bdfe8d0826"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b56e1a2581b051bdfe8d0826"}],"is_playable":true,"name":"La Bella Mafia","release_date":"2003-03-03","release_date_precision":"day","total_tracks":16,"type":"album","uri":"spotify:album:6UlNLXBFLqRDiKnyrF4oDE"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5tth2a3v0sWwV1C7bApBdX"},"href":"https://api.spotify.com/v1/artists/5tth2a3v0sWwV1C7bApBdX","id":"5tth2a3v0sWwV1C7bApBdX","name":"Lil' Kim","type":"artist","uri":"spotify:artist:5tth2a3v0sWwV1C7bApBdX"}],"disc_number":1,"duration_ms":359973,"explicit":true,"external_ids":{"isrc":"USAT20300282"},"external_urls":{"spotify":"https://open.spotify.com/track/0aULRU35N9kTj6O1xMULRR"},"href":"https://api.spotify.com/v1/tracks/0aULRU35N9kTj6O1xMULRR","id":"0aULRU35N9kTj6O1xMULRR","is_local":false,"is_playable":true,"name":"Magic Stick","track_number":12,"type":"track","uri":"spotify:track:0aULRU35N9kTj6O1xMULRR"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/5Ldum5WYigIxh35xTAEIo4"},"href":"https://api.spotify.com/v1/albums/5Ldum5WYigIxh35xTAEIo4","id":"5Ldum5WYigIxh35xTAEIo4","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738de5ef6a0d1b9a6a76aa2b4a"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028de5ef6a0d1b9a6a76aa2b4a"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518de5ef6a0d1b9a6a76aa2b4a"}],"is_playable":true,"name":"Classic Gym Rap","release_date":"2026-07-27","release_date_precision":"day","total_tracks":30,"type":"album","uri":"spotify:album:5Ldum5WYigIxh35xTAEIo4"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5tth2a3v0sWwV1C7bApBdX"},"href":"https://api.spotify.com/v1/artists/5tth2a3v0sWwV1C7bApBdX","id":"5tth2a3v0sWwV1C7bApBdX","name":"Lil' Kim","type":"artist","uri":"spotify:artist:5tth2a3v0sWwV1C7bApBdX"}],"disc_number":1,"duration_ms":359973,"explicit":true,"external_ids":{"isrc":"USAT20300282"},"external_urls":{"spotify":"https://open.spotify.com/track/4PXZi02DLo9EhYyIJXeGD0"},"href":"https://api.spotify.com/v1/tracks/4PXZi02DLo9EhYyIJXeGD0","id":"4PXZi02DLo9EhYyIJXeGD0","is_local":false,"is_playable":true,"name":"Magic Stick","track_number":30,"type":"track","uri":"spotify:track:4PXZi02DLo9EhYyIJXeGD0"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Believe+Me+Andy+C&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Body%20Move%20Kove&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Body%20Move%20Kove&type=track","offset":0,"previous":null,"total":19,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3BJfXq3PuHFiHrD6PcfpCd"},"href":"https://api.spotify.com/v1/artists/3BJfXq3PuHFiHrD6PcfpCd","id":"3BJfXq3PuHFiHrD6PcfpCd","name":"Lance Savali","type":"artist","uri":"spotify:artist:3BJfXq3PuHFiHrD6PcfpCd"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OzvqL4iqJa92nxgHs2mkN"},"href":"https://api.spotify.com/v1/albums/0OzvqL4iqJa92nxgHs2mkN","id":"0OzvqL4iqJa92nxgHs2mkN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b929edd34d0d5cc09132f839"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b929edd34d0d5cc09132f839"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b929edd34d0d5cc09132f839"}],"is_playable":true,"name":"Move Ya Body","release_date":"2022-10-21","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0OzvqL4iqJa92nxgHs2mkN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3BJfXq3PuHFiHrD6PcfpCd"},"href":"https://api.spotify.com/v1/artists/3BJfXq3PuHFiHrD6PcfpCd","id":"3BJfXq3PuHFiHrD6PcfpCd","name":"Lance Savali","type":"artist","uri":"spotify:artist:3BJfXq3PuHFiHrD6PcfpCd"}],"disc_number":1,"duration_ms":175021,"explicit":false,"external_ids":{"isrc":"NZUM72200272"},"external_urls":{"spotify":"https://open.spotify.com/track/2XvL3AOBDXqgQljhj9ksm2"},"href":"https://api.spotify.com/v1/tracks/2XvL3AOBDXqgQljhj9ksm2","id":"2XvL3AOBDXqgQljhj9ksm2","is_local":false,"is_playable":true,"name":"Move Ya Body","track_number":1,"type":"track","uri":"spotify:track:2XvL3AOBDXqgQljhj9ksm2"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6hBrJJrcYoNhvLC6KaFR4b"},"href":"https://api.spotify.com/v1/artists/6hBrJJrcYoNhvLC6KaFR4b","id":"6hBrJJrcYoNhvLC6KaFR4b","name":"Eliminate","type":"artist","uri":"spotify:artist:6hBrJJrcYoNhvLC6KaFR4b"}],"external_urls":{"spotify":"https://open.spotify.com/album/2dBce4y55fqAt8dbOhI9E3"},"href":"https://api.spotify.com/v1/albums/2dBce4y55fqAt8dbOhI9E3","id":"2dBce4y55fqAt8dbOhI9E3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27360b5f492440e38efe10d3a41"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0260b5f492440e38efe10d3a41"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485160b5f492440e38efe10d3a41"}],"is_playable":true,"name":"Turn It Up EP","release_date":"2025-09-12","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:2dBce4y55fqAt8dbOhI9E3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6hBrJJrcYoNhvLC6KaFR4b"},"href":"https://api.spotify.com/v1/artists/6hBrJJrcYoNhvLC6KaFR4b","id":"6hBrJJrcYoNhvLC6KaFR4b","name":"Eliminate","type":"artist","uri":"spotify:artist:6hBrJJrcYoNhvLC6KaFR4b"}],"disc_number":1,"duration_ms":143450,"explicit":false,"external_ids":{"isrc":"QZTGW2406156"},"external_urls":{"spotify":"https://open.spotify.com/track/1XvGtoO3ubLRFHXChk3Q1P"},"href":"https://api.spotify.com/v1/tracks/1XvGtoO3ubLRFHXChk3Q1P","id":"1XvGtoO3ubLRFHXChk3Q1P","is_local":false,"is_playable":true,"name":"BodyMove","track_number":4,"type":"track","uri":"spotify:track:1XvGtoO3ubLRFHXChk3Q1P"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SSciNLgRTNW5DQ7X8Df74"},"href":"https://api.spotify.com/v1/artists/0SSciNLgRTNW5DQ7X8Df74","id":"0SSciNLgRTNW5DQ7X8Df74","name":"Umaedo","type":"artist","uri":"spotify:artist:0SSciNLgRTNW5DQ7X8Df74"}],"external_urls":{"spotify":"https://open.spotify.com/album/18Lp7l7QbYlEEsMROnXQx5"},"href":"https://api.spotify.com/v1/albums/18Lp7l7QbYlEEsMROnXQx5","id":"18Lp7l7QbYlEEsMROnXQx5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27306c221b9be7533e1cf13b488"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0206c221b9be7533e1cf13b488"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485106c221b9be7533e1cf13b488"}],"is_playable":true,"name":"Body Moving","release_date":"2026-03-27","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:18Lp7l7QbYlEEsMROnXQx5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SSciNLgRTNW5DQ7X8Df74"},"href":"https://api.spotify.com/v1/artists/0SSciNLgRTNW5DQ7X8Df74","id":"0SSciNLgRTNW5DQ7X8Df74","name":"Umaedo","type":"artist","uri":"spotify:artist:0SSciNLgRTNW5DQ7X8Df74"}],"disc_number":1,"duration_ms":171507,"explicit":false,"external_ids":{"isrc":"USA2P2618025"},"external_urls":{"spotify":"https://open.spotify.com/track/4XF44ZR69PSnEa1oIUfS88"},"href":"https://api.spotify.com/v1/tracks/4XF44ZR69PSnEa1oIUfS88","id":"4XF44ZR69PSnEa1oIUfS88","is_local":false,"is_playable":true,"name":"Body Moving","track_number":1,"type":"track","uri":"spotify:track:4XF44ZR69PSnEa1oIUfS88"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Di8r9df6xjyj6CVOqbGVz"},"href":"https://api.spotify.com/v1/artists/2Di8r9df6xjyj6CVOqbGVz","id":"2Di8r9df6xjyj6CVOqbGVz","name":"Marshall Jefferson","type":"artist","uri":"spotify:artist:2Di8r9df6xjyj6CVOqbGVz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0oO1IaDOBSeI96HbnCa5pZ"},"href":"https://api.spotify.com/v1/artists/0oO1IaDOBSeI96HbnCa5pZ","id":"0oO1IaDOBSeI96HbnCa5pZ","name":"Solardo","type":"artist","uri":"spotify:artist:0oO1IaDOBSeI96HbnCa5pZ"}],"external_urls":{"spotify":"https://open.spotify.com/album/3wXxLmmbbiQn8ndz1L2Wxo"},"href":"https://api.spotify.com/v1/albums/3wXxLmmbbiQn8ndz1L2Wxo","id":"3wXxLmmbbiQn8ndz1L2Wxo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c3f76f860585366e7a571c2c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c3f76f860585366e7a571c2c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c3f76f860585366e7a571c2c"}],"is_playable":true,"name":"Move Your Body","release_date":"2019-10-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3wXxLmmbbiQn8ndz1L2Wxo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Di8r9df6xjyj6CVOqbGVz"},"href":"https://api.spotify.com/v1/artists/2Di8r9df6xjyj6CVOqbGVz","id":"2Di8r9df6xjyj6CVOqbGVz","name":"Marshall Jefferson","type":"artist","uri":"spotify:artist:2Di8r9df6xjyj6CVOqbGVz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0oO1IaDOBSeI96HbnCa5pZ"},"href":"https://api.spotify.com/v1/artists/0oO1IaDOBSeI96HbnCa5pZ","id":"0oO1IaDOBSeI96HbnCa5pZ","name":"Solardo","type":"artist","uri":"spotify:artist:0oO1IaDOBSeI96HbnCa5pZ"}],"disc_number":1,"duration_ms":196109,"explicit":false,"external_ids":{"isrc":"USUS11900546"},"external_urls":{"spotify":"https://open.spotify.com/track/3OrcEhLzxv1YX597jGjEI7"},"href":"https://api.spotify.com/v1/tracks/3OrcEhLzxv1YX597jGjEI7","id":"3OrcEhLzxv1YX597jGjEI7","is_local":false,"is_playable":true,"name":"Move Your Body","track_number":1,"type":"track","uri":"spotify:track:3OrcEhLzxv1YX597jGjEI7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6eBYLQONaYZhZNAVK061t6"},"href":"https://api.spotify.com/v1/artists/6eBYLQONaYZhZNAVK061t6","id":"6eBYLQONaYZhZNAVK061t6","name":"Nina Sky","type":"artist","uri":"spotify:artist:6eBYLQONaYZhZNAVK061t6"}],"external_urls":{"spotify":"https://open.spotify.com/album/15Zjx7K5ifTVmXa3Nk5B88"},"href":"https://api.spotify.com/v1/albums/15Zjx7K5ifTVmXa3Nk5B88","id":"15Zjx7K5ifTVmXa3Nk5B88","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e0c595c1a9a2f98535072fdd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e0c595c1a9a2f98535072fdd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e0c595c1a9a2f98535072fdd"}],"is_playable":true,"name":"Nina Sky","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:15Zjx7K5ifTVmXa3Nk5B88"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6eBYLQONaYZhZNAVK061t6"},"href":"https://api.spotify.com/v1/artists/6eBYLQONaYZhZNAVK061t6","id":"6eBYLQONaYZhZNAVK061t6","name":"Nina Sky","type":"artist","uri":"spotify:artist:6eBYLQONaYZhZNAVK061t6"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cbRMYnjXAwJYNzxy291JY"},"href":"https://api.spotify.com/v1/artists/3cbRMYnjXAwJYNzxy291JY","id":"3cbRMYnjXAwJYNzxy291JY","name":"Jabba","type":"artist","uri":"spotify:artist:3cbRMYnjXAwJYNzxy291JY"}],"disc_number":1,"duration_ms":232000,"explicit":false,"external_ids":{"isrc":"USUR10400494"},"external_urls":{"spotify":"https://open.spotify.com/track/2ndnVdR8si7CW9T8vJRHyW"},"href":"https://api.spotify.com/v1/tracks/2ndnVdR8si7CW9T8vJRHyW","id":"2ndnVdR8si7CW9T8vJRHyW","is_local":false,"is_playable":true,"name":"Move Ya Body","track_number":2,"type":"track","uri":"spotify:track:2ndnVdR8si7CW9T8vJRHyW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1rpLzYzfrueWdkpcIunZQl"},"href":"https://api.spotify.com/v1/artists/1rpLzYzfrueWdkpcIunZQl","id":"1rpLzYzfrueWdkpcIunZQl","name":"Hard Driver","type":"artist","uri":"spotify:artist:1rpLzYzfrueWdkpcIunZQl"}],"external_urls":{"spotify":"https://open.spotify.com/album/35DequSIKFZ3uL2YeepqvD"},"href":"https://api.spotify.com/v1/albums/35DequSIKFZ3uL2YeepqvD","id":"35DequSIKFZ3uL2YeepqvD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dd4fdfbe387ea62b5bf852e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dd4fdfbe387ea62b5bf852e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dd4fdfbe387ea62b5bf852e7"}],"is_playable":true,"name":"BODY MOVE","release_date":"2026-06-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:35DequSIKFZ3uL2YeepqvD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1rpLzYzfrueWdkpcIunZQl"},"href":"https://api.spotify.com/v1/artists/1rpLzYzfrueWdkpcIunZQl","id":"1rpLzYzfrueWdkpcIunZQl","name":"Hard Driver","type":"artist","uri":"spotify:artist:1rpLzYzfrueWdkpcIunZQl"}],"disc_number":1,"duration_ms":158642,"explicit":false,"external_ids":{"isrc":"BEB682600528"},"external_urls":{"spotify":"https://open.spotify.com/track/6NqIFmNHR1sWzWGTmnYaLl"},"href":"https://api.spotify.com/v1/tracks/6NqIFmNHR1sWzWGTmnYaLl","id":"6NqIFmNHR1sWzWGTmnYaLl","is_local":false,"is_playable":true,"name":"BODY MOVE","track_number":1,"type":"track","uri":"spotify:track:6NqIFmNHR1sWzWGTmnYaLl"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4XC335ouK6pXyq4QiIb8bP"},"href":"https://api.spotify.com/v1/artists/4XC335ouK6pXyq4QiIb8bP","id":"4XC335ouK6pXyq4QiIb8bP","name":"Eliza Rose","type":"artist","uri":"spotify:artist:4XC335ouK6pXyq4QiIb8bP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7CajNmpbOovFoOoasH2HaY"},"href":"https://api.spotify.com/v1/artists/7CajNmpbOovFoOoasH2HaY","id":"7CajNmpbOovFoOoasH2HaY","name":"Calvin Harris","type":"artist","uri":"spotify:artist:7CajNmpbOovFoOoasH2HaY"}],"external_urls":{"spotify":"https://open.spotify.com/album/5EcypjAXyzxlrF5AKCNg9K"},"href":"https://api.spotify.com/v1/albums/5EcypjAXyzxlrF5AKCNg9K","id":"5EcypjAXyzxlrF5AKCNg9K","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273535aaa51352955a479bc5371"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02535aaa51352955a479bc5371"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851535aaa51352955a479bc5371"}],"is_playable":true,"name":"Body Moving","release_date":"2023-11-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5EcypjAXyzxlrF5AKCNg9K"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4XC335ouK6pXyq4QiIb8bP"},"href":"https://api.spotify.com/v1/artists/4XC335ouK6pXyq4QiIb8bP","id":"4XC335ouK6pXyq4QiIb8bP","name":"Eliza Rose","type":"artist","uri":"spotify:artist:4XC335ouK6pXyq4QiIb8bP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7CajNmpbOovFoOoasH2HaY"},"href":"https://api.spotify.com/v1/artists/7CajNmpbOovFoOoasH2HaY","id":"7CajNmpbOovFoOoasH2HaY","name":"Calvin Harris","type":"artist","uri":"spotify:artist:7CajNmpbOovFoOoasH2HaY"}],"disc_number":1,"duration_ms":154215,"explicit":false,"external_ids":{"isrc":"GBARL2301617"},"external_urls":{"spotify":"https://open.spotify.com/track/5SFCEkybGYmmzKqewtDEaN"},"href":"https://api.spotify.com/v1/tracks/5SFCEkybGYmmzKqewtDEaN","id":"5SFCEkybGYmmzKqewtDEaN","is_local":false,"is_playable":true,"name":"Body Moving","track_number":1,"type":"track","uri":"spotify:track:5SFCEkybGYmmzKqewtDEaN"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NGAZxHanS9e0iNHpR8f2W"},"href":"https://api.spotify.com/v1/artists/0NGAZxHanS9e0iNHpR8f2W","id":"0NGAZxHanS9e0iNHpR8f2W","name":"Alok","type":"artist","uri":"spotify:artist:0NGAZxHanS9e0iNHpR8f2W"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77lzQa2JgjlkP4uA5ptyo7"},"href":"https://api.spotify.com/v1/artists/77lzQa2JgjlkP4uA5ptyo7","id":"77lzQa2JgjlkP4uA5ptyo7","name":"Mondello'G","type":"artist","uri":"spotify:artist:77lzQa2JgjlkP4uA5ptyo7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/32kPQzj1rk4nnGIIJpIUic"},"href":"https://api.spotify.com/v1/artists/32kPQzj1rk4nnGIIJpIUic","id":"32kPQzj1rk4nnGIIJpIUic","name":"CERES","type":"artist","uri":"spotify:artist:32kPQzj1rk4nnGIIJpIUic"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6iqDK7aHVlwGGgPmcdSK5L"},"href":"https://api.spotify.com/v1/artists/6iqDK7aHVlwGGgPmcdSK5L","id":"6iqDK7aHVlwGGgPmcdSK5L","name":"Tribbs","type":"artist","uri":"spotify:artist:6iqDK7aHVlwGGgPmcdSK5L"}],"external_urls":{"spotify":"https://open.spotify.com/album/1zz2cxnkEpgyLdSmoPBEjK"},"href":"https://api.spotify.com/v1/albums/1zz2cxnkEpgyLdSmoPBEjK","id":"1zz2cxnkEpgyLdSmoPBEjK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27381b16b41c622baf9678a899f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0281b16b41c622baf9678a899f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485181b16b41c622baf9678a899f"}],"is_playable":true,"name":"LET'S GET FKD UP (feat. Tribbs)","release_date":"2023-11-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1zz2cxnkEpgyLdSmoPBEjK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NGAZxHanS9e0iNHpR8f2W"},"href":"https://api.spotify.com/v1/artists/0NGAZxHanS9e0iNHpR8f2W","id":"0NGAZxHanS9e0iNHpR8f2W","name":"Alok","type":"artist","uri":"spotify:artist:0NGAZxHanS9e0iNHpR8f2W"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77lzQa2JgjlkP4uA5ptyo7"},"href":"https://api.spotify.com/v1/artists/77lzQa2JgjlkP4uA5ptyo7","id":"77lzQa2JgjlkP4uA5ptyo7","name":"Mondello'G","type":"artist","uri":"spotify:artist:77lzQa2JgjlkP4uA5ptyo7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/32kPQzj1rk4nnGIIJpIUic"},"href":"https://api.spotify.com/v1/artists/32kPQzj1rk4nnGIIJpIUic","id":"32kPQzj1rk4nnGIIJpIUic","name":"CERES","type":"artist","uri":"spotify:artist:32kPQzj1rk4nnGIIJpIUic"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6iqDK7aHVlwGGgPmcdSK5L"},"href":"https://api.spotify.com/v1/artists/6iqDK7aHVlwGGgPmcdSK5L","id":"6iqDK7aHVlwGGgPmcdSK5L","name":"Tribbs","type":"artist","uri":"spotify:artist:6iqDK7aHVlwGGgPmcdSK5L"}],"disc_number":1,"duration_ms":121500,"explicit":true,"external_ids":{"isrc":"DEE862301931"},"external_urls":{"spotify":"https://open.spotify.com/track/0iB5f04XdJ2tcfhoVkeLV8"},"href":"https://api.spotify.com/v1/tracks/0iB5f04XdJ2tcfhoVkeLV8","id":"0iB5f04XdJ2tcfhoVkeLV8","is_local":false,"is_playable":true,"name":"LET'S GET FKD UP","track_number":1,"type":"track","uri":"spotify:track:0iB5f04XdJ2tcfhoVkeLV8"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/37czgDRfGMvgRiUKHvnnhj"},"href":"https://api.spotify.com/v1/artists/37czgDRfGMvgRiUKHvnnhj","id":"37czgDRfGMvgRiUKHvnnhj","name":"\u00d6wnboss","type":"artist","uri":"spotify:artist:37czgDRfGMvgRiUKHvnnhj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0aOIluXr131XqrXFwFCFGT"},"href":"https://api.spotify.com/v1/artists/0aOIluXr131XqrXFwFCFGT","id":"0aOIluXr131XqrXFwFCFGT","name":"Sevek","type":"artist","uri":"spotify:artist:0aOIluXr131XqrXFwFCFGT"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l9wMVL4XAM5jPMXP5RAbL"},"href":"https://api.spotify.com/v1/albums/4l9wMVL4XAM5jPMXP5RAbL","id":"4l9wMVL4XAM5jPMXP5RAbL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dbe45fee4e36211b4bf8de71"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dbe45fee4e36211b4bf8de71"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dbe45fee4e36211b4bf8de71"}],"is_playable":true,"name":"Move Your Body","release_date":"2021-10-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4l9wMVL4XAM5jPMXP5RAbL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/37czgDRfGMvgRiUKHvnnhj"},"href":"https://api.spotify.com/v1/artists/37czgDRfGMvgRiUKHvnnhj","id":"37czgDRfGMvgRiUKHvnnhj","name":"\u00d6wnboss","type":"artist","uri":"spotify:artist:37czgDRfGMvgRiUKHvnnhj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0aOIluXr131XqrXFwFCFGT"},"href":"https://api.spotify.com/v1/artists/0aOIluXr131XqrXFwFCFGT","id":"0aOIluXr131XqrXFwFCFGT","name":"Sevek","type":"artist","uri":"spotify:artist:0aOIluXr131XqrXFwFCFGT"}],"disc_number":1,"duration_ms":157444,"explicit":false,"external_ids":{"isrc":"NLZ542101576"},"external_urls":{"spotify":"https://open.spotify.com/track/6GomT970rCOkKAyyrwJeZi"},"href":"https://api.spotify.com/v1/tracks/6GomT970rCOkKAyyrwJeZi","id":"6GomT970rCOkKAyyrwJeZi","is_local":false,"is_playable":true,"name":"Move Your Body","track_number":1,"type":"track","uri":"spotify:track:6GomT970rCOkKAyyrwJeZi"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VJ0briNOlXRtJUAzoUJdt"},"href":"https://api.spotify.com/v1/artists/1VJ0briNOlXRtJUAzoUJdt","id":"1VJ0briNOlXRtJUAzoUJdt","name":"FISHER","type":"artist","uri":"spotify:artist:1VJ0briNOlXRtJUAzoUJdt"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7mGI9Sd66FqHjIkwzkgbG7"},"href":"https://api.spotify.com/v1/artists/7mGI9Sd66FqHjIkwzkgbG7","id":"7mGI9Sd66FqHjIkwzkgbG7","name":"AR/CO","type":"artist","uri":"spotify:artist:7mGI9Sd66FqHjIkwzkgbG7"}],"external_urls":{"spotify":"https://open.spotify.com/album/0T84ITkYkKp7x3vxWpvSCf"},"href":"https://api.spotify.com/v1/albums/0T84ITkYkKp7x3vxWpvSCf","id":"0T84ITkYkKp7x3vxWpvSCf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730445db0af0b11d14db1c4cfa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020445db0af0b11d14db1c4cfa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510445db0af0b11d14db1c4cfa"}],"is_playable":true,"name":"Ocean","release_date":"2024-11-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0T84ITkYkKp7x3vxWpvSCf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VJ0briNOlXRtJUAzoUJdt"},"href":"https://api.spotify.com/v1/artists/1VJ0briNOlXRtJUAzoUJdt","id":"1VJ0briNOlXRtJUAzoUJdt","name":"FISHER","type":"artist","uri":"spotify:artist:1VJ0briNOlXRtJUAzoUJdt"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7mGI9Sd66FqHjIkwzkgbG7"},"href":"https://api.spotify.com/v1/artists/7mGI9Sd66FqHjIkwzkgbG7","id":"7mGI9Sd66FqHjIkwzkgbG7","name":"AR/CO","type":"artist","uri":"spotify:artist:7mGI9Sd66FqHjIkwzkgbG7"}],"disc_number":1,"duration_ms":196923,"explicit":false,"external_ids":{"isrc":"USCRR2400013"},"external_urls":{"spotify":"https://open.spotify.com/track/6jhAJgaS9OttFwP5Cn8WII"},"href":"https://api.spotify.com/v1/tracks/6jhAJgaS9OttFwP5Cn8WII","id":"6jhAJgaS9OttFwP5Cn8WII","is_local":false,"is_playable":true,"name":"Ocean","track_number":1,"type":"track","uri":"spotify:track:6jhAJgaS9OttFwP5Cn8WII"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Body%20Move%20Kove&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Body%20Move%20Kove&type=track","offset":0,"previous":null,"total":19,"items":[{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3BJfXq3PuHFiHrD6PcfpCd"},"href":"https://api.spotify.com/v1/artists/3BJfXq3PuHFiHrD6PcfpCd","id":"3BJfXq3PuHFiHrD6PcfpCd","name":"Lance Savali","type":"artist","uri":"spotify:artist:3BJfXq3PuHFiHrD6PcfpCd"}],"external_urls":{"spotify":"https://open.spotify.com/album/0OzvqL4iqJa92nxgHs2mkN"},"href":"https://api.spotify.com/v1/albums/0OzvqL4iqJa92nxgHs2mkN","id":"0OzvqL4iqJa92nxgHs2mkN","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273b929edd34d0d5cc09132f839"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02b929edd34d0d5cc09132f839"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851b929edd34d0d5cc09132f839"}],"is_playable":true,"name":"Move Ya Body","release_date":"2022-10-21","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0OzvqL4iqJa92nxgHs2mkN"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3BJfXq3PuHFiHrD6PcfpCd"},"href":"https://api.spotify.com/v1/artists/3BJfXq3PuHFiHrD6PcfpCd","id":"3BJfXq3PuHFiHrD6PcfpCd","name":"Lance Savali","type":"artist","uri":"spotify:artist:3BJfXq3PuHFiHrD6PcfpCd"}],"disc_number":1,"duration_ms":175021,"explicit":false,"external_ids":{"isrc":"NZUM72200272"},"external_urls":{"spotify":"https://open.spotify.com/track/2XvL3AOBDXqgQljhj9ksm2"},"href":"https://api.spotify.com/v1/tracks/2XvL3AOBDXqgQljhj9ksm2","id":"2XvL3AOBDXqgQljhj9ksm2","is_local":false,"is_playable":true,"name":"Move Ya Body","track_number":1,"type":"track","uri":"spotify:track:2XvL3AOBDXqgQljhj9ksm2"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6hBrJJrcYoNhvLC6KaFR4b"},"href":"https://api.spotify.com/v1/artists/6hBrJJrcYoNhvLC6KaFR4b","id":"6hBrJJrcYoNhvLC6KaFR4b","name":"Eliminate","type":"artist","uri":"spotify:artist:6hBrJJrcYoNhvLC6KaFR4b"}],"external_urls":{"spotify":"https://open.spotify.com/album/2dBce4y55fqAt8dbOhI9E3"},"href":"https://api.spotify.com/v1/albums/2dBce4y55fqAt8dbOhI9E3","id":"2dBce4y55fqAt8dbOhI9E3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27360b5f492440e38efe10d3a41"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0260b5f492440e38efe10d3a41"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485160b5f492440e38efe10d3a41"}],"is_playable":true,"name":"Turn It Up EP","release_date":"2025-09-12","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:2dBce4y55fqAt8dbOhI9E3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6hBrJJrcYoNhvLC6KaFR4b"},"href":"https://api.spotify.com/v1/artists/6hBrJJrcYoNhvLC6KaFR4b","id":"6hBrJJrcYoNhvLC6KaFR4b","name":"Eliminate","type":"artist","uri":"spotify:artist:6hBrJJrcYoNhvLC6KaFR4b"}],"disc_number":1,"duration_ms":143450,"explicit":false,"external_ids":{"isrc":"QZTGW2406156"},"external_urls":{"spotify":"https://open.spotify.com/track/1XvGtoO3ubLRFHXChk3Q1P"},"href":"https://api.spotify.com/v1/tracks/1XvGtoO3ubLRFHXChk3Q1P","id":"1XvGtoO3ubLRFHXChk3Q1P","is_local":false,"is_playable":true,"name":"BodyMove","track_number":4,"type":"track","uri":"spotify:track:1XvGtoO3ubLRFHXChk3Q1P"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SSciNLgRTNW5DQ7X8Df74"},"href":"https://api.spotify.com/v1/artists/0SSciNLgRTNW5DQ7X8Df74","id":"0SSciNLgRTNW5DQ7X8Df74","name":"Umaedo","type":"artist","uri":"spotify:artist:0SSciNLgRTNW5DQ7X8Df74"}],"external_urls":{"spotify":"https://open.spotify.com/album/18Lp7l7QbYlEEsMROnXQx5"},"href":"https://api.spotify.com/v1/albums/18Lp7l7QbYlEEsMROnXQx5","id":"18Lp7l7QbYlEEsMROnXQx5","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27306c221b9be7533e1cf13b488"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0206c221b9be7533e1cf13b488"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485106c221b9be7533e1cf13b488"}],"is_playable":true,"name":"Body Moving","release_date":"2026-03-27","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:18Lp7l7QbYlEEsMROnXQx5"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0SSciNLgRTNW5DQ7X8Df74"},"href":"https://api.spotify.com/v1/artists/0SSciNLgRTNW5DQ7X8Df74","id":"0SSciNLgRTNW5DQ7X8Df74","name":"Umaedo","type":"artist","uri":"spotify:artist:0SSciNLgRTNW5DQ7X8Df74"}],"disc_number":1,"duration_ms":171507,"explicit":false,"external_ids":{"isrc":"USA2P2618025"},"external_urls":{"spotify":"https://open.spotify.com/track/4XF44ZR69PSnEa1oIUfS88"},"href":"https://api.spotify.com/v1/tracks/4XF44ZR69PSnEa1oIUfS88","id":"4XF44ZR69PSnEa1oIUfS88","is_local":false,"is_playable":true,"name":"Body Moving","track_number":1,"type":"track","uri":"spotify:track:4XF44ZR69PSnEa1oIUfS88"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Di8r9df6xjyj6CVOqbGVz"},"href":"https://api.spotify.com/v1/artists/2Di8r9df6xjyj6CVOqbGVz","id":"2Di8r9df6xjyj6CVOqbGVz","name":"Marshall Jefferson","type":"artist","uri":"spotify:artist:2Di8r9df6xjyj6CVOqbGVz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0oO1IaDOBSeI96HbnCa5pZ"},"href":"https://api.spotify.com/v1/artists/0oO1IaDOBSeI96HbnCa5pZ","id":"0oO1IaDOBSeI96HbnCa5pZ","name":"Solardo","type":"artist","uri":"spotify:artist:0oO1IaDOBSeI96HbnCa5pZ"}],"external_urls":{"spotify":"https://open.spotify.com/album/3wXxLmmbbiQn8ndz1L2Wxo"},"href":"https://api.spotify.com/v1/albums/3wXxLmmbbiQn8ndz1L2Wxo","id":"3wXxLmmbbiQn8ndz1L2Wxo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c3f76f860585366e7a571c2c"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c3f76f860585366e7a571c2c"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c3f76f860585366e7a571c2c"}],"is_playable":true,"name":"Move Your Body","release_date":"2019-10-18","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3wXxLmmbbiQn8ndz1L2Wxo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2Di8r9df6xjyj6CVOqbGVz"},"href":"https://api.spotify.com/v1/artists/2Di8r9df6xjyj6CVOqbGVz","id":"2Di8r9df6xjyj6CVOqbGVz","name":"Marshall Jefferson","type":"artist","uri":"spotify:artist:2Di8r9df6xjyj6CVOqbGVz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0oO1IaDOBSeI96HbnCa5pZ"},"href":"https://api.spotify.com/v1/artists/0oO1IaDOBSeI96HbnCa5pZ","id":"0oO1IaDOBSeI96HbnCa5pZ","name":"Solardo","type":"artist","uri":"spotify:artist:0oO1IaDOBSeI96HbnCa5pZ"}],"disc_number":1,"duration_ms":196109,"explicit":false,"external_ids":{"isrc":"USUS11900546"},"external_urls":{"spotify":"https://open.spotify.com/track/3OrcEhLzxv1YX597jGjEI7"},"href":"https://api.spotify.com/v1/tracks/3OrcEhLzxv1YX597jGjEI7","id":"3OrcEhLzxv1YX597jGjEI7","is_local":false,"is_playable":true,"name":"Move Your Body","track_number":1,"type":"track","uri":"spotify:track:3OrcEhLzxv1YX597jGjEI7"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6eBYLQONaYZhZNAVK061t6"},"href":"https://api.spotify.com/v1/artists/6eBYLQONaYZhZNAVK061t6","id":"6eBYLQONaYZhZNAVK061t6","name":"Nina Sky","type":"artist","uri":"spotify:artist:6eBYLQONaYZhZNAVK061t6"}],"external_urls":{"spotify":"https://open.spotify.com/album/15Zjx7K5ifTVmXa3Nk5B88"},"href":"https://api.spotify.com/v1/albums/15Zjx7K5ifTVmXa3Nk5B88","id":"15Zjx7K5ifTVmXa3Nk5B88","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273e0c595c1a9a2f98535072fdd"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02e0c595c1a9a2f98535072fdd"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851e0c595c1a9a2f98535072fdd"}],"is_playable":true,"name":"Nina Sky","release_date":"2004-01-01","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:15Zjx7K5ifTVmXa3Nk5B88"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6eBYLQONaYZhZNAVK061t6"},"href":"https://api.spotify.com/v1/artists/6eBYLQONaYZhZNAVK061t6","id":"6eBYLQONaYZhZNAVK061t6","name":"Nina Sky","type":"artist","uri":"spotify:artist:6eBYLQONaYZhZNAVK061t6"},{"external_urls":{"spotify":"https://open.spotify.com/artist/3cbRMYnjXAwJYNzxy291JY"},"href":"https://api.spotify.com/v1/artists/3cbRMYnjXAwJYNzxy291JY","id":"3cbRMYnjXAwJYNzxy291JY","name":"Jabba","type":"artist","uri":"spotify:artist:3cbRMYnjXAwJYNzxy291JY"}],"disc_number":1,"duration_ms":232000,"explicit":false,"external_ids":{"isrc":"USUR10400494"},"external_urls":{"spotify":"https://open.spotify.com/track/2ndnVdR8si7CW9T8vJRHyW"},"href":"https://api.spotify.com/v1/tracks/2ndnVdR8si7CW9T8vJRHyW","id":"2ndnVdR8si7CW9T8vJRHyW","is_local":false,"is_playable":true,"name":"Move Ya Body","track_number":2,"type":"track","uri":"spotify:track:2ndnVdR8si7CW9T8vJRHyW"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1rpLzYzfrueWdkpcIunZQl"},"href":"https://api.spotify.com/v1/artists/1rpLzYzfrueWdkpcIunZQl","id":"1rpLzYzfrueWdkpcIunZQl","name":"Hard Driver","type":"artist","uri":"spotify:artist:1rpLzYzfrueWdkpcIunZQl"}],"external_urls":{"spotify":"https://open.spotify.com/album/35DequSIKFZ3uL2YeepqvD"},"href":"https://api.spotify.com/v1/albums/35DequSIKFZ3uL2YeepqvD","id":"35DequSIKFZ3uL2YeepqvD","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dd4fdfbe387ea62b5bf852e7"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dd4fdfbe387ea62b5bf852e7"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dd4fdfbe387ea62b5bf852e7"}],"is_playable":true,"name":"BODY MOVE","release_date":"2026-06-11","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:35DequSIKFZ3uL2YeepqvD"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1rpLzYzfrueWdkpcIunZQl"},"href":"https://api.spotify.com/v1/artists/1rpLzYzfrueWdkpcIunZQl","id":"1rpLzYzfrueWdkpcIunZQl","name":"Hard Driver","type":"artist","uri":"spotify:artist:1rpLzYzfrueWdkpcIunZQl"}],"disc_number":1,"duration_ms":158642,"explicit":false,"external_ids":{"isrc":"BEB682600528"},"external_urls":{"spotify":"https://open.spotify.com/track/6NqIFmNHR1sWzWGTmnYaLl"},"href":"https://api.spotify.com/v1/tracks/6NqIFmNHR1sWzWGTmnYaLl","id":"6NqIFmNHR1sWzWGTmnYaLl","is_local":false,"is_playable":true,"name":"BODY MOVE","track_number":1,"type":"track","uri":"spotify:track:6NqIFmNHR1sWzWGTmnYaLl"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4XC335ouK6pXyq4QiIb8bP"},"href":"https://api.spotify.com/v1/artists/4XC335ouK6pXyq4QiIb8bP","id":"4XC335ouK6pXyq4QiIb8bP","name":"Eliza Rose","type":"artist","uri":"spotify:artist:4XC335ouK6pXyq4QiIb8bP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7CajNmpbOovFoOoasH2HaY"},"href":"https://api.spotify.com/v1/artists/7CajNmpbOovFoOoasH2HaY","id":"7CajNmpbOovFoOoasH2HaY","name":"Calvin Harris","type":"artist","uri":"spotify:artist:7CajNmpbOovFoOoasH2HaY"}],"external_urls":{"spotify":"https://open.spotify.com/album/5EcypjAXyzxlrF5AKCNg9K"},"href":"https://api.spotify.com/v1/albums/5EcypjAXyzxlrF5AKCNg9K","id":"5EcypjAXyzxlrF5AKCNg9K","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273535aaa51352955a479bc5371"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02535aaa51352955a479bc5371"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851535aaa51352955a479bc5371"}],"is_playable":true,"name":"Body Moving","release_date":"2023-11-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:5EcypjAXyzxlrF5AKCNg9K"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/4XC335ouK6pXyq4QiIb8bP"},"href":"https://api.spotify.com/v1/artists/4XC335ouK6pXyq4QiIb8bP","id":"4XC335ouK6pXyq4QiIb8bP","name":"Eliza Rose","type":"artist","uri":"spotify:artist:4XC335ouK6pXyq4QiIb8bP"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7CajNmpbOovFoOoasH2HaY"},"href":"https://api.spotify.com/v1/artists/7CajNmpbOovFoOoasH2HaY","id":"7CajNmpbOovFoOoasH2HaY","name":"Calvin Harris","type":"artist","uri":"spotify:artist:7CajNmpbOovFoOoasH2HaY"}],"disc_number":1,"duration_ms":154215,"explicit":false,"external_ids":{"isrc":"GBARL2301617"},"external_urls":{"spotify":"https://open.spotify.com/track/5SFCEkybGYmmzKqewtDEaN"},"href":"https://api.spotify.com/v1/tracks/5SFCEkybGYmmzKqewtDEaN","id":"5SFCEkybGYmmzKqewtDEaN","is_local":false,"is_playable":true,"name":"Body Moving","track_number":1,"type":"track","uri":"spotify:track:5SFCEkybGYmmzKqewtDEaN"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NGAZxHanS9e0iNHpR8f2W"},"href":"https://api.spotify.com/v1/artists/0NGAZxHanS9e0iNHpR8f2W","id":"0NGAZxHanS9e0iNHpR8f2W","name":"Alok","type":"artist","uri":"spotify:artist:0NGAZxHanS9e0iNHpR8f2W"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77lzQa2JgjlkP4uA5ptyo7"},"href":"https://api.spotify.com/v1/artists/77lzQa2JgjlkP4uA5ptyo7","id":"77lzQa2JgjlkP4uA5ptyo7","name":"Mondello'G","type":"artist","uri":"spotify:artist:77lzQa2JgjlkP4uA5ptyo7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/32kPQzj1rk4nnGIIJpIUic"},"href":"https://api.spotify.com/v1/artists/32kPQzj1rk4nnGIIJpIUic","id":"32kPQzj1rk4nnGIIJpIUic","name":"CERES","type":"artist","uri":"spotify:artist:32kPQzj1rk4nnGIIJpIUic"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6iqDK7aHVlwGGgPmcdSK5L"},"href":"https://api.spotify.com/v1/artists/6iqDK7aHVlwGGgPmcdSK5L","id":"6iqDK7aHVlwGGgPmcdSK5L","name":"Tribbs","type":"artist","uri":"spotify:artist:6iqDK7aHVlwGGgPmcdSK5L"}],"external_urls":{"spotify":"https://open.spotify.com/album/1zz2cxnkEpgyLdSmoPBEjK"},"href":"https://api.spotify.com/v1/albums/1zz2cxnkEpgyLdSmoPBEjK","id":"1zz2cxnkEpgyLdSmoPBEjK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27381b16b41c622baf9678a899f"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0281b16b41c622baf9678a899f"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485181b16b41c622baf9678a899f"}],"is_playable":true,"name":"LET'S GET FKD UP (feat. Tribbs)","release_date":"2023-11-17","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:1zz2cxnkEpgyLdSmoPBEjK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0NGAZxHanS9e0iNHpR8f2W"},"href":"https://api.spotify.com/v1/artists/0NGAZxHanS9e0iNHpR8f2W","id":"0NGAZxHanS9e0iNHpR8f2W","name":"Alok","type":"artist","uri":"spotify:artist:0NGAZxHanS9e0iNHpR8f2W"},{"external_urls":{"spotify":"https://open.spotify.com/artist/77lzQa2JgjlkP4uA5ptyo7"},"href":"https://api.spotify.com/v1/artists/77lzQa2JgjlkP4uA5ptyo7","id":"77lzQa2JgjlkP4uA5ptyo7","name":"Mondello'G","type":"artist","uri":"spotify:artist:77lzQa2JgjlkP4uA5ptyo7"},{"external_urls":{"spotify":"https://open.spotify.com/artist/32kPQzj1rk4nnGIIJpIUic"},"href":"https://api.spotify.com/v1/artists/32kPQzj1rk4nnGIIJpIUic","id":"32kPQzj1rk4nnGIIJpIUic","name":"CERES","type":"artist","uri":"spotify:artist:32kPQzj1rk4nnGIIJpIUic"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6iqDK7aHVlwGGgPmcdSK5L"},"href":"https://api.spotify.com/v1/artists/6iqDK7aHVlwGGgPmcdSK5L","id":"6iqDK7aHVlwGGgPmcdSK5L","name":"Tribbs","type":"artist","uri":"spotify:artist:6iqDK7aHVlwGGgPmcdSK5L"}],"disc_number":1,"duration_ms":121500,"explicit":true,"external_ids":{"isrc":"DEE862301931"},"external_urls":{"spotify":"https://open.spotify.com/track/0iB5f04XdJ2tcfhoVkeLV8"},"href":"https://api.spotify.com/v1/tracks/0iB5f04XdJ2tcfhoVkeLV8","id":"0iB5f04XdJ2tcfhoVkeLV8","is_local":false,"is_playable":true,"name":"LET'S GET FKD UP","track_number":1,"type":"track","uri":"spotify:track:0iB5f04XdJ2tcfhoVkeLV8"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/37czgDRfGMvgRiUKHvnnhj"},"href":"https://api.spotify.com/v1/artists/37czgDRfGMvgRiUKHvnnhj","id":"37czgDRfGMvgRiUKHvnnhj","name":"\u00d6wnboss","type":"artist","uri":"spotify:artist:37czgDRfGMvgRiUKHvnnhj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0aOIluXr131XqrXFwFCFGT"},"href":"https://api.spotify.com/v1/artists/0aOIluXr131XqrXFwFCFGT","id":"0aOIluXr131XqrXFwFCFGT","name":"Sevek","type":"artist","uri":"spotify:artist:0aOIluXr131XqrXFwFCFGT"}],"external_urls":{"spotify":"https://open.spotify.com/album/4l9wMVL4XAM5jPMXP5RAbL"},"href":"https://api.spotify.com/v1/albums/4l9wMVL4XAM5jPMXP5RAbL","id":"4l9wMVL4XAM5jPMXP5RAbL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273dbe45fee4e36211b4bf8de71"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02dbe45fee4e36211b4bf8de71"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851dbe45fee4e36211b4bf8de71"}],"is_playable":true,"name":"Move Your Body","release_date":"2021-10-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:4l9wMVL4XAM5jPMXP5RAbL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/37czgDRfGMvgRiUKHvnnhj"},"href":"https://api.spotify.com/v1/artists/37czgDRfGMvgRiUKHvnnhj","id":"37czgDRfGMvgRiUKHvnnhj","name":"\u00d6wnboss","type":"artist","uri":"spotify:artist:37czgDRfGMvgRiUKHvnnhj"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0aOIluXr131XqrXFwFCFGT"},"href":"https://api.spotify.com/v1/artists/0aOIluXr131XqrXFwFCFGT","id":"0aOIluXr131XqrXFwFCFGT","name":"Sevek","type":"artist","uri":"spotify:artist:0aOIluXr131XqrXFwFCFGT"}],"disc_number":1,"duration_ms":157444,"explicit":false,"external_ids":{"isrc":"NLZ542101576"},"external_urls":{"spotify":"https://open.spotify.com/track/6GomT970rCOkKAyyrwJeZi"},"href":"https://api.spotify.com/v1/tracks/6GomT970rCOkKAyyrwJeZi","id":"6GomT970rCOkKAyyrwJeZi","is_local":false,"is_playable":true,"name":"Move Your Body","track_number":1,"type":"track","uri":"spotify:track:6GomT970rCOkKAyyrwJeZi"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VJ0briNOlXRtJUAzoUJdt"},"href":"https://api.spotify.com/v1/artists/1VJ0briNOlXRtJUAzoUJdt","id":"1VJ0briNOlXRtJUAzoUJdt","name":"FISHER","type":"artist","uri":"spotify:artist:1VJ0briNOlXRtJUAzoUJdt"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7mGI9Sd66FqHjIkwzkgbG7"},"href":"https://api.spotify.com/v1/artists/7mGI9Sd66FqHjIkwzkgbG7","id":"7mGI9Sd66FqHjIkwzkgbG7","name":"AR/CO","type":"artist","uri":"spotify:artist:7mGI9Sd66FqHjIkwzkgbG7"}],"external_urls":{"spotify":"https://open.spotify.com/album/0T84ITkYkKp7x3vxWpvSCf"},"href":"https://api.spotify.com/v1/albums/0T84ITkYkKp7x3vxWpvSCf","id":"0T84ITkYkKp7x3vxWpvSCf","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730445db0af0b11d14db1c4cfa"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020445db0af0b11d14db1c4cfa"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510445db0af0b11d14db1c4cfa"}],"is_playable":true,"name":"Ocean","release_date":"2024-11-29","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:0T84ITkYkKp7x3vxWpvSCf"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1VJ0briNOlXRtJUAzoUJdt"},"href":"https://api.spotify.com/v1/artists/1VJ0briNOlXRtJUAzoUJdt","id":"1VJ0briNOlXRtJUAzoUJdt","name":"FISHER","type":"artist","uri":"spotify:artist:1VJ0briNOlXRtJUAzoUJdt"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7mGI9Sd66FqHjIkwzkgbG7"},"href":"https://api.spotify.com/v1/artists/7mGI9Sd66FqHjIkwzkgbG7","id":"7mGI9Sd66FqHjIkwzkgbG7","name":"AR/CO","type":"artist","uri":"spotify:artist:7mGI9Sd66FqHjIkwzkgbG7"}],"disc_number":1,"duration_ms":196923,"explicit":false,"external_ids":{"isrc":"USCRR2400013"},"external_urls":{"spotify":"https://open.spotify.com/track/6jhAJgaS9OttFwP5Cn8WII"},"href":"https://api.spotify.com/v1/tracks/6jhAJgaS9OttFwP5Cn8WII","id":"6jhAJgaS9OttFwP5Cn8WII","is_local":false,"is_playable":true,"name":"Ocean","track_number":1,"type":"track","uri":"spotify:track:6jhAJgaS9OttFwP5Cn8WII"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Body+Move+Kove&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=track%3A%22Rock%20It%22%20artist%3A%22Sub%20Focus%22&type=track","limit":10,"next":null,"offset":0,"previous":null,"total":0,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"external_urls":{"spotify":"https://open.spotify.com/album/4hkUZ0YXr0Nnx9wCRpGykS"},"href":"https://api.spotify.com/v1/albums/4hkUZ0YXr0Nnx9wCRpGykS","id":"4hkUZ0YXr0Nnx9wCRpGykS","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a752489a348374c57efb6eee"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a752489a348374c57efb6eee"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a752489a348374c57efb6eee"}],"is_playable":true,"name":"Reworks I","release_date":"2021-09-17","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:4hkUZ0YXr0Nnx9wCRpGykS"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m8itYST9ADjBIYevXSb1r"},"href":"https://api.spotify.com/v1/artists/6m8itYST9ADjBIYevXSb1r","id":"6m8itYST9ADjBIYevXSb1r","name":"Wilkinson","type":"artist","uri":"spotify:artist:6m8itYST9ADjBIYevXSb1r"}],"disc_number":1,"duration_ms":272840,"explicit":false,"external_ids":{"isrc":"GB5KW2102262"},"external_urls":{"spotify":"https://open.spotify.com/track/1WShqPmOqOWljVNxI60ZA4"},"href":"https://api.spotify.com/v1/tracks/1WShqPmOqOWljVNxI60ZA4","id":"1WShqPmOqOWljVNxI60ZA4","is_local":false,"is_playable":true,"name":"Rock It - Wilkinson Remix","track_number":1,"type":"track","uri":"spotify:track:1WShqPmOqOWljVNxI60ZA4"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"external_urls":{"spotify":"https://open.spotify.com/album/1puaRzEhhLvXP17jUEGWb3"},"href":"https://api.spotify.com/v1/albums/1puaRzEhhLvXP17jUEGWb3","id":"1puaRzEhhLvXP17jUEGWb3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734999f72f9c376a7674411172"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024999f72f9c376a7674411172"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514999f72f9c376a7674411172"}],"is_playable":true,"name":"Sub Focus","release_date":"2009-09-14","release_date_precision":"day","total_tracks":13,"type":"album","uri":"spotify:album:1puaRzEhhLvXP17jUEGWb3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":275120,"explicit":false,"external_ids":{"isrc":"GBBZH0991306"},"external_urls":{"spotify":"https://open.spotify.com/track/69PmbaybVYoxErPtJ5v7Th"},"href":"https://api.spotify.com/v1/tracks/69PmbaybVYoxErPtJ5v7Th","id":"69PmbaybVYoxErPtJ5v7Th","is_local":false,"is_playable":true,"name":"Rock It","track_number":6,"type":"track","uri":"spotify:track:69PmbaybVYoxErPtJ5v7Th"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m8itYST9ADjBIYevXSb1r"},"href":"https://api.spotify.com/v1/artists/6m8itYST9ADjBIYevXSb1r","id":"6m8itYST9ADjBIYevXSb1r","name":"Wilkinson","type":"artist","uri":"spotify:artist:6m8itYST9ADjBIYevXSb1r"}],"external_urls":{"spotify":"https://open.spotify.com/album/3fJUuqlf7uesC5yvmTkoZY"},"href":"https://api.spotify.com/v1/albums/3fJUuqlf7uesC5yvmTkoZY","id":"3fJUuqlf7uesC5yvmTkoZY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2735c096dc6256ea35e5cd127ec"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e025c096dc6256ea35e5cd127ec"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048515c096dc6256ea35e5cd127ec"}],"is_playable":true,"name":"Rock It (Wilkinson Remix)","release_date":"2021-07-19","release_date_precision":"day","total_tracks":1,"type":"album","uri":"spotify:album:3fJUuqlf7uesC5yvmTkoZY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m8itYST9ADjBIYevXSb1r"},"href":"https://api.spotify.com/v1/artists/6m8itYST9ADjBIYevXSb1r","id":"6m8itYST9ADjBIYevXSb1r","name":"Wilkinson","type":"artist","uri":"spotify:artist:6m8itYST9ADjBIYevXSb1r"}],"disc_number":1,"duration_ms":272840,"explicit":false,"external_ids":{"isrc":"GB5KW2102262"},"external_urls":{"spotify":"https://open.spotify.com/track/7aYilD8vBLICtiJ7Pt6XLY"},"href":"https://api.spotify.com/v1/tracks/7aYilD8vBLICtiJ7Pt6XLY","id":"7aYilD8vBLICtiJ7Pt6XLY","is_local":false,"is_playable":true,"name":"Rock It - Wilkinson Remix","track_number":1,"type":"track","uri":"spotify:track:7aYilD8vBLICtiJ7Pt6XLY"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"external_urls":{"spotify":"https://open.spotify.com/album/7iZlJtPfM5njkyAw62qAPo"},"href":"https://api.spotify.com/v1/albums/7iZlJtPfM5njkyAw62qAPo","id":"7iZlJtPfM5njkyAw62qAPo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ba5b9ea1f45399c7f46bc059"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ba5b9ea1f45399c7f46bc059"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ba5b9ea1f45399c7f46bc059"}],"is_playable":true,"name":"Rock It / Follow the Light","release_date":"2009-06-29","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:7iZlJtPfM5njkyAw62qAPo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":301733,"explicit":false,"external_ids":{"isrc":"GBBZH0907801"},"external_urls":{"spotify":"https://open.spotify.com/track/4O3isH2F6JL7ZOdBWLhwGu"},"href":"https://api.spotify.com/v1/tracks/4O3isH2F6JL7ZOdBWLhwGu","id":"4O3isH2F6JL7ZOdBWLhwGu","is_local":false,"is_playable":true,"name":"Rock It","track_number":1,"type":"track","uri":"spotify:track:4O3isH2F6JL7ZOdBWLhwGu"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"external_urls":{"spotify":"https://open.spotify.com/album/7iZlJtPfM5njkyAw62qAPo"},"href":"https://api.spotify.com/v1/albums/7iZlJtPfM5njkyAw62qAPo","id":"7iZlJtPfM5njkyAw62qAPo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ba5b9ea1f45399c7f46bc059"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ba5b9ea1f45399c7f46bc059"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ba5b9ea1f45399c7f46bc059"}],"is_playable":true,"name":"Rock It / Follow the Light","release_date":"2009-06-29","release_date_precision":"day","total_tracks":5,"type":"album","uri":"spotify:album:7iZlJtPfM5njkyAw62qAPo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":172986,"explicit":false,"external_ids":{"isrc":"GBBZH0907804"},"external_urls":{"spotify":"https://open.spotify.com/track/2plddWcVfuvB2QwkFumela"},"href":"https://api.spotify.com/v1/tracks/2plddWcVfuvB2QwkFumela","id":"2plddWcVfuvB2QwkFumela","is_local":false,"is_playable":true,"name":"Rock It - Radio Edit","track_number":4,"type":"track","uri":"spotify:track:2plddWcVfuvB2QwkFumela"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/0Saj39tbcH2t5C5hugWjGk"},"href":"https://api.spotify.com/v1/albums/0Saj39tbcH2t5C5hugWjGk","id":"0Saj39tbcH2t5C5hugWjGk","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273ae25236fd6e83c1b90796a6e"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02ae25236fd6e83c1b90796a6e"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851ae25236fd6e83c1b90796a6e"}],"is_playable":true,"name":"RAM 25","release_date":"2017-12-15","release_date_precision":"day","total_tracks":41,"type":"album","uri":"spotify:album:0Saj39tbcH2t5C5hugWjGk"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"}],"disc_number":1,"duration_ms":275120,"explicit":false,"external_ids":{"isrc":"GBBZH0991306"},"external_urls":{"spotify":"https://open.spotify.com/track/2NxMjliQD4rRBk7jqYC7ZN"},"href":"https://api.spotify.com/v1/tracks/2NxMjliQD4rRBk7jqYC7ZN","id":"2NxMjliQD4rRBk7jqYC7ZN","is_local":false,"is_playable":true,"name":"Rock It","track_number":5,"type":"track","uri":"spotify:track:2NxMjliQD4rRBk7jqYC7ZN"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/13j5MrWYURgUNzqvhmRMc3"},"href":"https://api.spotify.com/v1/albums/13j5MrWYURgUNzqvhmRMc3","id":"13j5MrWYURgUNzqvhmRMc3","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737e23f8c811ecfda898da8dad"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027e23f8c811ecfda898da8dad"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517e23f8c811ecfda898da8dad"}],"is_playable":true,"name":"RAM Drum & Bass Annual 2022","release_date":"2021-12-17","release_date_precision":"day","total_tracks":40,"type":"album","uri":"spotify:album:13j5MrWYURgUNzqvhmRMc3"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0QaSiI5TLA4N7mcsdxShDO"},"href":"https://api.spotify.com/v1/artists/0QaSiI5TLA4N7mcsdxShDO","id":"0QaSiI5TLA4N7mcsdxShDO","name":"Sub Focus","type":"artist","uri":"spotify:artist:0QaSiI5TLA4N7mcsdxShDO"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6m8itYST9ADjBIYevXSb1r"},"href":"https://api.spotify.com/v1/artists/6m8itYST9ADjBIYevXSb1r","id":"6m8itYST9ADjBIYevXSb1r","name":"Wilkinson","type":"artist","uri":"spotify:artist:6m8itYST9ADjBIYevXSb1r"}],"disc_number":1,"duration_ms":272840,"explicit":false,"external_ids":{"isrc":"GB5KW2102262"},"external_urls":{"spotify":"https://open.spotify.com/track/25qt8FBtWeEmjHLAsGBJrY"},"href":"https://api.spotify.com/v1/tracks/25qt8FBtWeEmjHLAsGBJrY","id":"25qt8FBtWeEmjHLAsGBJrY","is_local":false,"is_playable":true,"name":"Rock It - Wilkinson Remix","track_number":19,"type":"track","uri":"spotify:track:25qt8FBtWeEmjHLAsGBJrY"}]}}", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMlJvY2slMjBJdCUyMiUyMGFydGlzdCUzQSUyMlN1YiUyMEZvY3VzJTIyJnR5cGU9dHJhY2siLCJsaW1pdCI6MTAsIm5leHQiOm51bGwsIm9mZnNldCI6MCwicHJldmlvdXMiOm51bGwsInRvdGFsIjowLCJpdGVtcyI6W3siYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wUWFTaUk1VExBNE43bWNzZHhTaERPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBRYVNpSTVUTEE0TjdtY3NkeFNoRE8iLCJpZCI6IjBRYVNpSTVUTEE0TjdtY3NkeFNoRE8iLCJuYW1lIjoiU3ViIEZvY3VzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBRYVNpSTVUTEE0TjdtY3NkeFNoRE8ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS80aGtVWjBZWHIwTm54OXdDUnBHeWtTIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvNGhrVVowWVhyME5ueDl3Q1JwR3lrUyIsImlkIjoiNGhrVVowWVhyME5ueDl3Q1JwR3lrUyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdl", + "L2FiNjc2MTZkMDAwMGIyNzNhNzUyNDg5YTM0ODM3NGM1N2VmYjZlZWUifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYTc1MjQ4OWEzNDgzNzRjNTdlZmI2ZWVlIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFhNzUyNDg5YTM0ODM3NGM1N2VmYjZlZWUifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUmV3b3JrcyBJIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wOS0xNyIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEyLCJ0eXBlIjoiYWxidW0iLCJ1cmkiOiJzcG90aWZ5OmFsYnVtOjRoa1VaMFlYcjBObng5d0NScEd5a1MifSwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wUWFTaUk1VExBNE43bWNzZHhTaERPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBRYVNpSTVUTEE0TjdtY3NkeFNoRE8iLCJpZCI6IjBRYVNpSTVUTEE0TjdtY3NkeFNoRE8iLCJuYW1lIjoiU3ViIEZvY3VzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBRYVNpSTVUTEE0TjdtY3NkeFNoRE8ifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNm04aXRZU1Q5QURqQklZZXZYU2IxciJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82bThpdFlTVDlBRGpCSVlldlhTYjFyIiwiaWQiOiI2bThpdFlTVDlBRGpCSVlldlhTYjFyIiwibmFtZSI6IldpbGtpbnNvbiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2bThpdFlTVDlBRGpCSVlldlhTYjFyIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI3Mjg0MCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCNUtXMjEwMjI2MiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMVdTaHFQbU9xT1dsalZOeEk2MFpBNCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzFXU2hxUG1PcU9XbGpWTnhJNjBaQTQiLCJpZCI6IjFXU2hxUG1PcU9XbGpWTnhJNjBaQTQiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm9jayBJdCAtIFdpbGtpbnNvbiBSZW1peCIsInRyYWNrX251bWJlciI6MSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoxV1NocVBtT3FPV2xqVk54STYwWg==", + "QTQifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJhbGJ1bSIsImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFFhU2lJNVRMQTRON21jc2R4U2hETyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUWFTaUk1VExBNE43bWNzZHhTaERPIiwiaWQiOiIwUWFTaUk1VExBNE43bWNzZHhTaERPIiwibmFtZSI6IlN1YiBGb2N1cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUWFTaUk1VExBNE43bWNzZHhTaERPIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vMXB1YVJ6RWhoTHZYUDE3alVFR1diMyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzFwdWFSekVoaEx2WFAxN2pVRUdXYjMiLCJpZCI6IjFwdWFSekVoaEx2WFAxN2pVRUdXYjMiLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczNDk5OWY3MmY5YzM3NmE3Njc0NDExMTcyIn0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMjQ5OTlmNzJmOWMzNzZhNzY3NDQxMTE3MiJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxNDk5OWY3MmY5YzM3NmE3Njc0NDExMTcyIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlN1YiBGb2N1cyIsInJlbGVhc2VfZGF0ZSI6IjIwMDktMDktMTQiLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjoxMywidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxcHVhUnpFaGhMdlhQMTdqVUVHV2IzIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFFhU2lJNVRMQTRON21jc2R4U2hETyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUWFTaUk1VExBNE43bWNzZHhTaERPIiwiaWQiOiIwUWFTaUk1VExBNE43bWNzZHhTaERPIiwibmFtZSI6IlN1YiBGb2N1cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUWFTaUk1VExBNE43bWNzZHhTaERPIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI3NTEyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQlpIMDk5MTMwNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodA==", + "dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay82OVBtYmF5YlZZb3hFclB0SjV2N1RoIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvNjlQbWJheWJWWW94RXJQdEo1djdUaCIsImlkIjoiNjlQbWJheWJWWW94RXJQdEo1djdUaCIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb2NrIEl0IiwidHJhY2tfbnVtYmVyIjo2LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjY5UG1iYXliVllveEVyUHRKNXY3VGgifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBRYVNpSTVUTEE0TjdtY3NkeFNoRE8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFFhU2lJNVRMQTRON21jc2R4U2hETyIsImlkIjoiMFFhU2lJNVRMQTRON21jc2R4U2hETyIsIm5hbWUiOiJTdWIgRm9jdXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFFhU2lJNVRMQTRON21jc2R4U2hETyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bThpdFlTVDlBRGpCSVlldlhTYjFyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZtOGl0WVNUOUFEakJJWWV2WFNiMXIiLCJpZCI6IjZtOGl0WVNUOUFEakJJWWV2WFNiMXIiLCJuYW1lIjoiV2lsa2luc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZtOGl0WVNUOUFEakJJWWV2WFNiMXIifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8zZkpVdXFsZjd1ZXNDNXl2bVRrb1pZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvM2ZKVXVxbGY3dWVzQzV5dm1Ua29aWSIsImlkIjoiM2ZKVXVxbGY3dWVzQzV5dm1Ua29aWSIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzM1YzA5NmRjNjI1NmVhMzVlNWNkMTI3ZWMifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyNWMwOTZkYzYyNTZlYTM1ZTVjZDEyN2VjIn0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTE1YzA5NmRjNjI1NmVhMzVlNWNkMTI3ZWMifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm9jayBJdA==", + "IChXaWxraW5zb24gUmVtaXgpIiwicmVsZWFzZV9kYXRlIjoiMjAyMS0wNy0xOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06M2ZKVXVxbGY3dWVzQzV5dm1Ua29aWSJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBRYVNpSTVUTEE0TjdtY3NkeFNoRE8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFFhU2lJNVRMQTRON21jc2R4U2hETyIsImlkIjoiMFFhU2lJNVRMQTRON21jc2R4U2hETyIsIm5hbWUiOiJTdWIgRm9jdXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFFhU2lJNVRMQTRON21jc2R4U2hETyJ9LHsiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82bThpdFlTVDlBRGpCSVlldlhTYjFyIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZtOGl0WVNUOUFEakJJWWV2WFNiMXIiLCJpZCI6IjZtOGl0WVNUOUFEakJJWWV2WFNiMXIiLCJuYW1lIjoiV2lsa2luc29uIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZtOGl0WVNUOUFEakJJWWV2WFNiMXIifV0sImRpc2NfbnVtYmVyIjoxLCJkdXJhdGlvbl9tcyI6MjcyODQwLCJleHBsaWNpdCI6ZmFsc2UsImV4dGVybmFsX2lkcyI6eyJpc3JjIjoiR0I1S1cyMTAyMjYyIn0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay83YVlpbEQ4dkJMSUN0aUo3UHQ2WExZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvN2FZaWxEOHZCTElDdGlKN1B0NlhMWSIsImlkIjoiN2FZaWxEOHZCTElDdGlKN1B0NlhMWSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb2NrIEl0IC0gV2lsa2luc29uIFJlbWl4IiwidHJhY2tfbnVtYmVyIjoxLCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjdhWWlsRDh2QkxJQ3RpSjdQdDZYTFkifSx7ImFsYnVtIjp7ImFsYnVtX3R5cGUiOiJzaW5nbGUiLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBRYVNpSTVUTEE0TjdtY3NkeFNoRE8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFFhU2lJNVRMQTRON21jc2R4U2hETyIsImlkIjoiMFFhU2lJNVRMQTRON21jc2R4U2hETyIsIm5hbWUiOiJTdWIgRm9jdXMiLCJ0eXBlIjoiYXJ0aQ==", + "c3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUWFTaUk1VExBNE43bWNzZHhTaERPIn1dLCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYWxidW0vN2labEp0UGZNNW5qa3lBdzYycUFQbyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYWxidW1zLzdpWmxKdFBmTTVuamt5QXc2MnFBUG8iLCJpZCI6IjdpWmxKdFBmTTVuamt5QXc2MnFBUG8iLCJpbWFnZXMiOlt7ImhlaWdodCI6NjQwLCJ3aWR0aCI6NjQwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDBiMjczYmE1YjllYTFmNDUzOTljN2Y0NmJjMDU5In0seyJoZWlnaHQiOjMwMCwid2lkdGgiOjMwMCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwMWUwMmJhNWI5ZWExZjQ1Mzk5YzdmNDZiYzA1OSJ9LHsiaGVpZ2h0Ijo2NCwid2lkdGgiOjY0LCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxYmE1YjllYTFmNDUzOTljN2Y0NmJjMDU5In1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvY2sgSXQgLyBGb2xsb3cgdGhlIExpZ2h0IiwicmVsZWFzZV9kYXRlIjoiMjAwOS0wNi0yOSIsInJlbGVhc2VfZGF0ZV9wcmVjaXNpb24iOiJkYXkiLCJ0b3RhbF90cmFja3MiOjUsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06N2labEp0UGZNNW5qa3lBdzYycUFQbyJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBRYVNpSTVUTEE0TjdtY3NkeFNoRE8ifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMFFhU2lJNVRMQTRON21jc2R4U2hETyIsImlkIjoiMFFhU2lJNVRMQTRON21jc2R4U2hETyIsIm5hbWUiOiJTdWIgRm9jdXMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MFFhU2lJNVRMQTRON21jc2R4U2hETyJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjozMDE3MzMsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQkJaSDA5MDc4MDEifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzRPM2lzSDJGNkpMN1pPZEJXTGh3R3UifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy80TzNpc0gyRjZKTDdaT2RCV0xod0d1IiwiaWQiOiI0TzNpc0gyRjZKTDdaT2RCV0xod0d1IiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvY2sgSXQiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwbw==", + "dGlmeTp0cmFjazo0TzNpc0gyRjZKTDdaT2RCV0xod0d1In0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC8wUWFTaUk1VExBNE43bWNzZHhTaERPIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzBRYVNpSTVUTEE0TjdtY3NkeFNoRE8iLCJpZCI6IjBRYVNpSTVUTEE0TjdtY3NkeFNoRE8iLCJuYW1lIjoiU3ViIEZvY3VzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjBRYVNpSTVUTEE0TjdtY3NkeFNoRE8ifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS83aVpsSnRQZk01bmpreUF3NjJxQVBvIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvN2labEp0UGZNNW5qa3lBdzYycUFQbyIsImlkIjoiN2labEp0UGZNNW5qa3lBdzYycUFQbyIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiYTViOWVhMWY0NTM5OWM3ZjQ2YmMwNTkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYmE1YjllYTFmNDUzOTljN2Y0NmJjMDU5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiYTViOWVhMWY0NTM5OWM3ZjQ2YmMwNTkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm9jayBJdCAvIEZvbGxvdyB0aGUgTGlnaHQiLCJyZWxlYXNlX2RhdGUiOiIyMDA5LTA2LTI5IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTo3aVpsSnRQZk01bmpreUF3NjJxQVBvIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFFhU2lJNVRMQTRON21jc2R4U2hETyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUWFTaUk1VExBNE43bWNzZHhTaERPIiwiaWQiOiIwUWFTaUk1VExBNE43bWNzZHhTaERPIiwibmFtZSI6IlN1YiBGb2N1cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUWFTaUk1VExBNE43bWNzZHhTaERPIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjE3Mjk4NiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYw==", + "IjoiR0JCWkgwOTA3ODA0In0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS90cmFjay8ycGxkZFdjVmZ1dkIyUXdrRnVtZWxhIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMnBsZGRXY1ZmdXZCMlF3a0Z1bWVsYSIsImlkIjoiMnBsZGRXY1ZmdXZCMlF3a0Z1bWVsYSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSb2NrIEl0IC0gUmFkaW8gRWRpdCIsInRyYWNrX251bWJlciI6NCwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoycGxkZFdjVmZ1dkIyUXdrRnVtZWxhIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBTYWozOXRiY0gydDVDNWh1Z1dqR2sifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wU2FqMzl0YmNIMnQ1QzVodWdXakdrIiwiaWQiOiIwU2FqMzl0YmNIMnQ1QzVodWdXakdrIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2FlMjUyMzZmZDZlODNjMWI5MDc5NmE2ZSJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJhZTI1MjM2ZmQ2ZTgzYzFiOTA3OTZhNmUifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWFlMjUyMzZmZDZlODNjMWI5MDc5NmE2ZSJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJSQU0gMjUiLCJyZWxlYXNlX2RhdGUiOiIyMDE3LTEyLTE1IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDEsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MFNhajM5dGJjSDJ0NUM1aHVnV2pHayJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4ucw==", + "cG90aWZ5LmNvbS9hcnRpc3QvMFFhU2lJNVRMQTRON21jc2R4U2hETyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUWFTaUk1VExBNE43bWNzZHhTaERPIiwiaWQiOiIwUWFTaUk1VExBNE43bWNzZHhTaERPIiwibmFtZSI6IlN1YiBGb2N1cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUWFTaUk1VExBNE43bWNzZHhTaERPIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjI3NTEyMCwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCQlpIMDk5MTMwNiJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svMk54TWpsaVFENHJSQms3anFZQzdaTiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzJOeE1qbGlRRDRyUkJrN2pxWUM3Wk4iLCJpZCI6IjJOeE1qbGlRRDRyUkJrN2pxWUM3Wk4iLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiUm9jayBJdCIsInRyYWNrX251bWJlciI6NSwidHlwZSI6InRyYWNrIiwidXJpIjoic3BvdGlmeTp0cmFjazoyTnhNamxpUUQ0clJCazdqcVlDN1pOIn0seyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoiY29tcGlsYXRpb24iLCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzBMeWZRV0pUNm5YYWZMUFpxeGU5T2YifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsImlkIjoiMEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiIsIm5hbWUiOiJWYXJpb3VzIEFydGlzdHMiLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6MEx5ZlFXSlQ2blhhZkxQWnF4ZTlPZiJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzEzajVNcldZVVJnVU56cXZobVJNYzMifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8xM2o1TXJXWVVSZ1VOenF2aG1STWMzIiwiaWQiOiIxM2o1TXJXWVVSZ1VOenF2aG1STWMzIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3MzdlMjNmOGM4MTFlY2ZkYTg5OGRhOGRhZCJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDI3ZTIzZjhjODExZWNmZGE4OThkYThkYWQifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLg==", + "c2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDA0ODUxN2UyM2Y4YzgxMWVjZmRhODk4ZGE4ZGFkIn1dLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJBTSBEcnVtICYgQmFzcyBBbm51YWwgMjAyMiIsInJlbGVhc2VfZGF0ZSI6IjIwMjEtMTItMTciLCJyZWxlYXNlX2RhdGVfcHJlY2lzaW9uIjoiZGF5IiwidG90YWxfdHJhY2tzIjo0MCwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bToxM2o1TXJXWVVSZ1VOenF2aG1STWMzIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvMFFhU2lJNVRMQTRON21jc2R4U2hETyJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy8wUWFTaUk1VExBNE43bWNzZHhTaERPIiwiaWQiOiIwUWFTaUk1VExBNE43bWNzZHhTaERPIiwibmFtZSI6IlN1YiBGb2N1cyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDowUWFTaUk1VExBNE43bWNzZHhTaERPIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZtOGl0WVNUOUFEakJJWWV2WFNiMXIifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNm04aXRZU1Q5QURqQklZZXZYU2IxciIsImlkIjoiNm04aXRZU1Q5QURqQklZZXZYU2IxciIsIm5hbWUiOiJXaWxraW5zb24iLCJ0eXBlIjoiYXJ0aXN0IiwidXJpIjoic3BvdGlmeTphcnRpc3Q6Nm04aXRZU1Q5QURqQklZZXZYU2IxciJ9XSwiZGlzY19udW1iZXIiOjEsImR1cmF0aW9uX21zIjoyNzI4NDAsImV4cGxpY2l0IjpmYWxzZSwiZXh0ZXJuYWxfaWRzIjp7ImlzcmMiOiJHQjVLVzIxMDIyNjIifSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLzI1cXQ4RkJ0V2VFbWpITEFzR0JKclkifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3RyYWNrcy8yNXF0OEZCdFdlRW1qSExBc0dCSnJZIiwiaWQiOiIyNXF0OEZCdFdlRW1qSExBc0dCSnJZIiwiaXNfbG9jYWwiOmZhbHNlLCJpc19wbGF5YWJsZSI6dHJ1ZSwibmFtZSI6IlJvY2sgSXQgLSBXaWxraW5zb24gUmVtaXgiLCJ0cmFja19udW1iZXIiOjE5LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjI1cXQ4RkJ0V2VFbWpITEFzR0JKclkifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22Rock+It%22+artist%3A%22Sub+Focus%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "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", + "response_chunks_base64": [ + "eyJ0cmFja3MiOnsiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL3NlYXJjaD9vZmZzZXQ9MCZsaW1pdD0xMCZxdWVyeT10cmFjayUzQSUyMkhpZ2glMjBOb3RlJTIyJTIwYXJ0aXN0JTNBJTIySyUyME1vdGlvbnolMjImdHlwZT10cmFjayIsImxpbWl0IjoxMCwibmV4dCI6bnVsbCwib2Zmc2V0IjowLCJwcmV2aW91cyI6bnVsbCwidG90YWwiOjIsIml0ZW1zIjpbeyJhbGJ1bSI6eyJhbGJ1bV90eXBlIjoic2luZ2xlIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC82UVlkWFRvTW80WEhuRzFBbkVWWllKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzZRWWRYVG9NbzRYSG5HMUFuRVZaWUoiLCJpZCI6IjZRWWRYVG9NbzRYSG5HMUFuRVZaWUoiLCJuYW1lIjoiSyBNb3Rpb256IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjZRWWRYVG9NbzRYSG5HMUFuRVZaWUoifSx7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNTFmZXJ4b2NFS3Qwdmp4elVzcXlGWCJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy81MWZlcnhvY0VLdDB2anh6VXNxeUZYIiwiaWQiOiI1MWZlcnhvY0VLdDB2anh6VXNxeUZYIiwibmFtZSI6IkVtaWx5IE1ha2lzIiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjUxZg==", + "ZXJ4b2NFS3Qwdmp4elVzcXlGWCJ9XSwiZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLzBCS2pUVzQ5cXhPNmo4bWQ5ZVc5MWcifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FsYnVtcy8wQktqVFc0OXF4TzZqOG1kOWVXOTFnIiwiaWQiOiIwQktqVFc0OXF4TzZqOG1kOWVXOTFnIiwiaW1hZ2VzIjpbeyJoZWlnaHQiOjY0MCwid2lkdGgiOjY0MCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwYjI3M2IxZmNlZWY2MjBiZmY0YzAyY2Q0MWE5YiJ9LHsiaGVpZ2h0IjozMDAsIndpZHRoIjozMDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDFlMDJiMWZjZWVmNjIwYmZmNGMwMmNkNDFhOWIifSx7ImhlaWdodCI6NjQsIndpZHRoIjo2NCwidXJsIjoiaHR0cHM6Ly9pLnNjZG4uY28vaW1hZ2UvYWI2NzYxNmQwMDAwNDg1MWIxZmNlZWY2MjBiZmY0YzAyY2Q0MWE5YiJ9XSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIaWdoIE5vdGUiLCJyZWxlYXNlX2RhdGUiOiIyMDIxLTA5LTIyIiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6MSwidHlwZSI6ImFsYnVtIiwidXJpIjoic3BvdGlmeTphbGJ1bTowQktqVFc0OXF4TzZqOG1kOWVXOTFnIn0sImFydGlzdHMiOlt7ImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hcnRpc3QvNlFZZFhUb01vNFhIbkcxQW5FVlpZSiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvYXJ0aXN0cy82UVlkWFRvTW80WEhuRzFBbkVWWllKIiwiaWQiOiI2UVlkWFRvTW80WEhuRzFBbkVWWllKIiwibmFtZSI6IksgTW90aW9ueiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2UVlkWFRvTW80WEhuRzFBbkVWWllKIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzUxZmVyeG9jRUt0MHZqeHpVc3F5RlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTFmZXJ4b2NFS3Qwdmp4elVzcXlGWCIsImlkIjoiNTFmZXJ4b2NFS3Qwdmp4elVzcXlGWCIsIm5hbWUiOiJFbWlseSBNYWtpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1MWZlcnhvY0VLdDB2anh6VXNxeUZYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyNTg2MiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCMkxEMjExMDI2OCJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdA==", + "cmFjay8yOGY1Y0hPYWh0QTNKaGJJQnQ5cTlZIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS90cmFja3MvMjhmNWNIT2FodEEzSmhiSUJ0OXE5WSIsImlkIjoiMjhmNWNIT2FodEEzSmhiSUJ0OXE5WSIsImlzX2xvY2FsIjpmYWxzZSwiaXNfcGxheWFibGUiOnRydWUsIm5hbWUiOiJIaWdoIE5vdGUiLCJ0cmFja19udW1iZXIiOjEsInR5cGUiOiJ0cmFjayIsInVyaSI6InNwb3RpZnk6dHJhY2s6MjhmNWNIT2FodEEzSmhiSUJ0OXE5WSJ9LHsiYWxidW0iOnsiYWxidW1fdHlwZSI6ImFsYnVtIiwiYXJ0aXN0cyI6W3siZXh0ZXJuYWxfdXJscyI6eyJzcG90aWZ5IjoiaHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FydGlzdC81WE1HbnBramdxQzF0OU5XT203bkc0In0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hcnRpc3RzLzVYTUducGtqZ3FDMXQ5TldPbTduRzQiLCJpZCI6IjVYTUducGtqZ3FDMXQ5TldPbTduRzQiLCJuYW1lIjoiTGlxdWljaXR5IiwidHlwZSI6ImFydGlzdCIsInVyaSI6InNwb3RpZnk6YXJ0aXN0OjVYTUducGtqZ3FDMXQ5TldPbTduRzQifV0sImV4dGVybmFsX3VybHMiOnsic3BvdGlmeSI6Imh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9hbGJ1bS8yejBFeTJZYXhQZFFpUThKRUxlU3BKIn0sImhyZWYiOiJodHRwczovL2FwaS5zcG90aWZ5LmNvbS92MS9hbGJ1bXMvMnowRXkyWWF4UGRRaVE4SkVMZVNwSiIsImlkIjoiMnowRXkyWWF4UGRRaVE4SkVMZVNwSiIsImltYWdlcyI6W3siaGVpZ2h0Ijo2NDAsIndpZHRoIjo2NDAsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMGIyNzNiNjg3YzgwMmIyMjMxYmUzZDVlOGJhOTkifSx7ImhlaWdodCI6MzAwLCJ3aWR0aCI6MzAwLCJ1cmwiOiJodHRwczovL2kuc2Nkbi5jby9pbWFnZS9hYjY3NjE2ZDAwMDAxZTAyYjY4N2M4MDJiMjIzMWJlM2Q1ZThiYTk5In0seyJoZWlnaHQiOjY0LCJ3aWR0aCI6NjQsInVybCI6Imh0dHBzOi8vaS5zY2RuLmNvL2ltYWdlL2FiNjc2MTZkMDAwMDQ4NTFiNjg3YzgwMmIyMjMxYmUzZDVlOGJhOTkifV0sImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiTGlxdWljaXR5IEZlc3RpdmFsIDIwMjUiLCJyZWxlYXNlX2RhdGUiOiIyMDI1LTA3LTE4IiwicmVsZWFzZV9kYXRlX3ByZWNpc2lvbiI6ImRheSIsInRvdGFsX3RyYWNrcyI6NDAsInR5cGUiOiJhbGJ1bSIsInVyaSI6InNwb3RpZnk6YWxidW06MnowRXkyWWF4UGRRaVE4SkVMZVNwSiJ9LCJhcnRpc3RzIjpbeyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzZRWWRYVG9NbzRYSG5HMUFuRVZaWUoifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxLw==", + "YXJ0aXN0cy82UVlkWFRvTW80WEhuRzFBbkVWWllKIiwiaWQiOiI2UVlkWFRvTW80WEhuRzFBbkVWWllKIiwibmFtZSI6IksgTW90aW9ueiIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo2UVlkWFRvTW80WEhuRzFBbkVWWllKIn0seyJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vYXJ0aXN0LzUxZmVyeG9jRUt0MHZqeHpVc3F5RlgifSwiaHJlZiI6Imh0dHBzOi8vYXBpLnNwb3RpZnkuY29tL3YxL2FydGlzdHMvNTFmZXJ4b2NFS3Qwdmp4elVzcXlGWCIsImlkIjoiNTFmZXJ4b2NFS3Qwdmp4elVzcXlGWCIsIm5hbWUiOiJFbWlseSBNYWtpcyIsInR5cGUiOiJhcnRpc3QiLCJ1cmkiOiJzcG90aWZ5OmFydGlzdDo1MWZlcnhvY0VLdDB2anh6VXNxeUZYIn1dLCJkaXNjX251bWJlciI6MSwiZHVyYXRpb25fbXMiOjIyNTg2MiwiZXhwbGljaXQiOmZhbHNlLCJleHRlcm5hbF9pZHMiOnsiaXNyYyI6IkdCMkxEMjExMDI3OSJ9LCJleHRlcm5hbF91cmxzIjp7InNwb3RpZnkiOiJodHRwczovL29wZW4uc3BvdGlmeS5jb20vdHJhY2svNDRla2VSNzhkckRCWjFqT05EZ254YiJ9LCJocmVmIjoiaHR0cHM6Ly9hcGkuc3BvdGlmeS5jb20vdjEvdHJhY2tzLzQ0ZWtlUjc4ZHJEQloxak9ORGdueGIiLCJpZCI6IjQ0ZWtlUjc4ZHJEQloxak9ORGdueGIiLCJpc19sb2NhbCI6ZmFsc2UsImlzX3BsYXlhYmxlIjp0cnVlLCJuYW1lIjoiSGlnaCBOb3RlIiwidHJhY2tfbnVtYmVyIjo0LCJ0eXBlIjoidHJhY2siLCJ1cmkiOiJzcG90aWZ5OnRyYWNrOjQ0ZWtlUjc4ZHJEQloxak9ORGdueGIifV19fQ==" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=track%3A%22High+Note%22+artist%3A%22K+Motionz%22&type=track&limit=10" + }, + { + "method": "GET", + "request_body_base64": "", + "response_body_base64": "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Bring%20You%20Down%20Wilkinson&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Bring%20You%20Down%20Wilkinson&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6m8itYST9ADjBIYevXSb1r"},"href":"https://api.spotify.com/v1/artists/6m8itYST9ADjBIYevXSb1r","id":"6m8itYST9ADjBIYevXSb1r","name":"Wilkinson","type":"artist","uri":"spotify:artist:6m8itYST9ADjBIYevXSb1r"}],"external_urls":{"spotify":"https://open.spotify.com/album/3sRcAEZJlzV4w67gnpR2jL"},"href":"https://api.spotify.com/v1/albums/3sRcAEZJlzV4w67gnpR2jL","id":"3sRcAEZJlzV4w67gnpR2jL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737c71ba5c19cc1ae4b5c38bb8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027c71ba5c19cc1ae4b5c38bb8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517c71ba5c19cc1ae4b5c38bb8"}],"is_playable":true,"name":"Infinity","release_date":"2026-03-27","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:3sRcAEZJlzV4w67gnpR2jL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6m8itYST9ADjBIYevXSb1r"},"href":"https://api.spotify.com/v1/artists/6m8itYST9ADjBIYevXSb1r","id":"6m8itYST9ADjBIYevXSb1r","name":"Wilkinson","type":"artist","uri":"spotify:artist:6m8itYST9ADjBIYevXSb1r"}],"disc_number":1,"duration_ms":183620,"explicit":false,"external_ids":{"isrc":"US38Y2552713"},"external_urls":{"spotify":"https://open.spotify.com/track/3t91YwjY1x6q2PuzAaPpBR"},"href":"https://api.spotify.com/v1/tracks/3t91YwjY1x6q2PuzAaPpBR","id":"3t91YwjY1x6q2PuzAaPpBR","is_local":false,"is_playable":true,"name":"Come Down","track_number":8,"type":"track","uri":"spotify:track:3t91YwjY1x6q2PuzAaPpBR"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7bXgB6jMjp9ATFy66eO08Z"},"href":"https://api.spotify.com/v1/artists/7bXgB6jMjp9ATFy66eO08Z","id":"7bXgB6jMjp9ATFy66eO08Z","name":"Chris Brown","type":"artist","uri":"spotify:artist:7bXgB6jMjp9ATFy66eO08Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4Ws2otunReOa6BbwxxpCt6"},"href":"https://api.spotify.com/v1/artists/4Ws2otunReOa6BbwxxpCt6","id":"4Ws2otunReOa6BbwxxpCt6","name":"Benny Benassi","type":"artist","uri":"spotify:artist:4Ws2otunReOa6BbwxxpCt6"}],"external_urls":{"spotify":"https://open.spotify.com/album/1T7NGLd1bEw4al4bbIVSDo"},"href":"https://api.spotify.com/v1/albums/1T7NGLd1bEw4al4bbIVSDo","id":"1T7NGLd1bEw4al4bbIVSDo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a55c021f62ed35cc2711e435"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a55c021f62ed35cc2711e435"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a55c021f62ed35cc2711e435"}],"is_playable":true,"name":"Beautiful People","release_date":"2011","release_date_precision":"year","total_tracks":2,"type":"album","uri":"spotify:album:1T7NGLd1bEw4al4bbIVSDo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7bXgB6jMjp9ATFy66eO08Z"},"href":"https://api.spotify.com/v1/artists/7bXgB6jMjp9ATFy66eO08Z","id":"7bXgB6jMjp9ATFy66eO08Z","name":"Chris Brown","type":"artist","uri":"spotify:artist:7bXgB6jMjp9ATFy66eO08Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4Ws2otunReOa6BbwxxpCt6"},"href":"https://api.spotify.com/v1/artists/4Ws2otunReOa6BbwxxpCt6","id":"4Ws2otunReOa6BbwxxpCt6","name":"Benny Benassi","type":"artist","uri":"spotify:artist:4Ws2otunReOa6BbwxxpCt6"}],"disc_number":1,"duration_ms":225933,"explicit":false,"external_ids":{"isrc":"USUS11100035"},"external_urls":{"spotify":"https://open.spotify.com/track/16whkF55KgWqpNChzOQWB3"},"href":"https://api.spotify.com/v1/tracks/16whkF55KgWqpNChzOQWB3","id":"16whkF55KgWqpNChzOQWB3","is_local":false,"is_playable":true,"name":"Beautiful People - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:16whkF55KgWqpNChzOQWB3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0etNimDSQLWFbktPBHQ5vb"},"href":"https://api.spotify.com/v1/artists/0etNimDSQLWFbktPBHQ5vb","id":"0etNimDSQLWFbktPBHQ5vb","name":"Kevin Sherwood","type":"artist","uri":"spotify:artist:0etNimDSQLWFbktPBHQ5vb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2a1s63oSnZEVny55iHFs5P"},"href":"https://api.spotify.com/v1/artists/2a1s63oSnZEVny55iHFs5P","id":"2a1s63oSnZEVny55iHFs5P","name":"James McCawley","type":"artist","uri":"spotify:artist:2a1s63oSnZEVny55iHFs5P"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5Hpt9NA27fOu1HhvQ6YITJ"},"href":"https://api.spotify.com/v1/artists/5Hpt9NA27fOu1HhvQ6YITJ","id":"5Hpt9NA27fOu1HhvQ6YITJ","name":"Brian Tuey","type":"artist","uri":"spotify:artist:5Hpt9NA27fOu1HhvQ6YITJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/5iIo9PaIwnmuhKWVaoU2WY"},"href":"https://api.spotify.com/v1/albums/5iIo9PaIwnmuhKWVaoU2WY","id":"5iIo9PaIwnmuhKWVaoU2WY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734bc9031ffb86dfa3cea86c52"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024bc9031ffb86dfa3cea86c52"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514bc9031ffb86dfa3cea86c52"}],"is_playable":true,"name":"Call of Duty: Black Ops \u2013 Zombies (Original Game Soundtrack)","release_date":"2011-01-25","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5iIo9PaIwnmuhKWVaoU2WY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6BlZkvGwQyo011poQEhQ1J"},"href":"https://api.spotify.com/v1/artists/6BlZkvGwQyo011poQEhQ1J","id":"6BlZkvGwQyo011poQEhQ1J","name":"Elena Siegman","type":"artist","uri":"spotify:artist:6BlZkvGwQyo011poQEhQ1J"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0etNimDSQLWFbktPBHQ5vb"},"href":"https://api.spotify.com/v1/artists/0etNimDSQLWFbktPBHQ5vb","id":"0etNimDSQLWFbktPBHQ5vb","name":"Kevin Sherwood","type":"artist","uri":"spotify:artist:0etNimDSQLWFbktPBHQ5vb"}],"disc_number":1,"duration_ms":228160,"explicit":false,"external_ids":{"isrc":"USZXT1061478"},"external_urls":{"spotify":"https://open.spotify.com/track/725NSbIej5lP3GfhLC7So3"},"href":"https://api.spotify.com/v1/tracks/725NSbIej5lP3GfhLC7So3","id":"725NSbIej5lP3GfhLC7So3","is_local":false,"is_playable":true,"name":"115","track_number":14,"type":"track","uri":"spotify:track:725NSbIej5lP3GfhLC7So3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3qm84nBOXUEQ2vnTfUTTFC"},"href":"https://api.spotify.com/v1/artists/3qm84nBOXUEQ2vnTfUTTFC","id":"3qm84nBOXUEQ2vnTfUTTFC","name":"Guns N' Roses","type":"artist","uri":"spotify:artist:3qm84nBOXUEQ2vnTfUTTFC"}],"external_urls":{"spotify":"https://open.spotify.com/album/28yHV3Gdg30AiB8h8em1eW"},"href":"https://api.spotify.com/v1/albums/28yHV3Gdg30AiB8h8em1eW","id":"28yHV3Gdg30AiB8h8em1eW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27321ebf49b3292c3f0f575f0f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0221ebf49b3292c3f0f575f0f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485121ebf49b3292c3f0f575f0f5"}],"is_playable":true,"name":"Appetite For Destruction","release_date":"1987-07-21","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:28yHV3Gdg30AiB8h8em1eW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3qm84nBOXUEQ2vnTfUTTFC"},"href":"https://api.spotify.com/v1/artists/3qm84nBOXUEQ2vnTfUTTFC","id":"3qm84nBOXUEQ2vnTfUTTFC","name":"Guns N' Roses","type":"artist","uri":"spotify:artist:3qm84nBOXUEQ2vnTfUTTFC"}],"disc_number":1,"duration_ms":273480,"explicit":true,"external_ids":{"isrc":"USGF18714801"},"external_urls":{"spotify":"https://open.spotify.com/track/0G21yYKMZoHa30cYVi1iA8"},"href":"https://api.spotify.com/v1/tracks/0G21yYKMZoHa30cYVi1iA8","id":"0G21yYKMZoHa30cYVi1iA8","is_local":false,"is_playable":true,"name":"Welcome To The Jungle","track_number":1,"type":"track","uri":"spotify:track:0G21yYKMZoHa30cYVi1iA8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5a2EaR3hamoenG9rDuVn8j"},"href":"https://api.spotify.com/v1/artists/5a2EaR3hamoenG9rDuVn8j","id":"5a2EaR3hamoenG9rDuVn8j","name":"Prince","type":"artist","uri":"spotify:artist:5a2EaR3hamoenG9rDuVn8j"}],"external_urls":{"spotify":"https://open.spotify.com/album/2umoqwMrmjBBPeaqgYu6J9"},"href":"https://api.spotify.com/v1/albums/2umoqwMrmjBBPeaqgYu6J9","id":"2umoqwMrmjBBPeaqgYu6J9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738a2ce3f148f57584269c3782"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028a2ce3f148f57584269c3782"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518a2ce3f148f57584269c3782"}],"is_playable":true,"name":"Purple Rain","release_date":"1984-06-25","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:2umoqwMrmjBBPeaqgYu6J9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5a2EaR3hamoenG9rDuVn8j"},"href":"https://api.spotify.com/v1/artists/5a2EaR3hamoenG9rDuVn8j","id":"5a2EaR3hamoenG9rDuVn8j","name":"Prince","type":"artist","uri":"spotify:artist:5a2EaR3hamoenG9rDuVn8j"}],"disc_number":1,"duration_ms":279240,"explicit":false,"external_ids":{"isrc":"USWB19903188"},"external_urls":{"spotify":"https://open.spotify.com/track/6FMIVQPZg9cmMY8hPxAacD"},"href":"https://api.spotify.com/v1/tracks/6FMIVQPZg9cmMY8hPxAacD","id":"6FMIVQPZg9cmMY8hPxAacD","is_local":false,"is_playable":true,"name":"Let's Go Crazy","track_number":1,"type":"track","uri":"spotify:track:6FMIVQPZg9cmMY8hPxAacD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2yEwvVSSSUkcLeSTNyHKh8"},"href":"https://api.spotify.com/v1/artists/2yEwvVSSSUkcLeSTNyHKh8","id":"2yEwvVSSSUkcLeSTNyHKh8","name":"TOOL","type":"artist","uri":"spotify:artist:2yEwvVSSSUkcLeSTNyHKh8"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Esn6LoXuWtLZNYq8FCzr0"},"href":"https://api.spotify.com/v1/albums/3Esn6LoXuWtLZNYq8FCzr0","id":"3Esn6LoXuWtLZNYq8FCzr0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fd1602df46ac56e2f5260ec0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fd1602df46ac56e2f5260ec0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fd1602df46ac56e2f5260ec0"}],"is_playable":true,"name":"Undertow","release_date":"1993-04-06","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:3Esn6LoXuWtLZNYq8FCzr0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2yEwvVSSSUkcLeSTNyHKh8"},"href":"https://api.spotify.com/v1/artists/2yEwvVSSSUkcLeSTNyHKh8","id":"2yEwvVSSSUkcLeSTNyHKh8","name":"TOOL","type":"artist","uri":"spotify:artist:2yEwvVSSSUkcLeSTNyHKh8"}],"disc_number":1,"duration_ms":306853,"explicit":true,"external_ids":{"isrc":"USVR10000011"},"external_urls":{"spotify":"https://open.spotify.com/track/6DyywdbmTzlmXBzG9ym7Rt"},"href":"https://api.spotify.com/v1/tracks/6DyywdbmTzlmXBzG9ym7Rt","id":"6DyywdbmTzlmXBzG9ym7Rt","is_local":false,"is_playable":true,"name":"Sober","track_number":3,"type":"track","uri":"spotify:track:6DyywdbmTzlmXBzG9ym7Rt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Mo9PoU6svvhgEum7wh2Nd"},"href":"https://api.spotify.com/v1/artists/6Mo9PoU6svvhgEum7wh2Nd","id":"6Mo9PoU6svvhgEum7wh2Nd","name":"Public Enemy","type":"artist","uri":"spotify:artist:6Mo9PoU6svvhgEum7wh2Nd"}],"external_urls":{"spotify":"https://open.spotify.com/album/6izTLoTDL2k78sAvpLfHOP"},"href":"https://api.spotify.com/v1/albums/6izTLoTDL2k78sAvpLfHOP","id":"6izTLoTDL2k78sAvpLfHOP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732acb820332d5f37cd536cc98"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022acb820332d5f37cd536cc98"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512acb820332d5f37cd536cc98"}],"is_playable":true,"name":"How You Sell Soul to a Soulless People Who Sold Their Soul?","release_date":"2007-08-07","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6izTLoTDL2k78sAvpLfHOP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Mo9PoU6svvhgEum7wh2Nd"},"href":"https://api.spotify.com/v1/artists/6Mo9PoU6svvhgEum7wh2Nd","id":"6Mo9PoU6svvhgEum7wh2Nd","name":"Public Enemy","type":"artist","uri":"spotify:artist:6Mo9PoU6svvhgEum7wh2Nd"}],"disc_number":1,"duration_ms":249521,"explicit":false,"external_ids":{"isrc":"USTC10778807"},"external_urls":{"spotify":"https://open.spotify.com/track/5YpZh8wfS4moRBk0ijNcXr"},"href":"https://api.spotify.com/v1/tracks/5YpZh8wfS4moRBk0ijNcXr","id":"5YpZh8wfS4moRBk0ijNcXr","is_local":false,"is_playable":true,"name":"Harder Than You Think","track_number":3,"type":"track","uri":"spotify:track:5YpZh8wfS4moRBk0ijNcXr"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3bO19AOone0ubCsfDXDtYt"},"href":"https://api.spotify.com/v1/artists/3bO19AOone0ubCsfDXDtYt","id":"3bO19AOone0ubCsfDXDtYt","name":"Myles Smith","type":"artist","uri":"spotify:artist:3bO19AOone0ubCsfDXDtYt"}],"external_urls":{"spotify":"https://open.spotify.com/album/0xBVvz5KOwJtgrc9sFpnwQ"},"href":"https://api.spotify.com/v1/albums/0xBVvz5KOwJtgrc9sFpnwQ","id":"0xBVvz5KOwJtgrc9sFpnwQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aa42c14488d5404e18993fdb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aa42c14488d5404e18993fdb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aa42c14488d5404e18993fdb"}],"is_playable":true,"name":"Wait For You","release_date":"2024-08-23","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:0xBVvz5KOwJtgrc9sFpnwQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3bO19AOone0ubCsfDXDtYt"},"href":"https://api.spotify.com/v1/artists/3bO19AOone0ubCsfDXDtYt","id":"3bO19AOone0ubCsfDXDtYt","name":"Myles Smith","type":"artist","uri":"spotify:artist:3bO19AOone0ubCsfDXDtYt"}],"disc_number":1,"duration_ms":201533,"explicit":false,"external_ids":{"isrc":"GBARL2401092"},"external_urls":{"spotify":"https://open.spotify.com/track/0JjecOzaIzBTfIY35QGmgw"},"href":"https://api.spotify.com/v1/tracks/0JjecOzaIzBTfIY35QGmgw","id":"0JjecOzaIzBTfIY35QGmgw","is_local":false,"is_playable":true,"name":"Wait For You","track_number":1,"type":"track","uri":"spotify:track:0JjecOzaIzBTfIY35QGmgw"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iEtIxbK0KxaSlF7G42ZOp"},"href":"https://api.spotify.com/v1/artists/0iEtIxbK0KxaSlF7G42ZOp","id":"0iEtIxbK0KxaSlF7G42ZOp","name":"Metro Boomin","type":"artist","uri":"spotify:artist:0iEtIxbK0KxaSlF7G42ZOp"}],"external_urls":{"spotify":"https://open.spotify.com/album/7txGsnDSqVMoRl6RQ9XyZP"},"href":"https://api.spotify.com/v1/albums/7txGsnDSqVMoRl6RQ9XyZP","id":"7txGsnDSqVMoRl6RQ9XyZP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c4fee55d7b51479627c31f89"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c4fee55d7b51479627c31f89"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c4fee55d7b51479627c31f89"}],"is_playable":true,"name":"HEROES & VILLAINS","release_date":"2022-12-02","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:7txGsnDSqVMoRl6RQ9XyZP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iEtIxbK0KxaSlF7G42ZOp"},"href":"https://api.spotify.com/v1/artists/0iEtIxbK0KxaSlF7G42ZOp","id":"0iEtIxbK0KxaSlF7G42ZOp","name":"Metro Boomin","type":"artist","uri":"spotify:artist:0iEtIxbK0KxaSlF7G42ZOp"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1RyvyyTE3xzB2ZywiAwp0i"},"href":"https://api.spotify.com/v1/artists/1RyvyyTE3xzB2ZywiAwp0i","id":"1RyvyyTE3xzB2ZywiAwp0i","name":"Future","type":"artist","uri":"spotify:artist:1RyvyyTE3xzB2ZywiAwp0i"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7bXgB6jMjp9ATFy66eO08Z"},"href":"https://api.spotify.com/v1/artists/7bXgB6jMjp9ATFy66eO08Z","id":"7bXgB6jMjp9ATFy66eO08Z","name":"Chris Brown","type":"artist","uri":"spotify:artist:7bXgB6jMjp9ATFy66eO08Z"}],"disc_number":1,"duration_ms":182666,"explicit":true,"external_ids":{"isrc":"USUG12208783"},"external_urls":{"spotify":"https://open.spotify.com/track/0vjeOZ3Ft5jvAi9SBFJm1j"},"href":"https://api.spotify.com/v1/tracks/0vjeOZ3Ft5jvAi9SBFJm1j","id":"0vjeOZ3Ft5jvAi9SBFJm1j","is_local":false,"is_playable":true,"name":"Superhero (Heroes & Villains) [with Future & Chris Brown]","track_number":2,"type":"track","uri":"spotify:track:0vjeOZ3Ft5jvAi9SBFJm1j"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1C1x4MVkql8AiABuTw6DgE"},"href":"https://api.spotify.com/v1/artists/1C1x4MVkql8AiABuTw6DgE","id":"1C1x4MVkql8AiABuTw6DgE","name":"Richard Wagner","type":"artist","uri":"spotify:artist:1C1x4MVkql8AiABuTw6DgE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1VwCj4mbRJcJNJeTkErmFK"},"href":"https://api.spotify.com/v1/albums/1VwCj4mbRJcJNJeTkErmFK","id":"1VwCj4mbRJcJNJeTkErmFK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730181feb44ef73502227144e1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020181feb44ef73502227144e1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510181feb44ef73502227144e1"}],"is_playable":true,"name":"Wagner Complete Operas (Volume 1)","release_date":"2012-01-01","release_date_precision":"day","total_tracks":212,"type":"album","uri":"spotify:album:1VwCj4mbRJcJNJeTkErmFK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1C1x4MVkql8AiABuTw6DgE"},"href":"https://api.spotify.com/v1/artists/1C1x4MVkql8AiABuTw6DgE","id":"1C1x4MVkql8AiABuTw6DgE","name":"Richard Wagner","type":"artist","uri":"spotify:artist:1C1x4MVkql8AiABuTw6DgE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5M4s5CWEtDgi5S1mIBDerz"},"href":"https://api.spotify.com/v1/artists/5M4s5CWEtDgi5S1mIBDerz","id":"5M4s5CWEtDgi5S1mIBDerz","name":"Elizabeth Gale","type":"artist","uri":"spotify:artist:5M4s5CWEtDgi5S1mIBDerz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5YiPZ5YGvXI7YgWZWpuSXW"},"href":"https://api.spotify.com/v1/artists/5YiPZ5YGvXI7YgWZWpuSXW","id":"5YiPZ5YGvXI7YgWZWpuSXW","name":"Alexander Young","type":"artist","uri":"spotify:artist:5YiPZ5YGvXI7YgWZWpuSXW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6TgyVIUZBCwqYKl5FL34Sp"},"href":"https://api.spotify.com/v1/artists/6TgyVIUZBCwqYKl5FL34Sp","id":"6TgyVIUZBCwqYKl5FL34Sp","name":"Neil Jenkins","type":"artist","uri":"spotify:artist:6TgyVIUZBCwqYKl5FL34Sp"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4SLa6t3vT5I81Ib1rcL90B"},"href":"https://api.spotify.com/v1/artists/4SLa6t3vT5I81Ib1rcL90B","id":"4SLa6t3vT5I81Ib1rcL90B","name":"David Lennox","type":"artist","uri":"spotify:artist:4SLa6t3vT5I81Ib1rcL90B"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5helMrpPKcTSYjioHdyEzv"},"href":"https://api.spotify.com/v1/artists/5helMrpPKcTSYjioHdyEzv","id":"5helMrpPKcTSYjioHdyEzv","name":"Ian Caley","type":"artist","uri":"spotify:artist:5helMrpPKcTSYjioHdyEzv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5FEi4BDhQSzyJdfaPIVCIy"},"href":"https://api.spotify.com/v1/artists/5FEi4BDhQSzyJdfaPIVCIy","id":"5FEi4BDhQSzyJdfaPIVCIy","name":"William Elvin","type":"artist","uri":"spotify:artist:5FEi4BDhQSzyJdfaPIVCIy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1B1mAngQaEaWbj5WOaGeHu"},"href":"https://api.spotify.com/v1/artists/1B1mAngQaEaWbj5WOaGeHu","id":"1B1mAngQaEaWbj5WOaGeHu","name":"Leslie Fyson","type":"artist","uri":"spotify:artist:1B1mAngQaEaWbj5WOaGeHu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1z9u3vLr7gw6IBS8CP8c2X"},"href":"https://api.spotify.com/v1/artists/1z9u3vLr7gw6IBS8CP8c2X","id":"1z9u3vLr7gw6IBS8CP8c2X","name":"BBC Philharmonic","type":"artist","uri":"spotify:artist:1z9u3vLr7gw6IBS8CP8c2X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6cuA6068ujeUjQtms8gQfq"},"href":"https://api.spotify.com/v1/artists/6cuA6068ujeUjQtms8gQfq","id":"6cuA6068ujeUjQtms8gQfq","name":"Sir Edward Downes","type":"artist","uri":"spotify:artist:6cuA6068ujeUjQtms8gQfq"}],"disc_number":4,"duration_ms":179613,"explicit":false,"external_ids":{"isrc":"DEF057632905"},"external_urls":{"spotify":"https://open.spotify.com/track/4ccLQY8innhprrSLzHmnNx"},"href":"https://api.spotify.com/v1/tracks/4ccLQY8innhprrSLzHmnNx","id":"4ccLQY8innhprrSLzHmnNx","is_local":false,"is_playable":true,"name":"Das Liebesverbot / Act 1: Wen bringt man dort? Seht hin!","track_number":5,"type":"track","uri":"spotify:track:4ccLQY8innhprrSLzHmnNx"}]}}", + "response_chunks_base64": [ + "{"tracks":{"href":"https://api.spotify.com/v1/search?offset=0&limit=10&query=Bring%20You%20Down%20Wilkinson&type=track","limit":10,"next":"https://api.spotify.com/v1/search?offset=10&limit=10&query=Bring%20You%20Down%20Wilkinson&type=track","offset":0,"previous":null,"total":12,"items":[{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6m8itYST9ADjBIYevXSb1r"},"href":"https://api.spotify.com/v1/artists/6m8itYST9ADjBIYevXSb1r","id":"6m8itYST9ADjBIYevXSb1r","name":"Wilkinson","type":"artist","uri":"spotify:artist:6m8itYST9ADjBIYevXSb1r"}],"external_urls":{"spotify":"https://open.spotify.com/album/3sRcAEZJlzV4w67gnpR2jL"},"href":"https://api.spotify.com/v1/albums/3sRcAEZJlzV4w67gnpR2jL","id":"3sRcAEZJlzV4w67gnpR2jL","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2737c71ba5c19cc1ae4b5c38bb8"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e027c71ba5c19cc1ae4b5c38bb8"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048517c71ba5c19cc1ae4b5c38bb8"}],"is_playable":true,"name":"Infinity","release_date":"2026-03-27","release_date_precision":"day","total_tracks":14,"type":"album","uri":"spotify:album:3sRcAEZJlzV4w67gnpR2jL"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6m8itYST9ADjBIYevXSb1r"},"href":"https://api.spotify.com/v1/artists/6m8itYST9ADjBIYevXSb1r","id":"6m8itYST9ADjBIYevXSb1r","name":"Wilkinson","type":"artist","uri":"spotify:artist:6m8itYST9ADjBIYevXSb1r"}],"disc_number":1,"duration_ms":183620,"explicit":false,"external_ids":{"isrc":"US38Y2552713"},"external_urls":{"spotify":"https://open.spotify.com/track/3t91YwjY1x6q2PuzAaPpBR"},"href":"https://api.spotify.com/v1/tracks/3t91YwjY1x6q2PuzAaPpBR","id":"3t91YwjY1x6q2PuzAaPpBR","is_local":false,"is_playable":true,"name":"Come Down","track_number":8,"type":"track","uri":"spotify:track:3t91YwjY1x6q2PuzAaPpBR"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7bXgB6jMjp9ATFy66eO08Z"},"href":"https://api.spotify.com/v1/artists/7bXgB6jMjp9ATFy66eO08Z","id":"7bXgB6jMjp9ATFy66eO08Z","name":"Chris Brown","type":"artist","uri":"spotify:artist:7bXgB6jMjp9ATFy66eO08Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4Ws2otunReOa6BbwxxpCt6"},"href":"https://api.spotify.com/v1/artists/4Ws2otunReOa6BbwxxpCt6","id":"4Ws2otunReOa6BbwxxpCt6","name":"Benny Benassi","type":"artist","uri":"spotify:artist:4Ws2otunReOa6BbwxxpCt6"}],"external_urls":{"spotify":"https://open.spotify.com/album/1T7NGLd1bEw4al4bbIVSDo"},"href":"https://api.spotify.com/v1/albums/1T7NGLd1bEw4al4bbIVSDo","id":"1T7NGLd1bEw4al4bbIVSDo","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273a55c021f62ed35cc2711e435"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02a55c021f62ed35cc2711e435"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851a55c021f62ed35cc2711e435"}],"is_playable":true,"name":"Beautiful People","release_date":"2011","release_date_precision":"year","total_tracks":2,"type":"album","uri":"spotify:album:1T7NGLd1bEw4al4bbIVSDo"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/7bXgB6jMjp9ATFy66eO08Z"},"href":"https://api.spotify.com/v1/artists/7bXgB6jMjp9ATFy66eO08Z","id":"7bXgB6jMjp9ATFy66eO08Z","name":"Chris Brown","type":"artist","uri":"spotify:artist:7bXgB6jMjp9ATFy66eO08Z"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4Ws2otunReOa6BbwxxpCt6"},"href":"https://api.spotify.com/v1/artists/4Ws2otunReOa6BbwxxpCt6","id":"4Ws2otunReOa6BbwxxpCt6","name":"Benny Benassi","type":"artist","uri":"spotify:artist:4Ws2otunReOa6BbwxxpCt6"}],"disc_number":1,"duration_ms":225933,"explicit":false,"external_ids":{"isrc":"USUS11100035"},"external_urls":{"spotify":"https://open.spotify.com/track/16whkF55KgWqpNChzOQWB3"},"href":"https://api.spotify.com/v1/tracks/16whkF55KgWqpNChzOQWB3","id":"16whkF55KgWqpNChzOQWB3","is_local":false,"is_playable":true,"name":"Beautiful People - Radio Edit","track_number":1,"type":"track","uri":"spotify:track:16whkF55KgWqpNChzOQWB3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0etNimDSQLWFbktPBHQ5vb"},"href":"https://api.spotify.com/v1/artists/0etNimDSQLWFbktPBHQ5vb","id":"0etNimDSQLWFbktPBHQ5vb","name":"Kevin Sherwood","type":"artist","uri":"spotify:artist:0etNimDSQLWFbktPBHQ5vb"},{"external_urls":{"spotify":"https://open.spotify.com/artist/2a1s63oSnZEVny55iHFs5P"},"href":"https://api.spotify.com/v1/artists/2a1s63oSnZEVny55iHFs5P","id":"2a1s63oSnZEVny55iHFs5P","name":"James McCawley","type":"artist","uri":"spotify:artist:2a1s63oSnZEVny55iHFs5P"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5Hpt9NA27fOu1HhvQ6YITJ"},"href":"https://api.spotify.com/v1/artists/5Hpt9NA27fOu1HhvQ6YITJ","id":"5Hpt9NA27fOu1HhvQ6YITJ","name":"Brian Tuey","type":"artist","uri":"spotify:artist:5Hpt9NA27fOu1HhvQ6YITJ"}],"external_urls":{"spotify":"https://open.spotify.com/album/5iIo9PaIwnmuhKWVaoU2WY"},"href":"https://api.spotify.com/v1/albums/5iIo9PaIwnmuhKWVaoU2WY","id":"5iIo9PaIwnmuhKWVaoU2WY","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2734bc9031ffb86dfa3cea86c52"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e024bc9031ffb86dfa3cea86c52"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048514bc9031ffb86dfa3cea86c52"}],"is_playable":true,"name":"Call of Duty: Black Ops \u2013 Zombies (Original Game Soundtrack)","release_date":"2011-01-25","release_date_precision":"day","total_tracks":17,"type":"album","uri":"spotify:album:5iIo9PaIwnmuhKWVaoU2WY"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6BlZkvGwQyo011poQEhQ1J"},"href":"https://api.spotify.com/v1/artists/6BlZkvGwQyo011poQEhQ1J","id":"6BlZkvGwQyo011poQEhQ1J","name":"Elena Siegman","type":"artist","uri":"spotify:artist:6BlZkvGwQyo011poQEhQ1J"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0etNimDSQLWFbktPBHQ5vb"},"href":"https://api.spotify.com/v1/artists/0etNimDSQLWFbktPBHQ5vb","id":"0etNimDSQLWFbktPBHQ5vb","name":"Kevin Sherwood","type":"artist","uri":"spotify:artist:0etNimDSQLWFbktPBHQ5vb"}],"disc_number":1,"duration_ms":228160,"explicit":false,"external_ids":{"isrc":"USZXT1061478"},"external_urls":{"spotify":"https://open.spotify.com/track/725NSbIej5lP3GfhLC7So3"},"href":"https://api.spotify.com/v1/tracks/725NSbIej5lP3GfhLC7So3","id":"725NSbIej5lP3GfhLC7So3","is_local":false,"is_playable":true,"name":"115","track_number":14,"type":"track","uri":"spotify:track:725NSbIej5lP3GfhLC7So3"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3qm84nBOXUEQ2vnTfUTTFC"},"href":"https://api.spotify.com/v1/artists/3qm84nBOXUEQ2vnTfUTTFC","id":"3qm84nBOXUEQ2vnTfUTTFC","name":"Guns N' Roses","type":"artist","uri":"spotify:artist:3qm84nBOXUEQ2vnTfUTTFC"}],"external_urls":{"spotify":"https://open.spotify.com/album/28yHV3Gdg30AiB8h8em1eW"},"href":"https://api.spotify.com/v1/albums/28yHV3Gdg30AiB8h8em1eW","id":"28yHV3Gdg30AiB8h8em1eW","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b27321ebf49b3292c3f0f575f0f5"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e0221ebf49b3292c3f0f575f0f5"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d0000485121ebf49b3292c3f0f575f0f5"}],"is_playable":true,"name":"Appetite For Destruction","release_date":"1987-07-21","release_date_precision":"day","total_tracks":12,"type":"album","uri":"spotify:album:28yHV3Gdg30AiB8h8em1eW"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3qm84nBOXUEQ2vnTfUTTFC"},"href":"https://api.spotify.com/v1/artists/3qm84nBOXUEQ2vnTfUTTFC","id":"3qm84nBOXUEQ2vnTfUTTFC","name":"Guns N' Roses","type":"artist","uri":"spotify:artist:3qm84nBOXUEQ2vnTfUTTFC"}],"disc_number":1,"duration_ms":273480,"explicit":true,"external_ids":{"isrc":"USGF18714801"},"external_urls":{"spotify":"https://open.spotify.com/track/0G21yYKMZoHa30cYVi1iA8"},"href":"https://api.spotify.com/v1/tracks/0G21yYKMZoHa30cYVi1iA8","id":"0G21yYKMZoHa30cYVi1iA8","is_local":false,"is_playable":true,"name":"Welcome To The Jungle","track_number":1,"type":"track","uri":"spotify:track:0G21yYKMZoHa30cYVi1iA8"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5a2EaR3hamoenG9rDuVn8j"},"href":"https://api.spotify.com/v1/artists/5a2EaR3hamoenG9rDuVn8j","id":"5a2EaR3hamoenG9rDuVn8j","name":"Prince","type":"artist","uri":"spotify:artist:5a2EaR3hamoenG9rDuVn8j"}],"external_urls":{"spotify":"https://open.spotify.com/album/2umoqwMrmjBBPeaqgYu6J9"},"href":"https://api.spotify.com/v1/albums/2umoqwMrmjBBPeaqgYu6J9","id":"2umoqwMrmjBBPeaqgYu6J9","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2738a2ce3f148f57584269c3782"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e028a2ce3f148f57584269c3782"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048518a2ce3f148f57584269c3782"}],"is_playable":true,"name":"Purple Rain","release_date":"1984-06-25","release_date_precision":"day","total_tracks":9,"type":"album","uri":"spotify:album:2umoqwMrmjBBPeaqgYu6J9"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/5a2EaR3hamoenG9rDuVn8j"},"href":"https://api.spotify.com/v1/artists/5a2EaR3hamoenG9rDuVn8j","id":"5a2EaR3hamoenG9rDuVn8j","name":"Prince","type":"artist","uri":"spotify:artist:5a2EaR3hamoenG9rDuVn8j"}],"disc_number":1,"duration_ms":279240,"explicit":false,"external_ids":{"isrc":"USWB19903188"},"external_urls":{"spotify":"https://open.spotify.com/track/6FMIVQPZg9cmMY8hPxAacD"},"href":"https://api.spotify.com/v1/tracks/6FMIVQPZg9cmMY8hPxAacD","id":"6FMIVQPZg9cmMY8hPxAacD","is_local":false,"is_playable":true,"name":"Let's Go Crazy","track_number":1,"type":"track","uri":"spotify:track:6FMIVQPZg9cmMY8hPxAacD"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2yEwvVSSSUkcLeSTNyHKh8"},"href":"https://api.spotify.com/v1/artists/2yEwvVSSSUkcLeSTNyHKh8","id":"2yEwvVSSSUkcLeSTNyHKh8","name":"TOOL","type":"artist","uri":"spotify:artist:2yEwvVSSSUkcLeSTNyHKh8"}],"external_urls":{"spotify":"https://open.spotify.com/album/3Esn6LoXuWtLZNYq8FCzr0"},"href":"https://api.spotify.com/v1/albums/3Esn6LoXuWtLZNYq8FCzr0","id":"3Esn6LoXuWtLZNYq8FCzr0","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273fd1602df46ac56e2f5260ec0"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02fd1602df46ac56e2f5260ec0"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851fd1602df46ac56e2f5260ec0"}],"is_playable":true,"name":"Undertow","release_date":"1993-04-06","release_date_precision":"day","total_tracks":10,"type":"album","uri":"spotify:album:3Esn6LoXuWtLZNYq8FCzr0"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/2yEwvVSSSUkcLeSTNyHKh8"},"href":"https://api.spotify.com/v1/artists/2yEwvVSSSUkcLeSTNyHKh8","id":"2yEwvVSSSUkcLeSTNyHKh8","name":"TOOL","type":"artist","uri":"spotify:artist:2yEwvVSSSUkcLeSTNyHKh8"}],"disc_number":1,"duration_ms":306853,"explicit":true,"external_ids":{"isrc":"USVR10000011"},"external_urls":{"spotify":"https://open.spotify.com/track/6DyywdbmTzlmXBzG9ym7Rt"},"href":"https://api.spotify.com/v1/tracks/6DyywdbmTzlmXBzG9ym7Rt","id":"6DyywdbmTzlmXBzG9ym7Rt","is_local":false,"is_playable":true,"name":"Sober","track_number":3,"type":"track","uri":"spotify:track:6DyywdbmTzlmXBzG9ym7Rt"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Mo9PoU6svvhgEum7wh2Nd"},"href":"https://api.spotify.com/v1/artists/6Mo9PoU6svvhgEum7wh2Nd","id":"6Mo9PoU6svvhgEum7wh2Nd","name":"Public Enemy","type":"artist","uri":"spotify:artist:6Mo9PoU6svvhgEum7wh2Nd"}],"external_urls":{"spotify":"https://open.spotify.com/album/6izTLoTDL2k78sAvpLfHOP"},"href":"https://api.spotify.com/v1/albums/6izTLoTDL2k78sAvpLfHOP","id":"6izTLoTDL2k78sAvpLfHOP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2732acb820332d5f37cd536cc98"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e022acb820332d5f37cd536cc98"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048512acb820332d5f37cd536cc98"}],"is_playable":true,"name":"How You Sell Soul to a Soulless People Who Sold Their Soul?","release_date":"2007-08-07","release_date_precision":"day","total_tracks":20,"type":"album","uri":"spotify:album:6izTLoTDL2k78sAvpLfHOP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/6Mo9PoU6svvhgEum7wh2Nd"},"href":"https://api.spotify.com/v1/artists/6Mo9PoU6svvhgEum7wh2Nd","id":"6Mo9PoU6svvhgEum7wh2Nd","name":"Public Enemy","type":"artist","uri":"spotify:artist:6Mo9PoU6svvhgEum7wh2Nd"}],"disc_number":1,"duration_ms":249521,"explicit":false,"external_ids":{"isrc":"USTC10778807"},"external_urls":{"spotify":"https://open.spotify.com/track/5YpZh8wfS4moRBk0ijNcXr"},"href":"https://api.spotify.com/v1/tracks/5YpZh8wfS4moRBk0ijNcXr","id":"5YpZh8wfS4moRBk0ijNcXr","is_local":false,"is_playable":true,"name":"Harder Than You Think","track_number":3,"type":"track","uri":"spotify:track:5YpZh8wfS4moRBk0ijNcXr"},{"album":{"album_type":"single","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3bO19AOone0ubCsfDXDtYt"},"href":"https://api.spotify.com/v1/artists/3bO19AOone0ubCsfDXDtYt","id":"3bO19AOone0ubCsfDXDtYt","name":"Myles Smith","type":"artist","uri":"spotify:artist:3bO19AOone0ubCsfDXDtYt"}],"external_urls":{"spotify":"https://open.spotify.com/album/0xBVvz5KOwJtgrc9sFpnwQ"},"href":"https://api.spotify.com/v1/albums/0xBVvz5KOwJtgrc9sFpnwQ","id":"0xBVvz5KOwJtgrc9sFpnwQ","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273aa42c14488d5404e18993fdb"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02aa42c14488d5404e18993fdb"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851aa42c14488d5404e18993fdb"}],"is_playable":true,"name":"Wait For You","release_date":"2024-08-23","release_date_precision":"day","total_tracks":2,"type":"album","uri":"spotify:album:0xBVvz5KOwJtgrc9sFpnwQ"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/3bO19AOone0ubCsfDXDtYt"},"href":"https://api.spotify.com/v1/artists/3bO19AOone0ubCsfDXDtYt","id":"3bO19AOone0ubCsfDXDtYt","name":"Myles Smith","type":"artist","uri":"spotify:artist:3bO19AOone0ubCsfDXDtYt"}],"disc_number":1,"duration_ms":201533,"explicit":false,"external_ids":{"isrc":"GBARL2401092"},"external_urls":{"spotify":"https://open.spotify.com/track/0JjecOzaIzBTfIY35QGmgw"},"href":"https://api.spotify.com/v1/tracks/0JjecOzaIzBTfIY35QGmgw","id":"0JjecOzaIzBTfIY35QGmgw","is_local":false,"is_playable":true,"name":"Wait For You","track_number":1,"type":"track","uri":"spotify:track:0JjecOzaIzBTfIY35QGmgw"},{"album":{"album_type":"album","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iEtIxbK0KxaSlF7G42ZOp"},"href":"https://api.spotify.com/v1/artists/0iEtIxbK0KxaSlF7G42ZOp","id":"0iEtIxbK0KxaSlF7G42ZOp","name":"Metro Boomin","type":"artist","uri":"spotify:artist:0iEtIxbK0KxaSlF7G42ZOp"}],"external_urls":{"spotify":"https://open.spotify.com/album/7txGsnDSqVMoRl6RQ9XyZP"},"href":"https://api.spotify.com/v1/albums/7txGsnDSqVMoRl6RQ9XyZP","id":"7txGsnDSqVMoRl6RQ9XyZP","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b273c4fee55d7b51479627c31f89"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e02c4fee55d7b51479627c31f89"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d00004851c4fee55d7b51479627c31f89"}],"is_playable":true,"name":"HEROES & VILLAINS","release_date":"2022-12-02","release_date_precision":"day","total_tracks":15,"type":"album","uri":"spotify:album:7txGsnDSqVMoRl6RQ9XyZP"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/0iEtIxbK0KxaSlF7G42ZOp"},"href":"https://api.spotify.com/v1/artists/0iEtIxbK0KxaSlF7G42ZOp","id":"0iEtIxbK0KxaSlF7G42ZOp","name":"Metro Boomin","type":"artist","uri":"spotify:artist:0iEtIxbK0KxaSlF7G42ZOp"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1RyvyyTE3xzB2ZywiAwp0i"},"href":"https://api.spotify.com/v1/artists/1RyvyyTE3xzB2ZywiAwp0i","id":"1RyvyyTE3xzB2ZywiAwp0i","name":"Future","type":"artist","uri":"spotify:artist:1RyvyyTE3xzB2ZywiAwp0i"},{"external_urls":{"spotify":"https://open.spotify.com/artist/7bXgB6jMjp9ATFy66eO08Z"},"href":"https://api.spotify.com/v1/artists/7bXgB6jMjp9ATFy66eO08Z","id":"7bXgB6jMjp9ATFy66eO08Z","name":"Chris Brown","type":"artist","uri":"spotify:artist:7bXgB6jMjp9ATFy66eO08Z"}],"disc_number":1,"duration_ms":182666,"explicit":true,"external_ids":{"isrc":"USUG12208783"},"external_urls":{"spotify":"https://open.spotify.com/track/0vjeOZ3Ft5jvAi9SBFJm1j"},"href":"https://api.spotify.com/v1/tracks/0vjeOZ3Ft5jvAi9SBFJm1j","id":"0vjeOZ3Ft5jvAi9SBFJm1j","is_local":false,"is_playable":true,"name":"Superhero (Heroes & Villains) [with Future & Chris Brown]","track_number":2,"type":"track","uri":"spotify:track:0vjeOZ3Ft5jvAi9SBFJm1j"},{"album":{"album_type":"compilation","artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1C1x4MVkql8AiABuTw6DgE"},"href":"https://api.spotify.com/v1/artists/1C1x4MVkql8AiABuTw6DgE","id":"1C1x4MVkql8AiABuTw6DgE","name":"Richard Wagner","type":"artist","uri":"spotify:artist:1C1x4MVkql8AiABuTw6DgE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/0LyfQWJT6nXafLPZqxe9Of"},"href":"https://api.spotify.com/v1/artists/0LyfQWJT6nXafLPZqxe9Of","id":"0LyfQWJT6nXafLPZqxe9Of","name":"Various Artists","type":"artist","uri":"spotify:artist:0LyfQWJT6nXafLPZqxe9Of"}],"external_urls":{"spotify":"https://open.spotify.com/album/1VwCj4mbRJcJNJeTkErmFK"},"href":"https://api.spotify.com/v1/albums/1VwCj4mbRJcJNJeTkErmFK","id":"1VwCj4mbRJcJNJeTkErmFK","images":[{"height":640,"width":640,"url":"https://i.scdn.co/image/ab67616d0000b2730181feb44ef73502227144e1"},{"height":300,"width":300,"url":"https://i.scdn.co/image/ab67616d00001e020181feb44ef73502227144e1"},{"height":64,"width":64,"url":"https://i.scdn.co/image/ab67616d000048510181feb44ef73502227144e1"}],"is_playable":true,"name":"Wagner Complete Operas (Volume 1)","release_date":"2012-01-01","release_date_precision":"day","total_tracks":212,"type":"album","uri":"spotify:album:1VwCj4mbRJcJNJeTkErmFK"},"artists":[{"external_urls":{"spotify":"https://open.spotify.com/artist/1C1x4MVkql8AiABuTw6DgE"},"href":"https://api.spotify.com/v1/artists/1C1x4MVkql8AiABuTw6DgE","id":"1C1x4MVkql8AiABuTw6DgE","name":"Richard Wagner","type":"artist","uri":"spotify:artist:1C1x4MVkql8AiABuTw6DgE"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5M4s5CWEtDgi5S1mIBDerz"},"href":"https://api.spotify.com/v1/artists/5M4s5CWEtDgi5S1mIBDerz","id":"5M4s5CWEtDgi5S1mIBDerz","name":"Elizabeth Gale","type":"artist","uri":"spotify:artist:5M4s5CWEtDgi5S1mIBDerz"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5YiPZ5YGvXI7YgWZWpuSXW"},"href":"https://api.spotify.com/v1/artists/5YiPZ5YGvXI7YgWZWpuSXW","id":"5YiPZ5YGvXI7YgWZWpuSXW","name":"Alexander Young","type":"artist","uri":"spotify:artist:5YiPZ5YGvXI7YgWZWpuSXW"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6TgyVIUZBCwqYKl5FL34Sp"},"href":"https://api.spotify.com/v1/artists/6TgyVIUZBCwqYKl5FL34Sp","id":"6TgyVIUZBCwqYKl5FL34Sp","name":"Neil Jenkins","type":"artist","uri":"spotify:artist:6TgyVIUZBCwqYKl5FL34Sp"},{"external_urls":{"spotify":"https://open.spotify.com/artist/4SLa6t3vT5I81Ib1rcL90B"},"href":"https://api.spotify.com/v1/artists/4SLa6t3vT5I81Ib1rcL90B","id":"4SLa6t3vT5I81Ib1rcL90B","name":"David Lennox","type":"artist","uri":"spotify:artist:4SLa6t3vT5I81Ib1rcL90B"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5helMrpPKcTSYjioHdyEzv"},"href":"https://api.spotify.com/v1/artists/5helMrpPKcTSYjioHdyEzv","id":"5helMrpPKcTSYjioHdyEzv","name":"Ian Caley","type":"artist","uri":"spotify:artist:5helMrpPKcTSYjioHdyEzv"},{"external_urls":{"spotify":"https://open.spotify.com/artist/5FEi4BDhQSzyJdfaPIVCIy"},"href":"https://api.spotify.com/v1/artists/5FEi4BDhQSzyJdfaPIVCIy","id":"5FEi4BDhQSzyJdfaPIVCIy","name":"William Elvin","type":"artist","uri":"spotify:artist:5FEi4BDhQSzyJdfaPIVCIy"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1B1mAngQaEaWbj5WOaGeHu"},"href":"https://api.spotify.com/v1/artists/1B1mAngQaEaWbj5WOaGeHu","id":"1B1mAngQaEaWbj5WOaGeHu","name":"Leslie Fyson","type":"artist","uri":"spotify:artist:1B1mAngQaEaWbj5WOaGeHu"},{"external_urls":{"spotify":"https://open.spotify.com/artist/1z9u3vLr7gw6IBS8CP8c2X"},"href":"https://api.spotify.com/v1/artists/1z9u3vLr7gw6IBS8CP8c2X","id":"1z9u3vLr7gw6IBS8CP8c2X","name":"BBC Philharmonic","type":"artist","uri":"spotify:artist:1z9u3vLr7gw6IBS8CP8c2X"},{"external_urls":{"spotify":"https://open.spotify.com/artist/6cuA6068ujeUjQtms8gQfq"},"href":"https://api.spotify.com/v1/artists/6cuA6068ujeUjQtms8gQfq","id":"6cuA6068ujeUjQtms8gQfq","name":"Sir Edward Downes","type":"artist","uri":"spotify:artist:6cuA6068ujeUjQtms8gQfq"}],"disc_number":4,"duration_ms":179613,"explicit":false,"external_ids":{"isrc":"DEF057632905"},"external_urls":{"spotify":"https://open.spotify.com/track/4ccLQY8innhprrSLzHmnNx"},"href":"https://api.spotify.com/v1/tracks/4ccLQY8innhprrSLzHmnNx","id":"4ccLQY8innhprrSLzHmnNx","is_local":false,"is_playable":true,"name":"Das Liebesverbot / Act 1: Wen bringt man dort? Seht hin!","track_number":5,"type":"track","uri":"spotify:track:4ccLQY8innhprrSLzHmnNx"}]}}" + ], + "status": 200, + "url": "https://api.spotify.com/v1/search?q=Bring+You+Down+Wilkinson&type=track&limit=10" + } +] diff --git a/eval/live.py b/eval/live.py new file mode 100644 index 0000000..b2eee46 --- /dev/null +++ b/eval/live.py @@ -0,0 +1,284 @@ +"""Exercise the live recommendation stream and assert behavior properties.""" + +import asyncio +import json +import time +from dataclasses import dataclass, field +from pathlib import Path + +import httpx +from scenario import Scenario +from wire import validate_event + +FACET_TERMS: dict[tuple[str, str], tuple[str, ...]] = { + ("activity", "coding"): ("coding", "programming"), + ("activity", "workout"): ("workout", "gym"), + ("familiarity", "mix"): ("mix", "familiar", "new", "discover"), + ("familiarity", "new"): ("new", "unfamiliar", "discover", "surprise"), + ("language", "nl"): ("dutch", "nederlandse"), + ("era", "1990s"): ("1990", "nineties", "90s"), + ("mood", "energetic"): ("energetic", "high-energy", "high energy"), + ("mood", "relaxed"): ("relaxed", "laid-back", "laid back", "couch-friendly"), + ("mood", "subdued"): ("subdued", "background", "unobtrusive", "not too present"), +} + + +@dataclass(frozen=True) +class LiveLimits: + """Quality and latency thresholds for one live request.""" + + minimum_tracks: int + maximum_tracks: int + minimum_artists: int + first_track_budget_ms: int + total_budget_ms: int + + +@dataclass +class ScenarioResult: + """Serializable observations and property failures for one scenario.""" + + scenario: Scenario + events: list[dict[str, object]] = field(default_factory=list) + failures: list[str] = field(default_factory=list) + checks: dict[str, bool] = field(default_factory=dict) + first_track_ms: int | None = None + total_ms: int | None = None + + @property + def tracks(self) -> list[dict[str, object]]: + """Return track event payloads in streamed order.""" + return [event for event in self.events if event.get("type") == "track"] + + @property + def passed(self) -> bool: + """Return whether all required properties passed.""" + return not self.failures + + def as_report(self) -> dict[str, object]: + """Render the stable JSON report shape.""" + return { + "key": self.scenario.key, + "query": self.scenario.query, + "after": self.scenario.after, + "status": "passed" if self.passed else "failed", + "first_track_ms": self.first_track_ms, + "total_ms": self.total_ms, + "checks": self.checks, + "failures": self.failures, + "events": self.events, + "tracks": self.tracks, + } + + +async def run_live_scenarios( + scenarios: tuple[Scenario, ...], + base_url: str, + report_root: Path, + limits: LiveLimits, +) -> tuple[ScenarioResult, ...]: + """Run all scenarios sequentially and write one report for each.""" + report_root.mkdir(parents=True, exist_ok=True) + results_by_key: dict[str, ScenarioResult] = {} + async with httpx.AsyncClient(base_url=base_url, timeout=None) as client: + for scenario in scenarios: + parent = results_by_key.get(scenario.after) if scenario.after is not None else None + result = await run_live_scenario(client, scenario, limits, parent) + _write_report(report_root / f"{scenario.key}.json", result.as_report()) + results_by_key[scenario.key] = result + return tuple(results_by_key[scenario.key] for scenario in scenarios) + + +async def run_live_scenario( + client: httpx.AsyncClient, + scenario: Scenario, + limits: LiveLimits, + parent: ScenarioResult | None = None, +) -> ScenarioResult: + """Run one strict NDJSON request and evaluate its properties.""" + result = ScenarioResult(scenario) + if scenario.after is not None and (parent is None or not parent.tracks): + result.failures.append("parent scenario did not produce usable recommendations") + return result + payload = build_request(scenario, parent) + started_at = time.monotonic() + try: + async with asyncio.timeout(limits.total_budget_ms / 1000): + async with client.stream("POST", "/api/recommendations", json=payload) as response: + if response.status_code != 200: + body = (await response.aread()).decode("utf-8", errors="replace") + result.failures.append(f"HTTP {response.status_code}: {body}") + else: + await _consume_response(response, result, started_at) + except TimeoutError: + result.failures.append("stream exceeded the configured total latency budget") + except (httpx.HTTPError, ValueError) as error: + result.failures.append(f"stream failed: {error}") + result.total_ms = _elapsed_ms(started_at) + _evaluate_result(result, limits) + return result + + +def build_request(scenario: Scenario, parent: ScenarioResult | None) -> dict[str, object]: + """Build the frozen request shape, including client-owned turn context.""" + payload: dict[str, object] = {"schema_version": 1, "query": scenario.query} + if parent is None: + return payload + prior = [] + labels = [] + for event in parent.tracks: + track = event["track"] + if not isinstance(track, dict): + continue + rank = event["rank"] + artists = track["artists"] + prior_artists = list(artists)[:10] if isinstance(artists, list) else [] + prior.append( + { + "rank": rank, + "track_id": track["id"], + "title": track["title"], + "artists": prior_artists, + } + ) + labels.append( + f"{rank}. {track['title']} by {', '.join(str(name) for name in prior_artists)}" + ) + payload["history"] = [ + {"role": "user", "content": parent.scenario.query}, + {"role": "assistant", "content": "\n".join(labels)[:2000]}, + ] + payload["prior_recommendations"] = prior + return payload + + +def _evaluate_result(result: ScenarioResult, limits: LiveLimits) -> None: + event_types = [str(event.get("type")) for event in result.events] + terminal_type = event_types[-1] if event_types else None + order_is_valid = ( + bool(event_types) + and event_types[0] == "metadata" + and terminal_type in {"done", "error"} + and all(event_type in {"track", "warning"} for event_type in event_types[1:-1]) + and event_types.count("metadata") == 1 + ) + _record_check(result, "event_order", order_is_valid, "event order is invalid") + if terminal_type == "error": + terminal = result.events[-1] + result.failures.append(f"terminal error: {terminal.get('code', 'unknown')}") + + tracks = result.tracks + if terminal_type == "done": + done_count = result.events[-1].get("track_count") + _record_check( + result, + "done_track_count", + done_count == len(tracks), + "done event track count did not match streamed tracks", + ) + track_ids = [_track_field(event, "id") for event in tracks] + _record_check( + result, + "unique_track_ids", + len(track_ids) == len(set(track_ids)), + "duplicate track ids were returned", + ) + justifications = [event.get("justification") for event in tracks] + _record_check( + result, + "non_empty_justifications", + all(isinstance(value, str) and bool(value.strip()) for value in justifications), + "a track justification was empty", + ) + _record_check( + result, + "track_count", + limits.minimum_tracks <= len(tracks) <= limits.maximum_tracks, + f"track count {len(tracks)} is outside configured bounds", + ) + artists = {str(artist).casefold() for event in tracks for artist in _track_artists(event)} + _record_check( + result, + "distinct_artists", + len(artists) >= limits.minimum_artists, + f"distinct artist count {len(artists)} is below configured minimum", + ) + _record_check( + result, + "first_track_latency", + result.first_track_ms is not None and result.first_track_ms <= limits.first_track_budget_ms, + "time to first track exceeded the configured budget", + ) + _record_check( + result, + "total_latency", + result.total_ms is not None and result.total_ms <= limits.total_budget_ms, + "total latency exceeded the configured budget", + ) + _evaluate_facets(result) + + +def _evaluate_facets(result: ScenarioResult) -> None: + metadata = next( + (event for event in result.events if event.get("type") == "metadata"), + None, + ) + summary = str(metadata.get("intent_summary", "")).casefold() if metadata else "" + for name, value in result.scenario.facets.items(): + if not isinstance(value, str): + continue + terms = FACET_TERMS.get((name, value), (value.casefold(),)) + _record_check( + result, + f"facet_{name}", + any(term in summary for term in terms), + f"intent summary did not express {name}={value}", + ) + + +async def _consume_response( + response: httpx.Response, + result: ScenarioResult, + started_at: float, +) -> None: + content_type = response.headers.get("content-type", "").split(";", 1)[0] + if content_type != "application/x-ndjson": + result.failures.append(f"unexpected content type: {content_type or 'missing'}") + return + async for line in response.aiter_lines(): + if not line: + result.failures.append("NDJSON stream contained an empty line") + continue + event = validate_event(line) + event_payload = event.model_dump(mode="json") + result.events.append(event_payload) + if event_payload["type"] == "track" and result.first_track_ms is None: + result.first_track_ms = _elapsed_ms(started_at) + + +def _record_check(result: ScenarioResult, name: str, passed: bool, failure: str) -> None: + result.checks[name] = passed + if not passed: + result.failures.append(failure) + + +def _track_field(event: dict[str, object], key: str) -> str: + track = event.get("track") + return str(track.get(key, "")) if isinstance(track, dict) else "" + + +def _track_artists(event: dict[str, object]) -> list[object]: + track = event.get("track") + artists = track.get("artists") if isinstance(track, dict) else None + return artists if isinstance(artists, list) else [] + + +def _elapsed_ms(started_at: float) -> int: + return round((time.monotonic() - started_at) * 1000) + + +def _write_report(path: Path, report: dict[str, object]) -> None: + path.write_text( + json.dumps(report, ensure_ascii=True, indent=2, sort_keys=True) + "\n", + encoding="ascii", + ) diff --git a/eval/record_fixtures.py b/eval/record_fixtures.py new file mode 100644 index 0000000..db7dea5 --- /dev/null +++ b/eval/record_fixtures.py @@ -0,0 +1,142 @@ +"""Record one scenario through a locally constructed application.""" + +import argparse +import os +import sys +from importlib import import_module +from pathlib import Path +from typing import cast + +import httpx +import httpx2 +from fastapi import FastAPI +from fastapi.testclient import TestClient +from live import ScenarioResult, build_request +from recording import Httpx2RecordingTransport, HttpxRecordingTransport, write_cassettes +from scenario import SCENARIO_PATH, Scenario, load_scenarios +from wire import BACKEND_ROOT, validate_event + +EVAL_ROOT = Path(__file__).parent + + +def main() -> int: + """Record the selected scenario and persist raw plus safe cassettes.""" + arguments = _parse_arguments() + scenarios = load_scenarios(arguments.scenarios) + selected = next((item for item in scenarios if item.key == arguments.scenario), None) + if selected is None: + raise SystemExit(f"Unknown scenario: {arguments.scenario}") + spotify_client_id = _required_environment("SPOTIFY_CLIENT_ID") + spotify_refresh_token = _required_environment("SPOTIFY_SEED_REFRESH_TOKEN") + anthropic_api_key = _required_environment("ANTHROPIC_API_KEY") + + spotify_transport = Httpx2RecordingTransport(httpx2.AsyncHTTPTransport()) + anthropic_transport = HttpxRecordingTransport(httpx.AsyncHTTPTransport()) + anthropic_http_client = httpx.AsyncClient(transport=anthropic_transport) + app = _create_recording_app( + spotify_client_id, + spotify_refresh_token, + anthropic_api_key, + spotify_transport, + anthropic_http_client, + ) + try: + with TestClient(app, base_url=arguments.base_url) as client: + _record_selected(client, scenarios, selected, spotify_transport) + finally: + raw_root, redacted_root = write_cassettes( + arguments.fixture_dir, + selected.key, + { + "spotify": spotify_transport.interactions, + "anthropic": anthropic_transport.interactions, + }, + ) + print(f"Raw cassettes: {raw_root}") + print(f"Redacted cassettes: {redacted_root}") + return 0 + + +def _record_selected( + client: TestClient, + scenarios: tuple[Scenario, ...], + selected: Scenario, + spotify_transport: Httpx2RecordingTransport, +) -> None: + if selected.after is not None: + parent_scenario = next(item for item in scenarios if item.key == selected.after) + parent = _send_turn(client, parent_scenario, None) + search_count = _search_count(spotify_transport) + _send_turn(client, selected, parent) + if _search_count(spotify_transport) != search_count: + raise RuntimeError("Refinement issued new Spotify searches") + else: + _send_turn(client, selected, None) + + +def _send_turn( + client: TestClient, + scenario: Scenario, + parent: ScenarioResult | None, +) -> ScenarioResult: + response = client.post("/api/recommendations", json=build_request(scenario, parent)) + response.raise_for_status() + result = ScenarioResult(scenario) + for line in response.text.splitlines(): + event = validate_event(line) + result.events.append(cast(dict[str, object], event.model_dump(mode="json"))) + if not result.events or result.events[-1].get("type") != "done": + raise RuntimeError(f"Scenario {scenario.key} did not complete") + return result + + +def _create_recording_app( + spotify_client_id: str, + spotify_refresh_token: str, + anthropic_api_key: str, + spotify_transport: Httpx2RecordingTransport, + anthropic_http_client: httpx.AsyncClient, +) -> FastAPI: + backend_path = str(BACKEND_ROOT) + if backend_path not in sys.path: + sys.path.insert(0, backend_path) + config_module = import_module("app.config") + main_module = import_module("app.main") + application_settings = config_module.Settings( + app_mode=config_module.AppMode.LIVE, + spotify_client_id=spotify_client_id, + spotify_seed_refresh_token=spotify_refresh_token, + anthropic_api_key=anthropic_api_key, + ) + return cast( + FastAPI, + main_module.create_app( + application_settings=application_settings, + http_transport=spotify_transport, + anthropic_http_client=anthropic_http_client, + ), + ) + + +def _search_count(transport: Httpx2RecordingTransport) -> int: + return sum("/search" in interaction.url for interaction in transport.interactions) + + +def _required_environment(name: str) -> str: + value = os.environ.get(name) + if not value: + raise SystemExit(f"{name} is required for recording") + return value + + +def _parse_arguments() -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--scenario", required=True) + parser.add_argument("--base-url", required=True) + parser.add_argument("--scenarios", type=Path, default=SCENARIO_PATH) + parser.add_argument("--fixture-dir", type=Path, default=EVAL_ROOT / "fixtures") + return parser.parse_args() + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/eval/recording/__init__.py b/eval/recording/__init__.py new file mode 100644 index 0000000..c474661 --- /dev/null +++ b/eval/recording/__init__.py @@ -0,0 +1,14 @@ +"""Record and redact external HTTP interactions for fixture replay.""" + +from recording.model import RecordedInteraction +from recording.redaction import redact_cassette +from recording.storage import write_cassettes +from recording.transport import Httpx2RecordingTransport, HttpxRecordingTransport + +__all__ = [ + "Httpx2RecordingTransport", + "HttpxRecordingTransport", + "RecordedInteraction", + "redact_cassette", + "write_cassettes", +] diff --git a/eval/recording/model.py b/eval/recording/model.py new file mode 100644 index 0000000..2f51224 --- /dev/null +++ b/eval/recording/model.py @@ -0,0 +1,30 @@ +"""Transport-neutral cassette interaction model.""" + +import base64 +from dataclasses import dataclass + + +@dataclass(frozen=True) +class RecordedInteraction: + """One completed HTTP exchange with exact response chunks.""" + + method: str + url: str + status: int + request_body: bytes + response_chunks: tuple[bytes, ...] + + def as_dict(self) -> dict[str, object]: + """Encode byte fields losslessly for JSON storage.""" + return { + "method": self.method, + "url": self.url, + "status": self.status, + "request_body_base64": _encode(self.request_body), + "response_body_base64": _encode(b"".join(self.response_chunks)), + "response_chunks_base64": [_encode(chunk) for chunk in self.response_chunks], + } + + +def _encode(value: bytes) -> str: + return base64.b64encode(value).decode("ascii") diff --git a/eval/recording/redaction.py b/eval/recording/redaction.py new file mode 100644 index 0000000..95d51c2 --- /dev/null +++ b/eval/recording/redaction.py @@ -0,0 +1,219 @@ +"""Remove credentials and listener identity from persisted cassettes.""" + +import base64 +import copy +import json +import re +from dataclasses import dataclass +from pathlib import Path +from typing import cast +from urllib.parse import urlparse + +SYNTHETIC_ACCOUNT_ID = "synthetic-account" +SYNTHETIC_DISPLAY_NAME = "Synthetic Listener" +SYNTHETIC_TASTE_PATH = Path(__file__).with_name("synthetic_taste.json") +BEARER_PATTERN = re.compile(r"Bearer\s+[A-Za-z0-9._~+/=-]+", re.IGNORECASE) +SENSITIVE_PATH_PARTS = {"authorize", "oauth", "token"} + + +@dataclass(frozen=True) +class _ListenerIdentities: + account_ids: frozenset[str] + display_names: frozenset[str] + + +def is_sensitive_url(url: str) -> bool: + """Return whether an authentication exchange must never be recorded.""" + parsed = urlparse(url) + path_parts = {part.casefold() for part in parsed.path.split("/") if part} + return parsed.hostname == "accounts.spotify.com" or bool(path_parts & SENSITIVE_PATH_PARTS) + + +def redact_cassette(interactions: list[dict[str, object]]) -> list[dict[str, object]]: + """Return safe interactions without mutating or persisting the source.""" + safe = [ + _drop_headers(copy.deepcopy(interaction)) + for interaction in interactions + if not is_sensitive_url(str(interaction.get("url", ""))) + ] + identities = _collect_identities(safe) + synthetic_taste = _load_synthetic_taste() + return [_redact_interaction(interaction, identities, synthetic_taste) for interaction in safe] + + +def _drop_headers(value: object) -> object: + if isinstance(value, dict): + return { + key: _drop_headers(item) + for key, item in value.items() + if not str(key).casefold().endswith("headers") + } + if isinstance(value, list): + return [_drop_headers(item) for item in value] + return value + + +def _collect_identities(interactions: list[object]) -> _ListenerIdentities: + account_ids: set[str] = set() + display_names: set[str] = set() + for interaction in interactions: + if not isinstance(interaction, dict) or not _is_current_user_url( + str(interaction.get("url", "")) + ): + continue + payload = _decode_json(str(interaction.get("response_body_base64", ""))) + if not isinstance(payload, dict): + continue + for key in ("id", "account_id"): + value = payload.get(key) + if isinstance(value, str) and value: + account_ids.add(value) + display_name = payload.get("display_name") + if isinstance(display_name, str) and display_name: + display_names.add(display_name) + return _ListenerIdentities(frozenset(account_ids), frozenset(display_names)) + + +def _redact_interaction( + interaction: object, + identities: _ListenerIdentities, + synthetic_taste: dict[str, object], +) -> dict[str, object]: + if not isinstance(interaction, dict): + raise ValueError("Cassette interaction must be a mapping") + redacted = {str(key): value for key, value in interaction.items()} + url = _replace_text(str(redacted.get("url", "")), identities) + redacted["url"] = url + redacted["request_body_base64"] = _redact_body( + str(redacted.get("request_body_base64", "")), identities, None, synthetic_taste + ) + replacement = _taste_replacement(url, synthetic_taste) + original_body = str(redacted.get("response_body_base64", "")) + response_body = _redact_body(original_body, identities, replacement, synthetic_taste) + redacted["response_body_base64"] = response_body + chunks = redacted.get("response_chunks_base64", []) + if response_body != original_body: + redacted["response_chunks_base64"] = [response_body] if response_body else [] + elif isinstance(chunks, list): + redacted["response_chunks_base64"] = [ + _redact_body(str(chunk), identities, None, synthetic_taste) for chunk in chunks + ] + return cast(dict[str, object], _redact_value(redacted, identities, synthetic_taste)) + + +def _redact_body( + encoded: str, + identities: _ListenerIdentities, + replacement: object | None, + synthetic_taste: dict[str, object], +) -> str: + try: + raw = base64.b64decode(encoded, validate=True) + except ValueError: + raw = b"" + if replacement is not None: + value = replacement + else: + try: + value = json.loads(raw) + except (json.JSONDecodeError, UnicodeDecodeError): + text = raw.decode("utf-8", errors="replace") + return _encode(_replace_text(text, identities).encode()) + redacted = _redact_value(value, identities, synthetic_taste) + return _encode(json.dumps(redacted, ensure_ascii=True, separators=(",", ":")).encode("ascii")) + + +def _redact_value( + value: object, + identities: _ListenerIdentities, + synthetic_taste: dict[str, object], +) -> object: + if isinstance(value, dict): + return { + str(key): _taste_summary(synthetic_taste) + if str(key) == "taste_profile" + else _synthetic_identity(item, identities, synthetic_taste) + for key, item in value.items() + if not str(key).casefold().endswith("headers") + } + if isinstance(value, list): + return [_redact_value(item, identities, synthetic_taste) for item in value] + if isinstance(value, str): + text = _replace_text(value, identities) + try: + nested = json.loads(text) + except json.JSONDecodeError: + return text + if isinstance(nested, (dict, list)): + return json.dumps( + _redact_value(nested, identities, synthetic_taste), + ensure_ascii=True, + separators=(",", ":"), + ) + return text + return value + + +def _synthetic_identity( + value: object, + identities: _ListenerIdentities, + synthetic_taste: dict[str, object], +) -> object: + if isinstance(value, str) and value in identities.display_names: + return SYNTHETIC_DISPLAY_NAME + if isinstance(value, str) and value in identities.account_ids: + return SYNTHETIC_ACCOUNT_ID + return _redact_value(value, identities, synthetic_taste) + + +def _replace_text(value: str, identities: _ListenerIdentities) -> str: + redacted = BEARER_PATTERN.sub("[REDACTED]", value) + replacements = { + **{identity: SYNTHETIC_ACCOUNT_ID for identity in identities.account_ids}, + **{identity: SYNTHETIC_DISPLAY_NAME for identity in identities.display_names}, + } + for identity, replacement in sorted( + replacements.items(), key=lambda item: len(item[0]), reverse=True + ): + redacted = redacted.replace(identity, replacement) + return redacted + + +def _taste_replacement(url: str, synthetic_taste: dict[str, object]) -> object | None: + path = urlparse(url).path.rstrip("/") + if path.endswith("/me/top/artists"): + return synthetic_taste.get("top_artists") + if path.endswith("/me/top/tracks"): + return synthetic_taste.get("top_tracks") + if path.endswith("/me/tracks"): + return synthetic_taste.get("saved_tracks") + return None + + +def _is_current_user_url(url: str) -> bool: + return urlparse(url).path.rstrip("/").endswith("/v1/me") + + +def _taste_summary(synthetic_taste: dict[str, object]) -> str: + summary = synthetic_taste.get("summary") + if not isinstance(summary, str): + raise ValueError("Synthetic taste fixture must contain a summary") + return summary + + +def _load_synthetic_taste() -> dict[str, object]: + payload: object = json.loads(SYNTHETIC_TASTE_PATH.read_text(encoding="ascii")) + if not isinstance(payload, dict): + raise ValueError("Synthetic taste fixture must be a mapping") + return cast(dict[str, object], payload) + + +def _decode_json(encoded: str) -> object: + try: + return json.loads(base64.b64decode(encoded, validate=True)) + except (ValueError, json.JSONDecodeError, UnicodeDecodeError): + return None + + +def _encode(value: bytes) -> str: + return base64.b64encode(value).decode("ascii") diff --git a/eval/recording/storage.py b/eval/recording/storage.py new file mode 100644 index 0000000..1e99d80 --- /dev/null +++ b/eval/recording/storage.py @@ -0,0 +1,32 @@ +"""Persist raw and redacted cassette stores.""" + +import json +from pathlib import Path + +from recording.model import RecordedInteraction +from recording.redaction import redact_cassette + + +def write_cassettes( + fixture_root: Path, + scenario_key: str, + recordings: dict[str, list[RecordedInteraction]], +) -> tuple[Path, Path]: + """Write ignored raw data first, then separately mapped safe cassettes.""" + raw_root = fixture_root / "raw" / scenario_key + redacted_root = fixture_root / scenario_key + raw_root.mkdir(parents=True, exist_ok=True) + redacted_root.mkdir(parents=True, exist_ok=True) + for service, interactions in recordings.items(): + raw_payload = [interaction.as_dict() for interaction in interactions] + _write_json(raw_root / f"{service}.json", raw_payload) + redacted_payload = redact_cassette(raw_payload) + _write_json(redacted_root / f"{service}.json", redacted_payload) + return raw_root, redacted_root + + +def _write_json(path: Path, payload: object) -> None: + path.write_text( + json.dumps(payload, ensure_ascii=True, indent=2, sort_keys=True) + "\n", + encoding="ascii", + ) diff --git a/eval/recording/synthetic_taste.json b/eval/recording/synthetic_taste.json new file mode 100644 index 0000000..578aa8e --- /dev/null +++ b/eval/recording/synthetic_taste.json @@ -0,0 +1,95 @@ +{ + "saved_tracks": { + "href": "https://api.spotify.com/v1/me/tracks", + "items": [ + { + "added_at": "2026-01-01T00:00:00Z", + "track": { + "album": { + "images": [], + "name": "Synthetic Saved Album" + }, + "artists": [ + { + "name": "Synthetic Saved Artist" + } + ], + "external_urls": { + "spotify": "https://open.spotify.com/track/synthetic-saved-track" + }, + "id": "synthetic-saved-track", + "name": "Synthetic Saved Track", + "uri": "spotify:track:synthetic-saved-track" + } + } + ], + "limit": 50, + "next": null, + "offset": 0, + "previous": null, + "total": 1 + }, + "summary": "Short-term top artists: Synthetic Focus Artist; Long-term top artists: Synthetic Jazz Artist; Short-term top tracks: Synthetic Focus Track by Synthetic Focus Artist; Long-term top tracks: Synthetic Jazz Track by Synthetic Jazz Artist; Saved-track sample: Synthetic Saved Track by Synthetic Saved Artist", + "top_artists": { + "href": "https://api.spotify.com/v1/me/top/artists", + "items": [ + { + "id": "synthetic-focus-artist", + "name": "Synthetic Focus Artist" + }, + { + "id": "synthetic-jazz-artist", + "name": "Synthetic Jazz Artist" + } + ], + "limit": 50, + "next": null, + "offset": 0, + "previous": null, + "total": 2 + }, + "top_tracks": { + "href": "https://api.spotify.com/v1/me/top/tracks", + "items": [ + { + "album": { + "images": [], + "name": "Synthetic Focus Album" + }, + "artists": [ + { + "name": "Synthetic Focus Artist" + } + ], + "external_urls": { + "spotify": "https://open.spotify.com/track/synthetic-focus-track" + }, + "id": "synthetic-focus-track", + "name": "Synthetic Focus Track", + "uri": "spotify:track:synthetic-focus-track" + }, + { + "album": { + "images": [], + "name": "Synthetic Jazz Album" + }, + "artists": [ + { + "name": "Synthetic Jazz Artist" + } + ], + "external_urls": { + "spotify": "https://open.spotify.com/track/synthetic-jazz-track" + }, + "id": "synthetic-jazz-track", + "name": "Synthetic Jazz Track", + "uri": "spotify:track:synthetic-jazz-track" + } + ], + "limit": 50, + "next": null, + "offset": 0, + "previous": null, + "total": 2 + } +} diff --git a/eval/recording/transport.py b/eval/recording/transport.py new file mode 100644 index 0000000..8976f39 --- /dev/null +++ b/eval/recording/transport.py @@ -0,0 +1,154 @@ +"""Recording transports for Spotify's httpx2 and Anthropic's httpx.""" + +from collections.abc import AsyncIterator, Callable +from typing import cast + +import httpx +import httpx2 + +from recording.model import RecordedInteraction +from recording.redaction import is_sensitive_url + + +class HttpxRecordingTransport(httpx.AsyncBaseTransport): + """Wrap an httpx transport and retain completed response chunk sequences.""" + + def __init__(self, transport: httpx.AsyncBaseTransport) -> None: + """Bind the real transport and start an empty in-memory cassette.""" + self.transport = transport + self.interactions: list[RecordedInteraction] = [] + + async def handle_async_request(self, request: httpx.Request) -> httpx.Response: + """Forward one request and wrap its response stream for capture.""" + request.headers["Accept-Encoding"] = "identity" + request_body = await request.aread() + response = await self.transport.handle_async_request(request) + if is_sensitive_url(str(request.url)): + return response + stream = _HttpxRecordingStream( + cast(httpx.AsyncByteStream, response.stream), + lambda chunks: self._finish(request, request_body, response.status_code, chunks), + ) + return httpx.Response( + response.status_code, + headers=response.headers, + stream=stream, + extensions=response.extensions, + request=request, + ) + + async def aclose(self) -> None: + """Close the wrapped transport.""" + await self.transport.aclose() + + def _finish( + self, + request: httpx.Request, + request_body: bytes, + status: int, + chunks: tuple[bytes, ...], + ) -> None: + self.interactions.append( + RecordedInteraction(request.method, str(request.url), status, request_body, chunks) + ) + + +class Httpx2RecordingTransport(httpx2.AsyncBaseTransport): + """Wrap an httpx2 transport and retain completed response chunk sequences.""" + + def __init__(self, transport: httpx2.AsyncBaseTransport) -> None: + """Bind the real transport and start an empty in-memory cassette.""" + self.transport = transport + self.interactions: list[RecordedInteraction] = [] + + async def handle_async_request(self, request: httpx2.Request) -> httpx2.Response: + """Forward one request and wrap its response stream for capture.""" + request.headers["Accept-Encoding"] = "identity" + request_body = await request.aread() + response = await self.transport.handle_async_request(request) + if is_sensitive_url(str(request.url)): + return response + stream = _Httpx2RecordingStream( + cast(httpx2.AsyncByteStream, response.stream), + lambda chunks: self._finish(request, request_body, response.status_code, chunks), + ) + return httpx2.Response( + response.status_code, + headers=response.headers, + stream=stream, + extensions=response.extensions, + request=request, + ) + + async def aclose(self) -> None: + """Close the wrapped transport.""" + await self.transport.aclose() + + def _finish( + self, + request: httpx2.Request, + request_body: bytes, + status: int, + chunks: tuple[bytes, ...], + ) -> None: + self.interactions.append( + RecordedInteraction(request.method, str(request.url), status, request_body, chunks) + ) + + +class _HttpxRecordingStream(httpx.AsyncByteStream): + def __init__( + self, + stream: httpx.AsyncByteStream, + finish: Callable[[tuple[bytes, ...]], None], + ) -> None: + self.stream = stream + self.finish = finish + self.chunks: list[bytes] = [] + self.is_finished = False + + async def __aiter__(self) -> AsyncIterator[bytes]: + try: + async for chunk in self.stream: + self.chunks.append(chunk) + yield chunk + finally: + self._finish() + + async def aclose(self) -> None: + await self.stream.aclose() + self._finish() + + def _finish(self) -> None: + if not self.is_finished: + self.is_finished = True + self.finish(tuple(self.chunks)) + + +class _Httpx2RecordingStream(httpx2.AsyncByteStream): + def __init__( + self, + stream: httpx2.AsyncByteStream, + finish: Callable[[tuple[bytes, ...]], None], + ) -> None: + self.stream = stream + self.finish = finish + self.chunks: list[bytes] = [] + self.is_finished = False + + async def __aiter__(self) -> AsyncIterator[bytes]: + try: + async for chunk in self.stream: + self.chunks.append(chunk) + yield chunk + finally: + self._finish() + + async def aclose(self) -> None: + await self.stream.aclose() + self._finish() + + def _finish(self) -> None: + if not self.is_finished: + self.is_finished = True + self.finish(tuple(self.chunks)) diff --git a/eval/run_eval.py b/eval/run_eval.py new file mode 100644 index 0000000..0af213c --- /dev/null +++ b/eval/run_eval.py @@ -0,0 +1,98 @@ +"""Command-line entry point for live and baseline evaluation.""" + +import argparse +import asyncio +import os +from pathlib import Path + +from baseline import record_baselines, write_comparison +from live import LiveLimits, ScenarioResult, run_live_scenarios +from scenario import SCENARIO_PATH, load_scenarios + +EVAL_ROOT = Path(__file__).parent + + +def main() -> int: + """Run the selected evaluation arms and return a process status.""" + arguments = _parse_arguments() + scenarios = load_scenarios(arguments.scenarios) + exit_code = 0 + if arguments.base_url is None: + raise SystemExit("--base-url is required") + limits = LiveLimits( + minimum_tracks=arguments.min_tracks, + maximum_tracks=arguments.max_tracks, + minimum_artists=arguments.min_artists, + first_track_budget_ms=arguments.first_track_budget_ms, + total_budget_ms=arguments.total_budget_ms, + ) + results = asyncio.run( + run_live_scenarios(scenarios, arguments.base_url, arguments.report_dir, limits) + ) + _print_summary(results) + if not all(result.passed for result in results): + exit_code = 1 + + if arguments.baseline: + client_id = os.environ.get("SPOTIFY_CLIENT_ID") + client_secret = os.environ.get("SPOTIFY_CLIENT_SECRET") + if not client_id or not client_secret: + print("Spotify client credentials are absent; skipping baseline.") + else: + baseline_root = arguments.snapshot_dir / "baseline" + asyncio.run(record_baselines(scenarios, client_id, client_secret, baseline_root)) + comparison_path = write_comparison( + scenarios, + arguments.snapshot_dir / "baseline", + arguments.report_dir, + arguments.comparison_top_n, + ) + print(f"Comparison: {comparison_path}") + return exit_code + + +def _parse_arguments() -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base-url") + parser.add_argument("--baseline", action="store_true") + parser.add_argument("--scenarios", type=Path, default=SCENARIO_PATH) + parser.add_argument("--snapshot-dir", type=Path, default=EVAL_ROOT / "snapshots") + parser.add_argument("--report-dir", type=Path, default=EVAL_ROOT / "reports") + parser.add_argument("--min-tracks", type=int, default=8) + parser.add_argument("--max-tracks", type=int, default=15) + parser.add_argument("--min-artists", type=int, default=5) + parser.add_argument("--first-track-budget-ms", type=int, default=20_000) + parser.add_argument("--total-budget-ms", type=int, default=30_000) + parser.add_argument("--comparison-top-n", type=int, default=10) + arguments = parser.parse_args() + if arguments.min_tracks < 0 or arguments.max_tracks < arguments.min_tracks: + parser.error("track bounds are invalid") + if min(arguments.min_artists, arguments.first_track_budget_ms, arguments.total_budget_ms) < 0: + parser.error("artist and latency limits must be non-negative") + if arguments.comparison_top_n < 1: + parser.error("comparison top N must be positive") + return arguments + + +def _print_summary(results: tuple[ScenarioResult, ...]) -> None: + print("| Scenario | Status | Tracks | Artists | First track | Total |") + print("| --- | --- | ---: | ---: | ---: | ---: |") + for result in results: + artists = {str(artist).casefold() for event in result.tracks for artist in _artists(event)} + first = f"{result.first_track_ms} ms" if result.first_track_ms is not None else "n/a" + total = f"{result.total_ms} ms" if result.total_ms is not None else "n/a" + status = "PASS" if result.passed else "FAIL" + print( + f"| {result.scenario.key} | {status} | {len(result.tracks)} | " + f"{len(artists)} | {first} | {total} |" + ) + + +def _artists(event: dict[str, object]) -> list[object]: + track = event.get("track") + artists = track.get("artists") if isinstance(track, dict) else None + return artists if isinstance(artists, list) else [] + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/eval/scenario.py b/eval/scenario.py new file mode 100644 index 0000000..5420f62 --- /dev/null +++ b/eval/scenario.py @@ -0,0 +1,79 @@ +"""Load the shared evaluation scenario catalog.""" + +from dataclasses import dataclass +from pathlib import Path +from typing import cast + +import yaml + +SCENARIO_PATH = Path(__file__).with_name("scenarios.yaml") +FacetValue = str | bool + + +@dataclass(frozen=True) +class Scenario: + """One golden query and its expected intent facets.""" + + key: str + chip: str + query: str + facets: dict[str, FacetValue] + after: str | None = None + + @property + def is_refinement(self) -> bool: + """Return whether this query follows another scenario.""" + return self.after is not None + + +def load_scenarios(path: Path = SCENARIO_PATH) -> tuple[Scenario, ...]: + """Read and validate the shared YAML scenario catalog.""" + payload = yaml.safe_load(path.read_text(encoding="ascii")) + if not isinstance(payload, dict) or payload.get("version") != 1: + raise ValueError("Scenario catalog must have version 1") + entries = payload.get("scenarios") + if not isinstance(entries, list) or not entries: + raise ValueError("Scenario catalog must contain scenarios") + + scenarios = tuple(_parse_scenario(entry) for entry in entries) + keys = [scenario.key for scenario in scenarios] + if len(keys) != len(set(keys)): + raise ValueError("Scenario keys must be unique") + known_keys = set(keys) + for scenario in scenarios: + if scenario.after is not None and scenario.after not in known_keys: + raise ValueError(f"Unknown parent scenario: {scenario.after}") + return scenarios + + +def _parse_scenario(payload: object) -> Scenario: + if not isinstance(payload, dict): + raise ValueError("Each scenario must be a mapping") + required = {"key", "chip", "query", "facets"} + allowed = required | {"after"} + if set(payload) - allowed or not required <= set(payload): + raise ValueError("Scenario fields must match the catalog schema") + facets = payload["facets"] + if not isinstance(facets, dict) or not facets: + raise ValueError("Scenario facets must be a non-empty mapping") + if not all( + isinstance(key, str) and isinstance(value, (str, bool)) for key, value in facets.items() + ): + raise ValueError("Scenario facets must contain string or boolean values") + after = payload.get("after") + if after is not None and not isinstance(after, str): + raise ValueError("Scenario after must be a key") + return Scenario( + key=_required_string(payload, "key"), + chip=_required_string(payload, "chip"), + query=_required_string(payload, "query"), + facets=cast(dict[str, FacetValue], facets), + after=after, + ) + + +def _required_string(payload: dict[object, object], key: str) -> str: + value = payload.get(key) + if not isinstance(value, str) or not value: + raise ValueError(f"Scenario {key} must be a non-empty string") + return value diff --git a/eval/scenarios.yaml b/eval/scenarios.yaml new file mode 100644 index 0000000..e282061 --- /dev/null +++ b/eval/scenarios.yaml @@ -0,0 +1,49 @@ +version: 1 +scenarios: + - key: focus-coding + chip: Focus while coding + query: something calm for while I am programming, but not boring + facets: + activity: coding + familiarity: mix + - key: workout-energy + chip: Energy for the gym + query: high-energy music for a heavy workout + facets: + activity: workout + mood: energetic + - key: dutch-chill + chip: Dutch and relaxed + query: relaxed Dutch-language music for the couch + facets: + language: nl + mood: relaxed + - key: nineties-nostalgia + chip: 90s nostalgia + query: take me back to the nineties + facets: + era: 1990s + - key: discover-new + chip: Surprise me with something new + query: something I do not know yet but will probably like + facets: + familiarity: new + - key: rainy-sunday + chip: Rainy Sunday + query: melancholic but warm, for a rainy Sunday morning + facets: + mood: melancholic + - key: dinner-background + chip: Background for dinner + query: something jazzy for during dinner, not too present + facets: + genre: jazz + mood: subdued + - key: focus-coding-refine + chip: More electronic + query: a bit more electronic, and drop number 3 + after: focus-coding + facets: + refinement: true + pool_reuse: true + re_grounding: false diff --git a/eval/tests/test_live.py b/eval/tests/test_live.py new file mode 100644 index 0000000..208d542 --- /dev/null +++ b/eval/tests/test_live.py @@ -0,0 +1,78 @@ +"""Tests for strict live stream property evaluation.""" + +import asyncio +import json + +import httpx +import pytest +from fastapi import FastAPI +from fastapi.responses import StreamingResponse +from live import LiveLimits, run_live_scenario +from scenario import Scenario +from wire import validate_event + + +def test_live_scenario_accepts_a_valid_property_stream() -> None: + async def run() -> None: + app = FastAPI() + + @app.post("/api/recommendations") + async def recommendations() -> StreamingResponse: + events = [ + { + "type": "metadata", + "request_id": "request", + "intent_summary": "Calm music for coding with a familiar discovery mix.", + "candidate_count": 10, + }, + { + "type": "track", + "rank": 1, + "track": { + "id": "track", + "uri": "spotify:track:track", + "title": "Track", + "artists": ["Artist"], + "album_name": "Album", + "album_art_url": None, + "external_url": None, + }, + "justification": "A focused fit.", + }, + {"type": "done", "track_count": 1, "total_ms": 1}, + ] + body = "".join(json.dumps(event) + "\n" for event in events) + return StreamingResponse(iter((body,)), media_type="application/x-ndjson") + + transport = httpx.ASGITransport(app=app) + async with httpx.AsyncClient(transport=transport, base_url="http://test") as client: + result = await run_live_scenario( + client, + Scenario( + "focus-coding", + "Focus while coding", + "calm coding music", + {"activity": "coding", "familiarity": "mix"}, + ), + LiveLimits(1, 1, 1, 1_000, 1_000), + ) + + assert result.passed + assert result.checks["event_order"] + assert result.checks["done_track_count"] + + asyncio.run(run()) + + +def test_wire_validation_rejects_extra_fields() -> None: + line = json.dumps( + { + "type": "done", + "track_count": 1, + "total_ms": 1, + "unexpected": True, + } + ) + + with pytest.raises(ValueError, match="fields do not match"): + validate_event(line) diff --git a/eval/tests/test_recording.py b/eval/tests/test_recording.py new file mode 100644 index 0000000..777bedc --- /dev/null +++ b/eval/tests/test_recording.py @@ -0,0 +1,134 @@ +"""Tests for cassette transport fidelity and redaction.""" + +import asyncio +import base64 +import json +from collections.abc import AsyncIterator + +import httpx +import httpx2 +from recording import Httpx2RecordingTransport, HttpxRecordingTransport, redact_cassette + + +class HttpxChunks(httpx.AsyncByteStream): + """Yield fixed httpx byte chunks.""" + + async def __aiter__(self) -> AsyncIterator[bytes]: + yield b"first-" + yield b"second" + + +class Httpx2Chunks(httpx2.AsyncByteStream): + """Yield fixed httpx2 byte chunks.""" + + async def __aiter__(self) -> AsyncIterator[bytes]: + yield b"first-" + yield b"second" + + +def test_httpx_recording_transport_preserves_chunk_boundaries() -> None: + async def run() -> None: + async def handler(request: httpx.Request) -> httpx.Response: + return httpx.Response(200, stream=HttpxChunks()) + + transport = HttpxRecordingTransport(httpx.MockTransport(handler)) + async with httpx.AsyncClient(transport=transport) as client: + response = await client.get("https://api.anthropic.com/v1/messages") + + assert response.content == b"first-second" + assert transport.interactions[0].response_chunks == (b"first-", b"second") + + asyncio.run(run()) + + +def test_httpx2_recording_transport_preserves_chunk_boundaries() -> None: + async def run() -> None: + async def handler(request: httpx2.Request) -> httpx2.Response: + return httpx2.Response(200, stream=Httpx2Chunks()) + + transport = Httpx2RecordingTransport(httpx2.MockTransport(handler)) + async with httpx2.AsyncClient(transport=transport) as client: + response = await client.get("https://api.spotify.com/v1/search?q=test") + + assert response.content == b"first-second" + assert transport.interactions[0].response_chunks == (b"first-", b"second") + + asyncio.run(run()) + + +def test_redaction_removes_headers_tokens_identity_and_taste() -> None: + interactions = [ + { + "method": "POST", + "url": "https://accounts.spotify.com/api/token", + "request_headers": {"Authorization": "Bearer raw-token"}, + "request_body_base64": _encode(b"client_secret=secret"), + "response_body_base64": _encode(b'{"access_token":"raw-token"}'), + "response_chunks_base64": [], + "status": 200, + }, + { + "method": "GET", + "url": "https://api.spotify.com/v1/me", + "response_headers": {"Set-Cookie": "secret"}, + "request_body_base64": "", + "response_body_base64": _encode( + b'{"id":"real-account-id","display_name":"Real Listener"}' + ), + "response_chunks_base64": [], + "status": 200, + }, + { + "method": "GET", + "url": "https://api.spotify.com/v1/me/top/artists?limit=50", + "headers": {"Authorization": "Bearer raw-token"}, + "request_body_base64": "", + "response_body_base64": _encode(b'{"items":[{"name":"Private Artist"}]}'), + "response_chunks_base64": [], + "status": 200, + }, + { + "method": "POST", + "url": "https://api.anthropic.com/v1/messages", + "request_body_base64": _encode( + json.dumps( + { + "messages": [ + { + "content": json.dumps( + { + "taste_profile": "Private Artist", + "account": "real-account-id", + } + ) + } + ] + } + ).encode() + ), + "response_body_base64": _encode(b"Bearer raw-token"), + "response_chunks_base64": [_encode(b"Bearer raw-token")], + "status": 200, + }, + ] + + redacted = redact_cassette(interactions) + rendered = json.dumps(redacted) + decoded_bodies = " ".join( + base64.b64decode(str(item.get(field, ""))).decode(errors="replace") + for item in redacted + for field in ("request_body_base64", "response_body_base64") + ) + + assert len(redacted) == 3 + assert "headers" not in rendered.casefold() + assert "raw-token" not in rendered + decoded_bodies + assert "real-account-id" not in rendered + decoded_bodies + assert "Real Listener" not in rendered + decoded_bodies + assert "Private Artist" not in rendered + decoded_bodies + assert "Synthetic Focus Artist" in decoded_bodies + assert "accounts.spotify.com" not in rendered + + +def _encode(value: bytes) -> str: + return base64.b64encode(value).decode("ascii") diff --git a/eval/wire.py b/eval/wire.py new file mode 100644 index 0000000..99e72e8 --- /dev/null +++ b/eval/wire.py @@ -0,0 +1,46 @@ +"""Validate NDJSON events against the application-owned wire schemas.""" + +import json +import sys +from importlib import import_module +from pathlib import Path +from types import ModuleType + +from pydantic import BaseModel, TypeAdapter + +BACKEND_ROOT = Path(__file__).parents[1] / "backend" +EVENT_CLASS_NAMES = { + "metadata": "MetadataEvent", + "track": "TrackEvent", + "warning": "WarningEvent", + "error": "ErrorEvent", + "done": "DoneEvent", +} + + +def validate_event(line: str) -> BaseModel: + """Parse one complete line with exact fields and strict value types.""" + schemas = _load_schemas() + payload = json.loads(line) + if not isinstance(payload, dict): + raise ValueError("NDJSON event must be an object") + event_type = payload.get("type") + if not isinstance(event_type, str) or event_type not in EVENT_CLASS_NAMES: + raise ValueError("NDJSON event has an unknown type") + event_class = getattr(schemas, EVENT_CLASS_NAMES[event_type]) + if set(payload) != set(event_class.model_fields): + raise ValueError(f"{event_type} event fields do not match the wire schema") + if event_type == "track": + track = payload.get("track") + track_class = schemas.TrackCard + if not isinstance(track, dict) or set(track) != set(track_class.model_fields): + raise ValueError("track card fields do not match the wire schema") + adapter: TypeAdapter[BaseModel] = TypeAdapter(schemas.StreamEvent) + return adapter.validate_json(line, strict=True) + + +def _load_schemas() -> ModuleType: + backend_path = str(BACKEND_ROOT) + if backend_path not in sys.path: + sys.path.insert(0, backend_path) + return import_module("app.api.schemas") From 401a0ddea7487ee797d3383782691d3311616348 Mon Sep 17 00:00:00 2001 From: Justin Visser Date: Tue, 11 Aug 2026 09:14:22 +0200 Subject: [PATCH 5/7] feat: add key-free demo mode replaying recorded fixtures --- .dockerignore | 10 ++ backend/Dockerfile | 8 +- backend/app/adapters/anthropic/llm.py | 13 +- backend/app/adapters/demo/cassette.py | 128 ++++++++++++++ backend/app/adapters/demo/catalog.py | 89 ++++++++++ backend/app/adapters/demo/pipeline.py | 78 +++++++++ backend/app/adapters/demo/playlist.py | 28 +++ backend/app/adapters/demo/recommender.py | 128 ++++++++++++++ backend/app/adapters/demo/scenario.py | 151 ++++++++++++++++ backend/app/api/recommendations.py | 14 +- backend/app/api/routes.py | 26 ++- backend/app/config.py | 3 + backend/app/main.py | 50 +++++- backend/app/pipeline/orchestrator.py | 12 +- backend/tests/test_anthropic_llm.py | 4 +- backend/tests/test_demo_adapters.py | 68 ++++++++ backend/tests/test_demo_app.py | 208 +++++++++++++++++++++++ backend/tests/test_demo_scenario.py | 32 ++++ backend/tests/test_health.py | 10 +- backend/tests/test_recommendation_api.py | 10 +- docker-compose.yml | 1 + 21 files changed, 1040 insertions(+), 31 deletions(-) create mode 100644 .dockerignore create mode 100644 backend/app/adapters/demo/cassette.py create mode 100644 backend/app/adapters/demo/catalog.py create mode 100644 backend/app/adapters/demo/pipeline.py create mode 100644 backend/app/adapters/demo/playlist.py create mode 100644 backend/app/adapters/demo/recommender.py create mode 100644 backend/app/adapters/demo/scenario.py create mode 100644 backend/tests/test_demo_adapters.py create mode 100644 backend/tests/test_demo_app.py create mode 100644 backend/tests/test_demo_scenario.py diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..cc22299 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,10 @@ +.git +**/.venv +**/__pycache__ +**/.mypy_cache +**/.pytest_cache +**/.ruff_cache +frontend/node_modules +eval/fixtures/raw +dist +**/dist diff --git a/backend/Dockerfile b/backend/Dockerfile index be491c8..cc1ba2c 100644 --- a/backend/Dockerfile +++ b/backend/Dockerfile @@ -6,11 +6,15 @@ RUN npm ci COPY frontend/ ./ RUN npm run build -FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim -WORKDIR /srv +FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim AS live +WORKDIR /srv/backend COPY backend/pyproject.toml backend/uv.lock ./ RUN uv sync --frozen --no-dev --no-install-project COPY backend/app ./app +COPY eval/scenarios.yaml ../eval/scenarios.yaml COPY --from=frontend /build/dist ./app/static EXPOSE 8000 CMD ["uv", "run", "--no-sync", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"] + +FROM live AS demo +COPY eval/fixtures ../eval/fixtures diff --git a/backend/app/adapters/anthropic/llm.py b/backend/app/adapters/anthropic/llm.py index b4558eb..205df35 100644 --- a/backend/app/adapters/anthropic/llm.py +++ b/backend/app/adapters/anthropic/llm.py @@ -112,7 +112,7 @@ class AnthropicRecommender: if parsed is None: raise RecommenderOutputError("Intent response contained no structured output") validated = IntentOutput.model_validate(parsed.model_dump()) - return _to_intent(validated) + return to_intent(validated) async def stream_rerank( self, @@ -125,7 +125,7 @@ class AnthropicRecommender: ) -> AsyncGenerator[RerankSelection]: """Yield each complete valid selection while the JSON is streaming.""" schema = transform_schema(RerankOutput.model_json_schema()) - parser = _RecommendationObjectParser() + parser = RecommendationObjectParser() async with self.client.messages.stream( model=self.settings.llm_model, max_tokens=self.settings.rerank_max_tokens, @@ -166,8 +166,11 @@ class AnthropicRecommender: raise RecommenderOutputError("Rerank response returned too many selections") -class _RecommendationObjectParser: +class RecommendationObjectParser: + """Incrementally extract complete recommendation objects from JSON text.""" + def __init__(self) -> None: + """Create an empty parser for one rerank response.""" self.complete_text = "" self._scan_index = 0 self._object_start: int | None = None @@ -177,6 +180,7 @@ class _RecommendationObjectParser: self._has_found_array = False def feed(self, text_delta: str) -> list[RerankSelectionOutput]: + """Consume a text delta and return newly completed selections.""" self.complete_text += text_delta if not self._has_found_array: match = _RECOMMENDATION_ARRAY.search(self.complete_text) @@ -231,7 +235,8 @@ class _RecommendationObjectParser: raise RecommenderOutputError("Rerank item failed validation") from error -def _to_intent(output: IntentOutput) -> Intent: +def to_intent(output: IntentOutput) -> Intent: + """Map validated intent output to the application domain.""" return Intent( mood=tuple(output.mood), activity=output.activity, diff --git a/backend/app/adapters/demo/cassette.py b/backend/app/adapters/demo/cassette.py new file mode 100644 index 0000000..c4e470d --- /dev/null +++ b/backend/app/adapters/demo/cassette.py @@ -0,0 +1,128 @@ +"""Decode recorded Spotify and Anthropic responses for demo replay.""" + +import base64 +import json +from dataclasses import dataclass +from functools import cache +from pathlib import Path + +from app.adapters.demo.scenario import FIXTURE_ROOT + + +@dataclass(frozen=True) +class RecordedResponse: + """One decoded response retained from a recorded HTTP interaction.""" + + method: str + url: str + status: int + response_body: bytes + response_chunks: tuple[bytes, ...] + + def json_body(self) -> object: + """Parse the decoded response body as JSON.""" + return json.loads(self.response_body) + + +@dataclass(frozen=True) +class DemoCassette: + """The recorded service responses needed by one demo scenario.""" + + key: str + spotify_responses: tuple[RecordedResponse, ...] + intent_response_bodies: tuple[bytes, ...] + rerank_response_chunks: tuple[bytes, ...] + + @property + def intent_response_body(self) -> bytes: + """Return the final intent response recorded for this scenario.""" + return self.intent_response_bodies[-1] + + @property + def spotify_search_responses(self) -> tuple[RecordedResponse, ...]: + """Return recorded Spotify search responses in capture order.""" + return tuple(response for response in self.spotify_responses if "/search?" in response.url) + + @property + def spotify_taste_responses(self) -> tuple[RecordedResponse, ...]: + """Return recorded Spotify taste responses in capture order.""" + return tuple( + response + for response in self.spotify_responses + if any( + endpoint in response.url + for endpoint in ("/me/top/artists", "/me/top/tracks", "/me/tracks?") + ) + ) + + +@cache +def load_cassette(scenario_key: str) -> DemoCassette: + """Load and decode both service cassettes for one scenario.""" + scenario_root = FIXTURE_ROOT / scenario_key + spotify = _load_responses(scenario_root / "spotify.json") + anthropic = _load_responses(scenario_root / "anthropic.json") + intent_responses = tuple( + response for response in anthropic if _is_anthropic_message(response.response_body) + ) + rerank_responses = tuple( + response for response in anthropic if not _is_anthropic_message(response.response_body) + ) + if not spotify or not intent_responses or not rerank_responses: + raise ValueError(f"Scenario cassette is incomplete: {scenario_key}") + return DemoCassette( + key=scenario_key, + spotify_responses=spotify, + intent_response_bodies=tuple(response.response_body for response in intent_responses), + rerank_response_chunks=rerank_responses[-1].response_chunks, + ) + + +def _load_responses(path: Path) -> tuple[RecordedResponse, ...]: + payload = json.loads(path.read_text(encoding="ascii")) + if not isinstance(payload, list): + raise ValueError(f"Cassette must contain a response list: {path}") + return tuple(_decode_response(entry) for entry in payload) + + +def _decode_response(payload: object) -> RecordedResponse: + if not isinstance(payload, dict): + raise ValueError("Cassette response must be a mapping") + try: + chunks_value = payload["response_chunks_base64"] + if not isinstance(chunks_value, list): + raise TypeError + chunks = tuple(_decode_base64(value) for value in chunks_value) + return RecordedResponse( + method=_string(payload["method"]), + url=_string(payload["url"]), + status=_integer(payload["status"]), + response_body=_decode_base64(payload["response_body_base64"]), + response_chunks=chunks, + ) + except (KeyError, TypeError, ValueError) as error: + raise ValueError("Cassette response is invalid") from error + + +def _decode_base64(value: object) -> bytes: + return base64.b64decode(_string(value), validate=True) + + +def _string(value: object) -> str: + if not isinstance(value, str): + raise TypeError + return value + + +def _integer(value: object) -> int: + if not isinstance(value, int): + raise TypeError + return value + + +def _is_anthropic_message(body: bytes) -> bool: + try: + payload = json.loads(body) + except (json.JSONDecodeError, UnicodeDecodeError): + return False + return isinstance(payload, dict) and payload.get("type") == "message" diff --git a/backend/app/adapters/demo/catalog.py b/backend/app/adapters/demo/catalog.py new file mode 100644 index 0000000..f07bd48 --- /dev/null +++ b/backend/app/adapters/demo/catalog.py @@ -0,0 +1,89 @@ +"""Spotify catalog adapter backed by one recorded demo cassette.""" + +from collections import defaultdict +from urllib.parse import parse_qs, urlparse + +from app.adapters.demo.cassette import DemoCassette, RecordedResponse +from app.adapters.demo.scenario import normalize_text +from app.adapters.spotify.mapping import ( + parse_saved_track_page, + parse_search_tracks, + parse_top_artists, + parse_track_page, +) +from app.domain.models import Track +from app.ports.protocols import TimeRange + + +class DemoCatalog: + """Replay recorded Spotify search and taste responses without HTTP.""" + + def __init__(self, cassette: DemoCassette) -> None: + """Index one scenario cassette for deterministic request replay.""" + self.cassette = cassette + self._search_pages = _index_search_pages(cassette.spotify_search_responses) + self._search_cursors: dict[str, int] = defaultdict(int) + + async def search_tracks(self, query: str, limit: int = 10) -> list[Track]: + """Return the next recorded search page for a normalized query.""" + normalized_query = normalize_text(query) + pages = self._search_pages.get(normalized_query, ()) + cursor = self._search_cursors[normalized_query] + if cursor >= len(pages): + return [] + self._search_cursors[normalized_query] += 1 + return parse_search_tracks(pages[cursor].json_body())[:limit] + + async def fetch_top_artists(self, time_range: TimeRange, limit: int) -> list[str]: + """Return the recorded synthetic top artists for a time range.""" + response = self._taste_response("/me/top/artists", time_range) + return parse_top_artists(response.json_body())[:limit] + + async def fetch_top_tracks(self, time_range: TimeRange, limit: int) -> list[Track]: + """Return the recorded synthetic top tracks for a time range.""" + response = self._taste_response("/me/top/tracks", time_range) + return parse_track_page(response.json_body())[:limit] + + async def fetch_saved_tracks(self, limit: int) -> list[Track]: + """Return recorded synthetic saved-track pages in offset order.""" + responses = sorted( + ( + response + for response in self.cassette.spotify_taste_responses + if urlparse(response.url).path.endswith("/me/tracks") + ), + key=_saved_track_offset, + ) + tracks: list[Track] = [] + for response in responses: + tracks.extend(parse_saved_track_page(response.json_body())) + if len(tracks) >= limit: + break + return tracks[:limit] + + def _taste_response(self, endpoint: str, time_range: TimeRange) -> RecordedResponse: + for response in self.cassette.spotify_taste_responses: + parsed_url = urlparse(response.url) + query = parse_qs(parsed_url.query) + if parsed_url.path.endswith(endpoint) and query.get("time_range") == [time_range]: + return response + raise ValueError(f"Cassette lacks {endpoint} for {time_range}") + + +def _index_search_pages( + responses: tuple[RecordedResponse, ...], +) -> dict[str, tuple[RecordedResponse, ...]]: + pages: dict[str, list[RecordedResponse]] = defaultdict(list) + for response in responses: + query = parse_qs(urlparse(response.url).query).get("q") + if query: + pages[normalize_text(query[0])].append(response) + return {key: tuple(value) for key, value in pages.items()} + + +def _saved_track_offset(response: RecordedResponse) -> int: + value = parse_qs(urlparse(response.url).query).get("offset", ["0"])[0] + try: + return int(value) + except ValueError: + return 0 diff --git a/backend/app/adapters/demo/pipeline.py b/backend/app/adapters/demo/pipeline.py new file mode 100644 index 0000000..aab0fed --- /dev/null +++ b/backend/app/adapters/demo/pipeline.py @@ -0,0 +1,78 @@ +"""Demo-only pipeline decorator for honest fuzzy replay disclosure.""" + +import time +from collections.abc import AsyncGenerator +from contextlib import aclosing + +from app.adapters.demo.catalog import DemoCatalog +from app.adapters.demo.recommender import DemoRecommender, parse_recorded_intent +from app.adapters.demo.scenario import select_replay_scenario +from app.config import Settings +from app.domain.models import ConversationTurn, PreviousRecommendation, Track +from app.pipeline.event import PipelineEvent, PipelineMetadataEvent, PipelineWarningEvent +from app.pipeline.grounding import Grounder +from app.pipeline.orchestrator import RecommendationPipeline +from app.ports.protocols import MusicCatalog + +DEMO_REPLAY_CODE = "demo_replay" + + +class DemoReplayPipeline: + """Decorate the real pipeline with a fuzzy-replay warning event.""" + + def __init__(self, settings: Settings) -> None: + """Create one cache-preserving pipeline with a replay recommender.""" + self.settings = settings + self.pipeline = RecommendationPipeline(DemoRecommender(settings), settings) + + async def stream( + self, + session_id: str, + request_id: str, + catalog: MusicCatalog, + query: str, + history: tuple[ConversationTurn, ...], + previous_recommendations: tuple[PreviousRecommendation, ...], + ) -> AsyncGenerator[PipelineEvent]: + """Stream the selected fixture and disclose non-exact selection.""" + match = select_replay_scenario(query, bool(previous_recommendations)) + seeded_pool = await self._prepare_refinement_pool(catalog) + event_stream = self.pipeline.stream( + session_id, + request_id, + catalog, + query, + history, + previous_recommendations, + seeded_pool=seeded_pool, + ) + async with aclosing(event_stream) as events: + async for event in events: + yield event + if isinstance(event, PipelineMetadataEvent) and not match.is_exact: + yield PipelineWarningEvent( + code=DEMO_REPLAY_CODE, + message=f'Demo replay is showing the recorded "{match.chip}" scenario.', + ) + + async def _prepare_refinement_pool( + self, + catalog: MusicCatalog, + ) -> tuple[Track, ...] | None: + if not isinstance(catalog, DemoCatalog): + return None + intent_bodies = catalog.cassette.intent_response_bodies + if len(intent_bodies) < 2: + return None + # Refinement cassettes record the parent intent first and refinement intent last. + parent_intent = parse_recorded_intent(intent_bodies[0]) + result = await Grounder(self.settings).ground( + catalog, + parent_intent.candidates, + # The recorded parent pool is listener-neutral, so replay has no known-track exclusions. + frozenset(), + parent_intent.familiarity, + self.settings.rerank_count + self.settings.rerank_pool_buffer, + time.monotonic() + self.settings.request_deadline_seconds, + ) + return result.tracks diff --git a/backend/app/adapters/demo/playlist.py b/backend/app/adapters/demo/playlist.py new file mode 100644 index 0000000..b630769 --- /dev/null +++ b/backend/app/adapters/demo/playlist.py @@ -0,0 +1,28 @@ +"""Playlist writer that makes demo saves explicit and network-free.""" + +import hashlib + +import structlog + +from app.domain.models import CreatedPlaylist + + +class DemoPlaylistWriter: + """Simulate playlist writes with stable Spotify-shaped URLs.""" + + async def create_playlist(self, name: str, description: str) -> CreatedPlaylist: + """Return a deterministic fake playlist without an external write.""" + digest = hashlib.sha256(f"{name}\n{description}".encode()).hexdigest()[:12] + playlist_id = f"demo-{digest}" + return CreatedPlaylist( + id=playlist_id, + url=f"https://open.spotify.com/playlist/{playlist_id}", + ) + + async def add_tracks_to_playlist(self, playlist_id: str, track_uris: list[str]) -> None: + """Log the simulated track addition without writing to Spotify.""" + structlog.get_logger().info( + "demo_playlist_simulated", + playlist_id=playlist_id, + track_count=len(track_uris), + ) diff --git a/backend/app/adapters/demo/recommender.py b/backend/app/adapters/demo/recommender.py new file mode 100644 index 0000000..dbbad20 --- /dev/null +++ b/backend/app/adapters/demo/recommender.py @@ -0,0 +1,128 @@ +"""Anthropic recommender adapter backed by recorded response chunks.""" + +import asyncio +import json +from collections.abc import AsyncGenerator +from contextvars import ContextVar + +from app.adapters.anthropic.llm import ( + IntentOutput, + RecommendationObjectParser, + RerankOutput, + to_intent, +) +from app.adapters.demo.cassette import DemoCassette, load_cassette +from app.adapters.demo.scenario import select_replay_scenario +from app.config import Settings +from app.domain.models import ( + ConversationTurn, + Intent, + PreviousRecommendation, + RerankSelection, + Track, +) +from app.ports.protocols import RecommenderOutputError + + +class DemoRecommender: + """Replay recorded intent and rerank output through live validation.""" + + def __init__(self, settings: Settings) -> None: + """Bind replay pacing and task-local scenario state.""" + self.settings = settings + self._cassette: ContextVar[DemoCassette | None] = ContextVar( + "demo_recommender_cassette", + default=None, + ) + + async def create_intent( + self, + query: str, + history: tuple[ConversationTurn, ...], + previous_recommendations: tuple[PreviousRecommendation, ...], + taste_summary: str, + candidate_count: int, + ) -> Intent: + """Parse the selected scenario's recorded structured intent.""" + match = select_replay_scenario(query, bool(previous_recommendations)) + cassette = load_cassette(match.key) + self._cassette.set(cassette) + return parse_recorded_intent(cassette.intent_response_body) + + async def stream_rerank( + self, + intent: Intent, + grounded_tracks: tuple[Track, ...], + taste_summary: str, + history: tuple[ConversationTurn, ...], + selection_count: int, + correction: str | None = None, + ) -> AsyncGenerator[RerankSelection]: + """Replay recorded SSE chunks through the live incremental parser.""" + cassette = self._cassette.get() + if cassette is None: + raise RecommenderOutputError("Demo rerank has no selected scenario") + parser = RecommendationObjectParser() + async for text_delta in _text_deltas( + cassette.rerank_response_chunks, + self.settings.demo_chunk_delay_seconds, + ): + for selection in parser.feed(text_delta): + yield RerankSelection(selection.track_id, selection.justification) + try: + validated = RerankOutput.model_validate_json(parser.complete_text) + except ValueError as error: + raise RecommenderOutputError("Recorded rerank response is invalid") from error + if len(validated.recommendations) > selection_count: + raise RecommenderOutputError("Recorded rerank returned too many selections") + + +def parse_recorded_intent(response_body: bytes) -> Intent: + """Parse an Anthropic message body through the live intent output model.""" + try: + response = json.loads(response_body) + content = response["content"] + text = content[0]["text"] + if not isinstance(text, str): + raise TypeError + return to_intent(IntentOutput.model_validate_json(text)) + except (IndexError, KeyError, TypeError, ValueError) as error: + raise RecommenderOutputError("Recorded intent response is invalid") from error + + +async def _text_deltas( + chunks: tuple[bytes, ...], + delay_seconds: float, +) -> AsyncGenerator[str]: + buffer = b"" + for chunk_index, chunk in enumerate(chunks): + if chunk_index and delay_seconds > 0: + await asyncio.sleep(delay_seconds) + buffer += chunk + buffer = buffer.replace(b"\r\n", b"\n") + while b"\n\n" in buffer: + event, buffer = buffer.split(b"\n\n", 1) + text_delta = _event_text_delta(event) + if text_delta is not None: + yield text_delta + if buffer: + text_delta = _event_text_delta(buffer) + if text_delta is not None: + yield text_delta + + +def _event_text_delta(event: bytes) -> str | None: + data_lines = [line[5:].strip() for line in event.splitlines() if line.startswith(b"data:")] + if not data_lines: + return None + try: + payload = json.loads(b"\n".join(data_lines)) + except (json.JSONDecodeError, UnicodeDecodeError): + return None + if not isinstance(payload, dict) or payload.get("type") != "content_block_delta": + return None + delta = payload.get("delta") + if not isinstance(delta, dict) or delta.get("type") != "text_delta": + return None + text = delta.get("text") + return text if isinstance(text, str) else None diff --git a/backend/app/adapters/demo/scenario.py b/backend/app/adapters/demo/scenario.py new file mode 100644 index 0000000..a523729 --- /dev/null +++ b/backend/app/adapters/demo/scenario.py @@ -0,0 +1,151 @@ +"""Select replayable demo scenarios from the shared scenario catalog.""" + +import re +import unicodedata +from dataclasses import dataclass +from difflib import SequenceMatcher +from functools import lru_cache +from pathlib import Path + +import yaml + +_REPOSITORY_ROOT = Path(__file__).parents[4] +SCENARIO_PATH = _REPOSITORY_ROOT / "eval" / "scenarios.yaml" +FIXTURE_ROOT = _REPOSITORY_ROOT / "eval" / "fixtures" +_WORD_PATTERN = re.compile(r"[a-z0-9]+") + + +@dataclass(frozen=True) +class Scenario: + """One shared suggestion and its optional parent scenario.""" + + key: str + chip: str + query: str + after: str | None = None + + @property + def is_refinement(self) -> bool: + """Return whether this scenario refines an earlier result.""" + return self.after is not None + + +@dataclass(frozen=True) +class ScenarioMatch: + """Describe which recorded scenario will answer a demo request.""" + + key: str + is_exact: bool + scenario_query: str + chip: str + + +@lru_cache(maxsize=1) +def load_scenarios() -> tuple[Scenario, ...]: + """Load and validate the shared scenario catalog once.""" + payload = yaml.safe_load(SCENARIO_PATH.read_text(encoding="ascii")) + if not isinstance(payload, dict) or payload.get("version") != 1: + raise ValueError("Scenario catalog must have version 1") + entries = payload.get("scenarios") + if not isinstance(entries, list) or not entries: + raise ValueError("Scenario catalog must contain scenarios") + scenarios = tuple(_parse_scenario(entry) for entry in entries) + keys = {scenario.key for scenario in scenarios} + if len(keys) != len(scenarios): + raise ValueError("Scenario keys must be unique") + if any(scenario.after not in keys for scenario in scenarios if scenario.after is not None): + raise ValueError("Scenario catalog contains an unknown parent") + return scenarios + + +def select_scenario(query: str) -> ScenarioMatch: + """Select an exact scenario or the nearest available recorded fixture.""" + scenarios = _replayable_scenarios() + normalized_query = normalize_text(query) + for scenario in scenarios: + if normalized_query in {normalize_text(scenario.query), normalize_text(scenario.chip)}: + return _to_match(scenario, is_exact=True) + + selected = max( + scenarios, + key=lambda scenario: max( + SequenceMatcher(None, normalized_query, normalize_text(scenario.query)).ratio(), + SequenceMatcher(None, normalized_query, normalize_text(scenario.chip)).ratio(), + ), + ) + return _to_match(selected, is_exact=False) + + +def select_replay_scenario( + query: str, + has_previous_recommendations: bool, +) -> ScenarioMatch: + """Map a request with prior results to its recorded refinement when available.""" + selected = select_scenario(query) + scenarios = _replayable_scenarios() + selected_scenario = next(scenario for scenario in scenarios if scenario.key == selected.key) + if selected_scenario.is_refinement or not has_previous_recommendations: + return selected + refinement = next( + (scenario for scenario in scenarios if scenario.after == selected_scenario.key), + None, + ) + return _to_match(refinement, is_exact=False) if refinement is not None else selected + + +def suggestion_items() -> list[dict[str, str]]: + """Return chip and query pairs for non-refinement scenarios.""" + return [ + {"chip": scenario.chip, "query": scenario.query} + for scenario in load_scenarios() + if not scenario.is_refinement + ] + + +def normalize_text(value: str) -> str: + """Normalize text for exact and similarity matching.""" + decomposed = unicodedata.normalize("NFKD", value.casefold()) + ascii_text = decomposed.encode("ascii", errors="ignore").decode("ascii") + return " ".join(_WORD_PATTERN.findall(ascii_text)) + + +@lru_cache(maxsize=1) +def _replayable_scenarios() -> tuple[Scenario, ...]: + fixture_keys = {path.name for path in FIXTURE_ROOT.iterdir() if path.is_dir()} + scenarios = tuple(scenario for scenario in load_scenarios() if scenario.key in fixture_keys) + if not scenarios: + raise ValueError("Demo mode requires at least one scenario fixture") + return scenarios + + +def _parse_scenario(payload: object) -> Scenario: + if not isinstance(payload, dict): + raise ValueError("Each scenario must be a mapping") + required = {"key", "chip", "query", "facets"} + if not required <= set(payload): + raise ValueError("Scenario is missing a required field") + after = payload.get("after") + if after is not None and not isinstance(after, str): + raise ValueError("Scenario parent must be a key") + return Scenario( + key=_required_string(payload, "key"), + chip=_required_string(payload, "chip"), + query=_required_string(payload, "query"), + after=after, + ) + + +def _required_string(payload: dict[object, object], key: str) -> str: + value = payload.get(key) + if not isinstance(value, str) or not value: + raise ValueError(f"Scenario {key} must be a non-empty string") + return value + + +def _to_match(scenario: Scenario, is_exact: bool) -> ScenarioMatch: + return ScenarioMatch( + key=scenario.key, + is_exact=is_exact, + scenario_query=scenario.query, + chip=scenario.chip, + ) diff --git a/backend/app/api/recommendations.py b/backend/app/api/recommendations.py index 218328c..3b60512 100644 --- a/backend/app/api/recommendations.py +++ b/backend/app/api/recommendations.py @@ -1,4 +1,4 @@ -"""Authenticated recommendation streaming and playlist creation routes.""" +"""Recommendation streaming and playlist creation routes.""" import asyncio from collections.abc import AsyncIterator, Callable @@ -38,6 +38,10 @@ from app.pipeline.orchestrator import RecommendationPipeline from app.ports.protocols import MusicCatalog, PlaylistWriter SpotifyClientFactory = Callable[[SpotifySession], MusicCatalog | PlaylistWriter] +MusicCatalogFactory = Callable[ + [SpotifySession, str, tuple[PreviousRecommendation, ...]], + MusicCatalog, +] router = APIRouter() @@ -47,14 +51,12 @@ async def recommendations( request: Request, payload: RecommendationRequest, ) -> StreamingResponse: - """Stream one authenticated discovery response as NDJSON.""" + """Stream one session-resolved discovery response as NDJSON.""" resolved = resolve_session(request) if resolved is None: raise HTTPException(status_code=401, detail="Not authenticated") pipeline = cast(RecommendationPipeline, request.app.state.recommendation_pipeline) - factory = cast(SpotifyClientFactory, request.app.state.spotify_client_factory) - catalog = cast(MusicCatalog, factory(resolved.session)) request_id = cast(str, request.state.request_id) history = tuple(ConversationTurn(turn.role, turn.content) for turn in payload.history) previous = tuple( @@ -66,6 +68,8 @@ async def recommendations( ) for item in payload.prior_recommendations ) + factory = cast(MusicCatalogFactory, request.app.state.music_catalog_factory) + catalog = factory(resolved.session, payload.query, previous) return StreamingResponse( _stream_lines( @@ -86,7 +90,7 @@ async def create_playlist( request: Request, payload: PlaylistCreateRequest, ) -> PlaylistCreateResponse: - """Create and fill one authenticated Spotify playlist.""" + """Create and fill one live or simulated playlist.""" resolved = resolve_session(request) if resolved is None: raise HTTPException(status_code=401, detail="Not authenticated") diff --git a/backend/app/api/routes.py b/backend/app/api/routes.py index aab0682..05128a6 100644 --- a/backend/app/api/routes.py +++ b/backend/app/api/routes.py @@ -1,4 +1,4 @@ -"""HTTP routes for Spotify login and session management.""" +"""HTTP routes for login and session management.""" from dataclasses import dataclass from typing import cast @@ -9,7 +9,7 @@ from fastapi.responses import JSONResponse, RedirectResponse, Response from app.adapters.spotify.login import begin_login, complete_login from app.adapters.spotify.session import PendingLogins, SessionStore, SpotifySession -from app.config import Settings +from app.config import AppMode, Settings SESSION_COOKIE_NAME = "discovery_session" @@ -26,8 +26,10 @@ class ResolvedSession: @router.get("/api/auth/login") def login(request: Request) -> RedirectResponse: - """Start Spotify Authorization Code with PKCE login.""" + """Start the configured live or demo login flow.""" application_settings = cast(Settings, request.app.state.settings) + if application_settings.app_mode is AppMode.DEMO: + return RedirectResponse("/?login=demo", status_code=307) pending_logins = cast(PendingLogins, request.app.state.pending_logins) authorize_url = begin_login(application_settings, pending_logins) return RedirectResponse(authorize_url, status_code=307) @@ -40,11 +42,13 @@ async def callback( state: str | None = None, error: str | None = None, ) -> RedirectResponse: - """Complete Spotify login and establish an opaque cookie session.""" + """Complete live login and establish an opaque cookie session.""" + application_settings = cast(Settings, request.app.state.settings) + if application_settings.app_mode is AppMode.DEMO: + return RedirectResponse("/?login=demo", status_code=307) if error is not None or code is None or state is None: return _login_error_redirect() - application_settings = cast(Settings, request.app.state.settings) http = cast(httpx2.AsyncClient, request.app.state.http) pending_logins = cast(PendingLogins, request.app.state.pending_logins) session_store = cast(SessionStore, request.app.state.session_store) @@ -80,6 +84,12 @@ def current_session(request: Request) -> JSONResponse: return JSONResponse({"display_name": resolved.session.display_name}) +@router.get("/api/suggestions") +def suggestions(request: Request) -> list[dict[str, str]]: + """Return shared non-refinement suggestion chips and queries.""" + return cast(list[dict[str, str]], request.app.state.suggestions) + + @router.post("/api/auth/logout", status_code=204) def logout(request: Request) -> Response: """Remove the current application session and clear its cookie.""" @@ -105,7 +115,11 @@ def _login_error_redirect() -> RedirectResponse: def resolve_session(request: Request) -> ResolvedSession | None: - """Resolve the cookie session or the installed live seed session.""" + """Resolve the stable demo identity, cookie, or live seed session.""" + application_settings = cast(Settings, request.app.state.settings) + if application_settings.app_mode is AppMode.DEMO: + demo_session = cast(SpotifySession, request.app.state.demo_session) + return ResolvedSession("demo", demo_session) session_store = cast(SessionStore, request.app.state.session_store) cookie_session_id = request.cookies.get(SESSION_COOKIE_NAME) if cookie_session_id is not None: diff --git a/backend/app/config.py b/backend/app/config.py index a560614..fcd8d3e 100644 --- a/backend/app/config.py +++ b/backend/app/config.py @@ -73,6 +73,9 @@ class Settings(BaseSettings): resolution_cache_max_entries: int = 2048 taste_profile_ttl_seconds: float = 900.0 + # Demo replay paces recorded stream chunks so cards appear as they did live. + demo_chunk_delay_seconds: float = 0.05 + # Taste profile fetch bounds: enough signal to describe a listener # without paging through an entire library on session start. top_items_limit: int = 50 diff --git a/backend/app/main.py b/backend/app/main.py index 4b1a37c..4bd51cf 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -12,6 +12,11 @@ from fastapi import FastAPI from fastapi.staticfiles import StaticFiles from app.adapters.anthropic.llm import AnthropicRecommender +from app.adapters.demo.cassette import load_cassette +from app.adapters.demo.catalog import DemoCatalog +from app.adapters.demo.pipeline import DemoReplayPipeline +from app.adapters.demo.playlist import DemoPlaylistWriter +from app.adapters.demo.scenario import select_replay_scenario, suggestion_items from app.adapters.spotify.auth import TokenSet, refresh_access_token from app.adapters.spotify.client import SpotifyClient from app.adapters.spotify.errors import SpotifyError @@ -19,6 +24,7 @@ from app.adapters.spotify.session import PendingLogins, SessionStore, SpotifySes from app.api.recommendations import router as recommendations_router from app.api.routes import router from app.config import AppMode, Settings, settings +from app.domain.models import PreviousRecommendation from app.observability.logging import configure_logging from app.observability.timing import RequestTimingMiddleware from app.pipeline.orchestrator import RecommendationPipeline @@ -38,17 +44,35 @@ def create_app( @asynccontextmanager async def lifespan(application: FastAPI) -> AsyncIterator[None]: _validate_live_settings(active_settings) + application.state.session_store = SessionStore() + application.state.pending_logins = PendingLogins() + application.state.settings = active_settings + application.state.seed_session_id = None + application.state.suggestions = suggestion_items() + if active_settings.app_mode is AppMode.DEMO: + application.state.demo_session = _demo_session() + application.state.recommendation_pipeline = DemoReplayPipeline(active_settings) + + def demo_catalog_factory( + session: SpotifySession, + query: str, + previous_recommendations: tuple[PreviousRecommendation, ...], + ) -> DemoCatalog: + match = select_replay_scenario(query, bool(previous_recommendations)) + return DemoCatalog(load_cassette(match.key)) + + application.state.music_catalog_factory = demo_catalog_factory + application.state.spotify_client_factory = lambda session: DemoPlaylistWriter() + yield + return + async with httpx2.AsyncClient( timeout=active_settings.spotify_timeout_seconds, transport=http_transport, ) as http: application.state.http = http - application.state.session_store = SessionStore() - application.state.pending_logins = PendingLogins() - application.state.settings = active_settings - application.state.seed_session_id = None anthropic_client = AsyncAnthropic( - api_key=active_settings.anthropic_api_key or "unused-demo-key", + api_key=active_settings.anthropic_api_key, timeout=active_settings.llm_timeout_seconds, http_client=anthropic_http_client, ) @@ -61,7 +85,15 @@ def create_app( def spotify_client_factory(session: SpotifySession) -> SpotifyClient: return SpotifyClient(http, session, active_settings) + def music_catalog_factory( + session: SpotifySession, + query: str, + previous_recommendations: tuple[PreviousRecommendation, ...], + ) -> SpotifyClient: + return spotify_client_factory(session) + application.state.spotify_client_factory = spotify_client_factory + application.state.music_catalog_factory = music_catalog_factory if ( active_settings.app_mode is AppMode.LIVE and active_settings.spotify_seed_refresh_token @@ -141,3 +173,11 @@ async def _install_seed_session( display_name=current_user.display_name, ) ) + + +def _demo_session() -> SpotifySession: + return SpotifySession( + tokens=TokenSet(access_token="demo", refresh_token="demo", expires_at=float("inf")), + account_id="demo-listener", + display_name="Demo Listener", + ) diff --git a/backend/app/pipeline/orchestrator.py b/backend/app/pipeline/orchestrator.py index fc20eac..f3a35fb 100644 --- a/backend/app/pipeline/orchestrator.py +++ b/backend/app/pipeline/orchestrator.py @@ -118,6 +118,7 @@ class RecommendationPipeline: query: str, history: tuple[ConversationTurn, ...], previous_recommendations: tuple[PreviousRecommendation, ...], + seeded_pool: tuple[Track, ...] | None = None, ) -> AsyncGenerator[PipelineEvent]: """Yield ordered events for one recommendation request.""" started_at = time.monotonic() @@ -157,7 +158,9 @@ class RecommendationPipeline: candidate_count=len(intent.candidates), ) - pool = await self._grounded_pool(session_id, catalog, intent, taste, deadline_at) + pool = await self._grounded_pool( + session_id, catalog, intent, taste, deadline_at, seeded_pool + ) if not pool: yield PipelineErrorEvent( code="no_grounded_results", @@ -189,10 +192,13 @@ class RecommendationPipeline: intent: Intent, taste: CompressedTasteProfile, deadline_at: float, + seeded_pool: tuple[Track, ...] | None, ) -> tuple[Track, ...]: - """Reuse the session's pool on refinement, otherwise ground anew.""" + """Reuse the seeded or session pool on refinement, otherwise ground anew.""" if intent.is_refinement: - cached_pool = self.last_pools.get(session_id) + cached_pool = ( + seeded_pool if seeded_pool is not None else self.last_pools.get(session_id) + ) if cached_pool: return cached_pool result = await self.grounder.ground( diff --git a/backend/tests/test_anthropic_llm.py b/backend/tests/test_anthropic_llm.py index 27d3a61..c8287e3 100644 --- a/backend/tests/test_anthropic_llm.py +++ b/backend/tests/test_anthropic_llm.py @@ -2,12 +2,12 @@ import pytest -from app.adapters.anthropic.llm import _RecommendationObjectParser +from app.adapters.anthropic.llm import RecommendationObjectParser from app.ports.protocols import RecommenderOutputError def test_parser_missing_object_start_raises_typed_output_error() -> None: - parser = _RecommendationObjectParser() + parser = RecommendationObjectParser() with pytest.raises(RecommenderOutputError, match="object start position"): parser._finish_object() diff --git a/backend/tests/test_demo_adapters.py b/backend/tests/test_demo_adapters.py new file mode 100644 index 0000000..ebdd20c --- /dev/null +++ b/backend/tests/test_demo_adapters.py @@ -0,0 +1,68 @@ +"""Offline replay tests for demo service adapters.""" + +import asyncio + +from app.adapters.demo.cassette import load_cassette +from app.adapters.demo.catalog import DemoCatalog +from app.adapters.demo.recommender import DemoRecommender +from app.config import Settings + + +def test_cassette_decodes_bodies_and_preserves_rerank_chunks() -> None: + cassette = load_cassette("focus-coding") + + assert cassette.intent_response_body.startswith(b'{"model"') + assert len(cassette.spotify_search_responses) > 20 + assert len(cassette.spotify_taste_responses) == 6 + assert len(cassette.rerank_response_chunks) > 1 + assert b"event: content_block_delta" in b"".join(cassette.rerank_response_chunks) + + +def test_demo_catalog_replays_search_and_synthetic_taste_pages() -> None: + async def run() -> None: + catalog = DemoCatalog(load_cassette("focus-coding")) + + tracks = await catalog.search_tracks('track:"Stay" artist:"Hybrid Minds"') + artists = await catalog.fetch_top_artists("short_term", 50) + top_tracks = await catalog.fetch_top_tracks("long_term", 50) + saved_tracks = await catalog.fetch_saved_tracks(100) + + assert tracks[0].title == "Stay" + assert artists[0] == "Synthetic Focus Artist" + assert {track.title for track in top_tracks} >= { + "Synthetic Focus Track", + "Synthetic Jazz Track", + } + assert saved_tracks[0].title == "Synthetic Saved Track" + + asyncio.run(run()) + + +def test_demo_recommender_parses_intent_and_streams_recorded_rerank() -> None: + async def run() -> None: + recommender = DemoRecommender(Settings(demo_chunk_delay_seconds=0)) + intent = await recommender.create_intent( + "Focus while coding", + (), + (), + "Synthetic taste", + 35, + ) + selections = [ + selection + async for selection in recommender.stream_rerank( + intent, + (), + "Synthetic taste", + (), + 15, + ) + ] + + assert intent.activity == "programming" + assert len(intent.candidates) == 35 + assert len(selections) == 15 + assert selections[0].track_id == "2nIixNuuV5eHCJydG5aYIB" + assert all(selection.justification for selection in selections) + + asyncio.run(run()) diff --git a/backend/tests/test_demo_app.py b/backend/tests/test_demo_app.py new file mode 100644 index 0000000..5b04d31 --- /dev/null +++ b/backend/tests/test_demo_app.py @@ -0,0 +1,208 @@ +"""Full HTTP contract tests for key-free demo mode.""" + +import asyncio + +import httpx +from fastapi.testclient import TestClient +from pydantic import TypeAdapter +from starlette.types import ASGIApp, Message, Receive, Scope, Send + +from app.adapters.demo.scenario import load_scenarios +from app.api.schemas import StreamEvent +from app.config import Settings +from app.main import create_app + + +class _MetadataBarrier: + """Pause one marked ASGI response immediately after its metadata event.""" + + def __init__(self, app: ASGIApp) -> None: + self.app = app + self.metadata_sent = asyncio.Event() + self.resume_response = asyncio.Event() + + async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: + is_refinement = dict(scope.get("headers", ())).get(b"x-demo-request") == b"refinement" + + async def send_with_barrier(message: Message) -> None: + await send(message) + if message["type"] == "http.response.body" and b'"type":"metadata"' in message.get( + "body", b"" + ): + self.metadata_sent.set() + await self.resume_response.wait() + + await self.app(scope, receive, send_with_barrier if is_refinement else send) + + +def test_demo_request_streams_valid_events_without_a_session() -> None: + app = create_app(Settings(demo_chunk_delay_seconds=0)) + with TestClient(app) as client: + response = client.post( + "/api/recommendations", + json={"schema_version": 1, "query": "Focus while coding"}, + ) + + adapter: TypeAdapter[StreamEvent] = TypeAdapter(StreamEvent) + events = [adapter.validate_json(line) for line in response.text.splitlines()] + assert response.status_code == 200 + assert events[0].type == "metadata" + assert events[-1].type == "done" + assert sum(event.type == "track" for event in events) == 15 + + +def test_unknown_demo_query_discloses_the_replayed_scenario_before_tracks() -> None: + app = create_app(Settings(demo_chunk_delay_seconds=0)) + with TestClient(app) as client: + response = client.post( + "/api/recommendations", + json={"schema_version": 1, "query": "Focus while codign"}, + ) + + adapter: TypeAdapter[StreamEvent] = TypeAdapter(StreamEvent) + events = [adapter.validate_json(line) for line in response.text.splitlines()] + warning_index = next( + index + for index, event in enumerate(events) + if event.type == "warning" and event.code == "demo_replay" + ) + first_track_index = next(index for index, event in enumerate(events) if event.type == "track") + warning = events[warning_index] + assert warning_index < first_track_index + assert warning.type == "warning" + assert "Focus while coding" in warning.message + + +def test_demo_refinement_reconstructs_the_pool_recorded_with_its_cassette() -> None: + app = create_app(Settings(demo_chunk_delay_seconds=0)) + with TestClient(app) as client: + initial_response = client.post( + "/api/recommendations", + json={"schema_version": 1, "query": "Focus while coding"}, + ) + initial_adapter: TypeAdapter[StreamEvent] = TypeAdapter(StreamEvent) + initial_events: list[StreamEvent] = [ + initial_adapter.validate_json(line) for line in initial_response.text.splitlines() + ] + prior_recommendations = [ + { + "rank": event.rank, + "track_id": event.track.id, + "title": event.track.title, + "artists": event.track.artists, + } + for event in initial_events + if event.type == "track" + ] + response = client.post( + "/api/recommendations", + json={ + "schema_version": 1, + "query": "More electronic", + "prior_recommendations": prior_recommendations, + }, + ) + + adapter: TypeAdapter[StreamEvent] = TypeAdapter(StreamEvent) + events = [adapter.validate_json(line) for line in response.text.splitlines()] + warning_codes = [event.code for event in events if event.type == "warning"] + assert "rerank_fallback" not in warning_codes + assert sum(event.type == "track" for event in events) == 15 + + +def test_concurrent_demo_refinement_uses_its_request_local_recorded_pool() -> None: + async def run() -> None: + settings = Settings(demo_chunk_delay_seconds=0) + previous = [ + { + "rank": 1, + "track_id": "previous", + "title": "Previous track", + "artists": ["Previous artist"], + } + ] + payload = { + "schema_version": 1, + "query": "More electronic", + "prior_recommendations": previous, + } + + baseline_app = create_app(settings) + baseline_transport = httpx.ASGITransport(app=baseline_app) + async with ( + baseline_app.router.lifespan_context(baseline_app), + httpx.AsyncClient( + transport=baseline_transport, + base_url="http://test", + ) as client, + ): + baseline_response = await client.post("/api/recommendations", json=payload) + baseline_events = _stream_events(baseline_response) + expected_track_ids = [event.track.id for event in baseline_events if event.type == "track"] + + concurrent_app = create_app(settings) + barrier = _MetadataBarrier(concurrent_app) + transport = httpx.ASGITransport(app=barrier) + async with ( + concurrent_app.router.lifespan_context(concurrent_app), + httpx.AsyncClient(transport=transport, base_url="http://test") as client, + ): + refinement_task = asyncio.create_task( + client.post( + "/api/recommendations", + json=payload, + headers={"x-demo-request": "refinement"}, + ) + ) + try: + await asyncio.wait_for(barrier.metadata_sent.wait(), timeout=2) + unrelated_response = await client.post( + "/api/recommendations", + json={"schema_version": 1, "query": "Energy for the gym"}, + ) + finally: + barrier.resume_response.set() + refinement_response = await refinement_task + + events = _stream_events(refinement_response) + warning_codes = [event.code for event in events if event.type == "warning"] + track_ids = [event.track.id for event in events if event.type == "track"] + assert unrelated_response.status_code == 200 + assert refinement_response.status_code == 200 + assert "rerank_fallback" not in warning_codes + assert track_ids == expected_track_ids + + asyncio.run(run()) + + +def test_demo_auth_playlist_and_suggestions_are_explicitly_simulated() -> None: + app = create_app(Settings(demo_chunk_delay_seconds=0)) + with TestClient(app, follow_redirects=False) as client: + current_user = client.get("/api/auth/me") + login = client.get("/api/auth/login") + playlist = client.post( + "/api/playlists", + json={ + "schema_version": 1, + "name": "Night drive", + "track_uris": ["spotify:track:demo"], + }, + ) + suggestions = client.get("/api/suggestions") + + expected_suggestions = [ + {"chip": scenario.chip, "query": scenario.query} + for scenario in load_scenarios() + if not scenario.is_refinement + ] + assert current_user.json() == {"display_name": "Demo Listener"} + assert login.headers["location"] == "/?login=demo" + assert playlist.json()["url"].startswith("https://open.spotify.com/playlist/demo-") + assert suggestions.json() == expected_suggestions + assert not hasattr(app.state, "http") + assert not hasattr(app.state, "anthropic") + + +def _stream_events(response: httpx.Response) -> list[StreamEvent]: + adapter: TypeAdapter[StreamEvent] = TypeAdapter(StreamEvent) + return [adapter.validate_json(line) for line in response.text.splitlines()] diff --git a/backend/tests/test_demo_scenario.py b/backend/tests/test_demo_scenario.py new file mode 100644 index 0000000..99c30d7 --- /dev/null +++ b/backend/tests/test_demo_scenario.py @@ -0,0 +1,32 @@ +"""Tests for deterministic demo scenario selection.""" + +from app.adapters.demo.scenario import select_replay_scenario, select_scenario + + +def test_scenario_selection_prefers_normalized_exact_query_or_chip() -> None: + query_match = select_scenario("something calm for while I am programming, but not boring") + chip_match = select_scenario(" FOCUS, while CODING! ") + + assert query_match.key == "focus-coding" + assert query_match.is_exact + assert chip_match.key == "focus-coding" + assert chip_match.is_exact + + +def test_scenario_selection_falls_back_to_nearest_fixture() -> None: + match = select_scenario("Focus while codign") + + assert match.key == "focus-coding" + assert not match.is_exact + + +def test_prior_results_select_a_matching_refinement_or_same_scenario() -> None: + refinement = select_replay_scenario("Focus while coding", True) + direct_refinement = select_replay_scenario("More electronic", False) + same_scenario = select_replay_scenario("Rainy Sunday", True) + + assert refinement.key == "focus-coding-refine" + assert not refinement.is_exact + assert direct_refinement.key == "focus-coding-refine" + assert direct_refinement.is_exact + assert same_scenario.key == "rainy-sunday" diff --git a/backend/tests/test_health.py b/backend/tests/test_health.py index 441bdc1..eb12b52 100644 --- a/backend/tests/test_health.py +++ b/backend/tests/test_health.py @@ -22,8 +22,14 @@ def test_anthropic_client_uses_configured_timeout(monkeypatch: pytest.MonkeyPatc constructor = Mock(return_value=anthropic_client) monkeypatch.setattr("app.main.AsyncAnthropic", constructor) - with TestClient(create_app(Settings(llm_timeout_seconds=42.0))) as client: + live_settings = Settings( + app_mode="live", + spotify_client_id="client-id", + anthropic_api_key="api-key", + llm_timeout_seconds=42.0, + ) + with TestClient(create_app(live_settings)) as client: response = client.get("/api/health") assert response.status_code == 200 - constructor.assert_called_once_with(api_key="unused-demo-key", timeout=42.0, http_client=None) + constructor.assert_called_once_with(api_key="api-key", timeout=42.0, http_client=None) diff --git a/backend/tests/test_recommendation_api.py b/backend/tests/test_recommendation_api.py index 1920454..569ad67 100644 --- a/backend/tests/test_recommendation_api.py +++ b/backend/tests/test_recommendation_api.py @@ -12,6 +12,7 @@ from app.adapters.spotify.errors import SpotifyAuthenticationError from app.adapters.spotify.session import SessionStore, SpotifySession from app.api.routes import SESSION_COOKIE_NAME from app.api.schemas import StreamEvent +from app.config import AppMode, Settings from app.domain.models import ConversationTurn, CreatedPlaylist, PreviousRecommendation, Track from app.main import create_app from app.pipeline.event import PipelineDoneEvent, PipelineMetadataEvent, PipelineTrackEvent @@ -81,8 +82,13 @@ def test_recommendations_stream_lines_validate_against_frozen_schemas( assert [event.type for event in events] == ["metadata", "track", "done"] -def test_recommendations_require_a_valid_session_without_seed() -> None: - with TestClient(create_app()) as client: +def test_live_recommendations_require_a_valid_session_without_seed() -> None: + application_settings = Settings( + app_mode=AppMode.LIVE, + spotify_client_id="client-id", + anthropic_api_key="test-key", + ) + with TestClient(create_app(application_settings)) as client: response = client.post( "/api/recommendations", json={"schema_version": 1, "query": "focused electronic music"}, diff --git a/docker-compose.yml b/docker-compose.yml index 1c38478..7e487aa 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -3,6 +3,7 @@ services: build: context: . dockerfile: backend/Dockerfile + target: demo env_file: - path: .env required: false From 5080e9a6091b84007bbcfdc551061718d3e4bc2d Mon Sep 17 00:00:00 2001 From: Justin Visser Date: Tue, 11 Aug 2026 09:31:39 +0200 Subject: [PATCH 6/7] chore: restore wrapped chips, trim unused scopes, and complete env docs --- .env.example | 18 +++++-- AGENTS.md | 7 ++- backend/app/adapters/spotify/auth.py | 6 +-- docs/logboek.md | 42 ++++++++++++++++ frontend/src/components/SuggestionChips.vue | 54 +++++---------------- frontend/tests/resultPresentation.test.ts | 4 +- 6 files changed, 74 insertions(+), 57 deletions(-) diff --git a/.env.example b/.env.example index 05680eb..2831159 100644 --- a/.env.example +++ b/.env.example @@ -1,5 +1,17 @@ -# Copy to .env and adjust. Without a .env the app starts in demo mode. -APP_MODE=demo +# Runtime mode; set to demo for no-key fixtures or live for Spotify and Anthropic. +APP_MODE= -# The redirect URI must exactly match the URI registered in the Spotify dashboard. +# Spotify app client ID; required in live mode and unused in demo mode. SPOTIFY_CLIENT_ID= + +# Spotify OAuth callback URI; set in live mode if the local default is not registered. +SPOTIFY_REDIRECT_URI= + +# Anthropic API key; required in live mode and unused in demo mode. +ANTHROPIC_API_KEY= + +# Pre-authorized Spotify token; only for hosted instances without interactive login. +SPOTIFY_SEED_REFRESH_TOKEN= + +# Secure session cookie flag; set to true on every HTTPS deployment. +SESSION_COOKIE_SECURE= diff --git a/AGENTS.md b/AGENTS.md index 65b4f0a..f919c7c 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -26,10 +26,9 @@ api -> pipeline -> ports <- adapters domain imports nothing app-level - Spotify JSON never escapes `adapters/spotify/mapping.py`. - Pipeline tunables (counts, thresholds, budgets, model id, effort, TTLs) live in `app/config.py` (pydantic-settings). No magic numbers in code. -- LLM prompts are versioned template files under `app/prompts/`, not inline - strings. -- `eval/scenarios.yaml` is one source of truth for three consumers: golden - eval queries, demo fixture keys, and UI suggestion chips. +- LLM prompts live as constants in `app/prompts.py`, not inline in adapters. +- `eval/scenarios.yaml` defines golden eval queries and fixture-recording keys. + UI suggestion chips live in `frontend/src/lib/suggestions.ts`. ## Naming diff --git a/backend/app/adapters/spotify/auth.py b/backend/app/adapters/spotify/auth.py index fb78635..8be4b8d 100644 --- a/backend/app/adapters/spotify/auth.py +++ b/backend/app/adapters/spotify/auth.py @@ -13,11 +13,7 @@ from app.adapters.spotify.errors import SpotifyAuthenticationError AUTHORIZE_URL = "https://accounts.spotify.com/authorize" TOKEN_URL = "https://accounts.spotify.com/api/token" -SCOPES = ( - "user-top-read user-library-read user-read-recently-played " - "playlist-modify-public playlist-modify-private " - "user-read-playback-state user-modify-playback-state" -) +SCOPES = "user-top-read user-library-read playlist-modify-public playlist-modify-private" TOKEN_EXPIRY_SKEW_SECONDS = 60.0 diff --git a/docs/logboek.md b/docs/logboek.md index d70a432..1ee58cb 100644 --- a/docs/logboek.md +++ b/docs/logboek.md @@ -396,3 +396,45 @@ Wat ik heb laten vallen of uitgesteld: - Byte-snapshots per pipeline-stap; de checks hierboven en de cassettes zijn nu het bewijs. + +### Demo mode + +Wat ik deed: + +- Demo mode af: zonder keys speelt de app de opgenomen cassettes af door + dezelfde pipeline en hetzelfde streamingpad als live. Onbekende vragen + krijgen het dichtstbijzijnde scenario, met een banner die dat eerlijk + benoemt; playlist-acties zijn gesimuleerd en zo gelabeld. +- Een eerste versie deelde replay-state tussen gelijktijdige requests; + dat kon elkaars refinement verstoren. Nu krijgt elke request zijn + eigen replay-pool, met een test die de botsing naspeelt. +- Het docker image bestaat nu in twee smaken: live zonder fixtures, demo + met. docker compose bouwt standaard de demo-smaak, dus een verse clone + zonder keys werkt direct. Een .dockerignore bracht de build context + van ~350 MB terug naar ~7 MB. + +Waarom: + +- De reviewer moet de app kunnen starten met alleen docker compose, + zonder accounts of keys; demo mode is ook het bewijs dat de + ports-and-adapters opzet echt is (dezelfde poorten, andere adapter). + +Wat ik heb laten vallen of uitgesteld: + +- Meer demo-scenario's; de 8 opgenomen zijn de suggestion chips en dat + is genoeg voor het verhaal. + +### Opruimen + +Wat ik deed: + +- De suggestion chips terug naar de wrapped look; de scrollbare box uit de + vorige batch stond lelijker dan wat er eerst was. +- Ongebruikte OAuth scopes weggehaald (player en recently-played; nergens + in de code gebruikt), .env.example compleet gemaakt en AGENTS.md + gelijkgetrokken met hoe de repo er echt uitziet. + +Waarom: + +- Minder scopes vragen dan je gebruikt is netter richting de reviewer en + richting Spotify. diff --git a/frontend/src/components/SuggestionChips.vue b/frontend/src/components/SuggestionChips.vue index 8f0dfdd..70e3c18 100644 --- a/frontend/src/components/SuggestionChips.vue +++ b/frontend/src/components/SuggestionChips.vue @@ -6,59 +6,27 @@ defineEmits<{ pick: [suggestion: string] }>()