{"status":"success","username":"r3myjay","page_id":4601,"firstname":"R3MY Jay","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"button\",\"data\":[{\"title\":\"Soundcloud\",\"url\":\"https:\/\/soundcloud.com\/r3myjay\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Audiomack\",\"url\":\"https:\/\/audiomack.com\/artist\/r3myjay\"}]}","{\"type\":\"card\",\"header\":\"Freestyles but Expensive\",\"subheader\":\"\\\"Freestyles but Expensive\\\" is a collection of random freestyles and covers recorded on my phone and released for your listening pleasure. This is me being spontaneous and not overthinking things as I always do. More importantly, this is for you! #Staysafe, stay at home and enjoy this piece.\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/d3dc5f0f-770b-4542-895c-87dcf4411173\/Sdzda5LE53sGtng72slaViXYTuJO5kfzaVNV20GS.jpeg\",\"title\":\"\",\"url\":\"https:\/\/r3myjay.fanlink.to\/FreestylesbutExpensive\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Play my music\",\"url\":\"https:\/\/r3myjay.fanlink.to\/FreestylesbutExpensive\"}]}","{\"type\":\"text\",\"header\":\"Freestyles but Expensive (A Compilation Project) \",\"data\":[{\"localHTML\":\"<p>Hey! Surprised?<\/p><p>Funny story, this project also comes as a surprise to me. I had no idea I was going to do this until yesterday. My original plans were to drop a single last month. But with the Covid-19 lockdown regulations limiting my movement, a lot of things I need in place for that release have been stalled. However, so many of my fans and friends have been asking me to \\\"drop something na\\\". So, here's a little appetizer as we await the main course.<\/p><p>\\\"Freestyles but Expensive\\\" is a collection of random freestyles and covers recorded on my phone and released for your listening pleasure. This is me being spontaneous and not overthinking things as I always do. More importantly, this is for you! #Staysafe, stay at home and enjoy this piece.<\/p><p>- Love \u2764\ufe0f and Lightttttt \ud83d\udca5<\/p><p>R3MY.<\/p><p><\/p><p><\/p><p><em>Check it out here: <\/em><a href=\\\"https:\/\/r3myjay.fanlink.to\/FreestylesbutExpensive\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/r3myjay.fanlink.to\/FreestylesbutExpensive<\/a><\/p>\"}]}","{\"type\":\"text\",\"header\":\"Inside R3MY's head: On Songwriting\",\"data\":[{\"localHTML\":\"<p><em>It's harder to write a song when you're trying to write a song.<\/em><\/p><p>It's much easier when you're driving, just sitting in church, taking a shit, eating or doing the most random thing and your head just starts brimming with ideas, lines or melodies.<\/p><p>My favourite songwriting process is waking up and remembering a song from my dream. One way or the other, my mind makes songs while I'm asleep and then I have dreams about <\/p><p>I don't really have a special time for making music. My mind works in a very different way. I'm pretty much \\\"making music\\\" half the time. Whether I'm just thinking up lines and puns, or making drumbeats in my head, thinking up melodies or randomly brooding on rap flows, I store all these things somewhere in my head (kind of like an archive) and also have several recordings and notes on my phone (for safety) and it really all comes together at some point in time.<\/p><p>But writing music (no matter how I achieve it), always comes with a rush. It's kinda like an orgasm. Of course, I might never release half these songs (not every single one of them would be \\\"release-worthy\\\"). But every single one of them was worth writing. It's self-therapy at times and so, some songs are meant for my ears alone<\/p><p>Making music, for me (not just as a musician but also as an avid listener over the years), is my solace and sinew; that means of escapism, that mode self expression, one way of the ways I truly find the perfect words to say less but to say more. It's more than just words, it's a perfect blend with sounds and beautiful rhythms. Of course,these are myopic definitions. There's truly no way to define music. It can't be demystified.<\/p><p>Music, for me, is the highest form of art. It could be poetic, dramatic, storytelling or outright chaotic.<\/p><p><em>They often say, \\\"a picture is worth more than a thousand words\\\"<\/em><\/p><p><strong>But with music, I could paint more than a million pictures.<\/strong><\/p><p><\/p><p>-Love \u2764 and Light \ud83d\udca5<\/p><p>R3MY .<\/p>\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/2ba14e45-0cf2-40aa-ad29-86202924dd85\/RUI3JN9HO4SK5CewNLxptfych2mbjwofQJhOCg7k.jpeg\",\"pageTitle\":\"R3MY Jay\",\"bio\":\"Hip-hop artiste & songwriter\\nNOT DEFINED BY GENRES\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"r3myjay\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"r3myjay\"},{\"id\":\"YouTube\",\"label\":\"youtube\",\"urlPrefix\":\"www.youtube.com\/\",\"value\":\"R3MY Jay\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"ajremy.owolabi@gmail.com\"}],\"setTheme\":{\"selectedFont\":\"font-simple\",\"selectedColor\":\"disha-theme-default\",\"selectedBorder\":\"border-default\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-light\",\"selectedBrand\":\"brandEnabled\"},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"}}","currency":null,"country":null,"industry":null,"is_discoverable":1,"is_payment_on":1,"has_products":false,"locale":"en","rave_islive":0,"rave_keys":"","created_on":"2020-04-16T18:48:00.000000Z","updated_on":"2024-04-23T13:00:24.000000Z"}