{"status":"success","username":"olamgroups","page_id":61474,"firstname":"Olam","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"text\",\"header\":\"About us\",\"data\":[{\"localHTML\":\"<p>Contact info +2348039588069....We manufacture and distribute packaged food products to African markets, addressing localised nutrition needs by offering affordable and fortified products. We offer good quality, inexpensive feed, and day-old-chicks to farmers, which also contributes to foods security.<br><br>Our mill farm produces 36,000 metric tonnes of rice for local markets under brands such as Mama\u2019s Pride and Mama\u2019s Choice.<br><br>We Brand's of rice we produce:<br>\u25aa\ufe0fMama Gold<br>\u25aa\ufe0fMama\u2019s Pride<br>\u25aa\ufe0fMama Choice Etc......<br><br>Crown Flour Mills is the second largest wheat miller in Nigeria, with two state-of-the-art facilities in Lagos, and one in Port Harcourt.<br><br>Brands of flour we produce:<br>\u25aa\ufe0fMama Gold Flour<br>\u25aa\ufe0fMix &amp; Bake Superb Flour<br>\u25aa\ufe0fBakewell Flour<br>\u25aa\ufe0fSupreme Lite Flour<br>\u25aa\ufe0fBua &amp; Crown Premium Flour Etc.......<br><br><br>Brands of Animal feeds we produce:<br><br>POULTRY<br>\u25aa\ufe0fUltima Feeds<br>\u25aa\ufe0fChikun Feeds<br><br><br>FISH FEEDS<br>\u25aa\ufe0fEcofloat Feeds<br>\u25aa\ufe0fAqualis Feeds<br>\u25aa\ufe0fBlue crown feedstock<br><br>Wesupport an \u2018Outgrower programme\u2019 for local rice-growing communities, offering training, pre-finance, fertiliser and seeds in order to improve their paddy yields. Olam generate tens of thousands of indirect jobs through our network of farmers, suppliers\/ wholesalers, local buying agents and service providers. In addition to our internal sourcing and markets, we also have significant import and export operations.<\/p>\"}]}","{\"type\":\"card\",\"header\":\"Crown Flour Mills (Olam Grains)\",\"subheader\":\"We are proud to announce that Crown Flour Mill has achieved another laudable feat. We have been awarded, The National Productivity Order of Merit Award presented by the President of the Federal Republic of Nigeria, Muhammadu Buhari GCFR to Ashish Pande (Managing Director\/ Snr. Vice President, Crown Flour Mill)\\nWe are highly honored to receive this award as we continue to serve you excellently.\\nKudos to our esteemed customers, partners and to the Crown Flour Mill team.\\n\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/73ea8ee0-1ff5-4aab-b5d1-f05b87401dd3\/IvDWKRYqTzrBkOkNQ3c5YJbvcBIr56yOJXkWFxsv.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"text\",\"header\":\"Olam Agri\",\"data\":[{\"localHTML\":\"<h2>Integrated Feed &amp; Poultry Breeding<\/h2><p>We operate Nigeria\u2019s largest poultry feed mill and day-old-chick facilities in Kaduna State and have an integrated poultry and fish feed mill in Kwara State.<\/p><p>We source ingredients locally to offer high-quality and affordable feeds to poultry farmers and our two poultry feed brands \u2013 Chikun and Ultima \u2013 are fortified with amino acids, vitamins, minerals, and feed additives that meet national and international standards. We\u2019re committed to quality and safety, and we were the first to introduce heat-treated mash and pelleted feeds to Nigeria for high microbial safety.<\/p><p><\/p><p>Our day-old chick hatchery and poultry farm produce layers (for egg production), broilers (for organised meat production), and cockerels (for backyard meat production). Our cutting-edge animal feed facilities provide local farmers with 720,000 metric tonnes of poultry feed which has the potential add eight billion eggs and 100 million kilos of poultry meat every year in Nigeria \u2013 or the equivalent of 40 eggs and 0.5kg of chicken per capita.<\/p><h3>Advanced Aquaculture<\/h3><p>We supply high quality, full-floating freshwater fish feed to more than 15,000 local farmers. Our fish feed brands \u2013 Blue Crown, Aqualis, EcoFloat and Alpha \u2013 offer balanced nutrition and high-water stability specifically tailored to the needs of the African catfish and farming practices in Nigeria.<br><\/p><h2><\/h2><p>Our facility at Ilorin in Kwara State is the most advanced fish feed manufacturing facility in Sub-Saharan Africa. Nigeria\u2019s aquaculture sector has grown by over 25% in the last four years and our world-class facility has nearly doubled the country\u2019s feed milling capacity, helped reduce the reliance on imported feed, and made quality affordable feed available to many farmers.<\/p><p>We produce competitively priced, specially formulated feed, which meets international quality and safety benchmarks and our we are helping improve best practices amongst fish farmers through our team qualified aqua technicians train fish farmers on best practices.<\/p><p><br>Our advanced laboratory assures quality at each state of production, and all our chicks receive full vaccination and environment-controlled transportation to protect their health.<br><\/p><p>We offer farmers training on best poultry practices, and we\u2019re creating thousands of direct and indirect rural employment opportunities that are helping meet rising consumer demand for chicken and fish at affordable prices.<\/p><p>To maintain a consistently high standard of animal welfare in our operations, we ensure that our practices align with internationally recognised principles in livestock production systems, determined by the World Organisation for Animal Health. We comply with all applicable laws in relation to our poultry operations, including environmental regulations.<br><\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Order Now\",\"url\":\"https:\/\/bit.ly\/3BdZBmk\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/072fc4c2-b6cd-4f4e-ab78-0f0874200062\/mtBEMVHErYejUkT1ZflD1QMv6b32rlShGA7yijFM.jpg\",\"pageTitle\":\"Olam Nigeria Limited\",\"bio\":\"We Are Re-imagining Global Agriculture Whether it's working with rice farmers in Africa, growing cotton in Australia, or developing innovative ingredients in Asia, we help our customers meet increasing consumer demands for sustainable sourcing and healthy foods.\\n\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Whatsapp\",\"label\":\"whatsapp\",\"urlPrefix\":\"www.whatsapp.com\/\",\"value\":\"23480588069\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"olammills@gmail.com\"},{\"id\":\"Phone\",\"label\":\"phone\",\"urlPrefix\":\"www.phone.com\/\",\"value\":\"8039587969\"},{\"id\":\"Facebook\",\"label\":\"facebook\",\"urlPrefix\":\"www.facebook.com\/\",\"value\":\"olamfeeds\"}],\"setTheme\":{\"selectedFont\":\"font-stylish\",\"selectedColor\":\"disha-theme-default\",\"selectedBorder\":\"border-normal\",\"selectedEdge\":\"edgeDisabled\",\"selectedBackground\":\"background-automatic\",\"selectedBrand\":\"brandDisabled\",\"toggleVisitorsBg\":false},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"},\"newUser\":false}","currency":null,"country":"NG","industry":"[\"Branding\",\"Content creation\",\"Web design\",\"Writing\"]","is_discoverable":1,"is_payment_on":1,"has_products":false,"locale":"en","rave_islive":0,"rave_keys":"","created_on":"2023-01-07T00:15:29.000000Z","updated_on":"2023-04-01T01:28:52.000000Z"}