{"status":"success","username":"logor","page_id":17672,"firstname":"Logo \"Logor\" Oluwamuyiwa","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"text\",\"header\":\"\",\"data\":[{\"localHTML\":\"<p>I am a culture analyst, artist, and filmmaker with almost a decade of experience working at the intersection of research, contemporary art, consumer insights, and multimedia production.<\/p><p>Though I enjoy working between genres, my heart belongs to photography and all sort of tinkering around contemporary art and storytelling. I come from a computer and information science background but my wild-wild weird creative side gives me unique perspectives and tools that set me apart as a culture producer and artist. This helps me understand how people, things, and systems work.<\/p><p>I have led and also been part of teams that executed very interesting award-winning creative projects and immersive ethnographic research that shaped and understood powerful nuances in social and contemporary culture as well as produced film and content for local and global audiences.<\/p><p>I am the team lead at Malokun Labs, a company that provides services in Multimedia Production, Consumer Insights, and Visual Arts.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Monochrome Lagos Project\",\"url\":\"http:\/\/www.instagram.com\/monochrome_lagos\"},{\"title\":\"Photography Portfolio\",\"url\":\"https:\/\/www.instagram.com\/logorofafrica\/?hl=en\"},{\"title\":\"Malokun Labs website\",\"url\":\"http:\/\/www.malokunlabs.com\"}]}","{\"type\":\"text\",\"header\":\"\",\"data\":[{\"localHTML\":\"<p><strong>Malokun Labs<\/strong> has its finger on the pulse of what makes Nigerians tick and facilitates meaningful connections with respondents in their natural setting. From mood-board creation to post-production, we provide expertise at every stage of the content and market research pipeline.<\/p><p>We help clients craft stories that hit the mark and have an extensive portfolio of supervising and producing content for top brands and organizations. Malokun Labs has access to a pool of seasoned talented multimedia professionals, thus making us a go-to for quality referrals and production management. We are cultural and trend-spotting experts who have supervised culturally and socially fluent projects for diverse award winning briefs.<\/p><p>Some of the clients that we have worked with include <em>Google, <a href=\\\"https:\/\/www.culturefoundryco.com\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">The Culture Foundry<\/a>, <a href=\\\"https:\/\/haveyouheard.co.za\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Have You Heard<\/a>, <a href=\\\"https:\/\/www.instagram.com\/priorgoldpictures\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">PriorGold Pictures<\/a>, Blink, THE MIX, Consumer Council, British High Commission, Royal National Theatre UK, Future Assembly, <a href=\\\"https:\/\/www.instagram.com\/p\/CEZ9BNYsTIf\/?utm_source=ig_web_copy_link\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">JM Films<\/a>, AS Roma FC &amp; Genesis Analytics.<\/em><\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"OkayAfrica: Monochrome Lagos\",\"url\":\"https:\/\/www.okayafrica.com\/monochrome-lagos-strips-city-vibrant-color\/\"},{\"title\":\"Culture Custodian: My First Million\",\"url\":\"https:\/\/culturecustodian.com\/my-first-million-logor-olumuyiwa\/\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/ee60a3f3-a281-465a-aa31-c223c04eae67\/Bm8AeQ6y82gEVUFVB1qrREwqd8l7kaCTFcvaUcwD.jpeg\",\"pageTitle\":\"Logo \\\"Logor\\\" Oluwamuyiwa\",\"bio\":\"Artist, Creative Producer, and Consumer Insights researcher.\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Whatsapp\",\"label\":\"whatsapp\",\"urlPrefix\":\"www.whatsapp.com\/\",\"value\":\"2349099981859\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"logorofafrica\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"logo.oluwamuyiwa@gmail.com\"}],\"setTheme\":{\"selectedFont\":\"font-bold\",\"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":null,"created_on":"2020-08-28T09:29:49.000000Z","updated_on":"2022-03-01T14:29:46.000000Z"}