<!DOCTYPE html><html lang=en-US><head><link rel=preconnect href=https://fonts.gstatic.com crossorigin><meta charset=UTF-8><meta name=viewport content="width=device-width, initial-scale=1"><link rel=profile href=https://gmpg.org/xfn/11><meta name=robots content="index, follow, max-image-preview:large, max-snippet:-1, max-video-preview:-1"><style>html{visibility:hidden}</style><link rel=preload as=style onload="setTimeout(function(){document.querySelector('html').style.visibility='visible';}, 1);this.onload=null;this.rel='stylesheet'" href=/wp-content/cache/wpspeed/css/583e1896e202381da3768d6f6927bacc.css><title>Home - Arabian Ethical</title><meta name=description content="Trusted Pharmaceutical Distributor in UAE"><link rel=canonical href=https://arabianethicals.ae/><meta property=og:locale content=en_US><meta property=og:type content=website><meta property=og:title content="Home - Arabian Ethical"><meta property=og:description content="Trusted Pharmaceutical Distributor in UAE"><meta property=og:url content=https://arabianethicals.ae/><meta property=og:site_name content="Arabian Ethical"><meta property=article:modified_time content=2025-09-18T11:17:19+00:00><meta property=og:image content=https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4.png><meta property=og:image:width content=1254><meta property=og:image:height content=577><meta property=og:image:type content=image/png><meta name=twitter:card content=summary_large_image> <script type=application/ld+json class=yoast-schema-graph>{"@context":"https://schema.org","@graph":[{"@type":"WebPage","@id":"https://arabianethicals.ae/","url":"https://arabianethicals.ae/","name":"Home - Arabian Ethical","isPartOf":{"@id":"https://arabianethicals.ae/#website"},"about":{"@id":"https://arabianethicals.ae/#organization"},"primaryImageOfPage":{"@id":"https://arabianethicals.ae/#primaryimage"},"image":{"@id":"https://arabianethicals.ae/#primaryimage"},"thumbnailUrl":"https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4.png","datePublished":"2024-10-22T09:07:43+00:00","dateModified":"2025-09-18T11:17:19+00:00","description":"Trusted Pharmaceutical Distributor in UAE","breadcrumb":{"@id":"https://arabianethicals.ae/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https://arabianethicals.ae/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https://arabianethicals.ae/#primaryimage","url":"https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4.png","contentUrl":"https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4.png","width":1254,"height":577},{"@type":"BreadcrumbList","@id":"https://arabianethicals.ae/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home"}]},{"@type":"WebSite","@id":"https://arabianethicals.ae/#website","url":"https://arabianethicals.ae/","name":"Arabian Ethical","description":"","publisher":{"@id":"https://arabianethicals.ae/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://arabianethicals.ae/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https://arabianethicals.ae/#organization","name":"Arabian Ethical","url":"https://arabianethicals.ae/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https://arabianethicals.ae/#/schema/logo/image/","url":"https://arabianethicals.ae/wp-content/uploads/2024/10/Logo.svg","contentUrl":"https://arabianethicals.ae/wp-content/uploads/2024/10/Logo.svg","width":60,"height":86,"caption":"Arabian Ethical"},"image":{"@id":"https://arabianethicals.ae/#/schema/logo/image/"}}]}</script><link rel=alternate type=application/rss+xml title="Arabian Ethical &raquo; Feed" href=https://arabianethicals.ae/feed/><link rel=alternate type=application/rss+xml title="Arabian Ethical &raquo; Comments Feed" href=https://arabianethicals.ae/comments/feed/><link rel=preload as=style href="https://fonts.googleapis.com/css?family=Roboto%3A100%2C100italic%2C200%2C200italic%2C300%2C300italic%2C400%2C400italic%2C500%2C500italic%2C600%2C600italic%2C700%2C700italic%2C800%2C800italic%2C900%2C900italic%7CRoboto+Slab%3A100%2C100italic%2C200%2C200italic%2C300%2C300italic%2C400%2C400italic%2C500%2C500italic%2C600%2C600italic%2C700%2C700italic%2C800%2C800italic%2C900%2C900italic%7CMontserrat%3A100%2C100italic%2C200%2C200italic%2C300%2C300italic%2C400%2C400italic%2C500%2C500italic%2C600%2C600italic%2C700%2C700italic%2C800%2C800italic%2C900%2C900italic&amp;display=swap&amp;ver=6.8.2" media=all onload="this.rel='stylesheet'"><link rel=preconnect href=https://fonts.gstatic.com/ crossorigin><link rel=https://api.w.org/ href=https://arabianethicals.ae/wp-json/><link rel=alternate title=JSON type=application/json href=https://arabianethicals.ae/wp-json/wp/v2/pages/8><link rel=EditURI type=application/rsd+xml title=RSD href=https://arabianethicals.ae/xmlrpc.php?rsd><meta name=generator content="WordPress 6.8.2"><link rel=shortlink href=https://arabianethicals.ae/><link rel=alternate title="oEmbed (JSON)" type=application/json+oembed href="https://arabianethicals.ae/wp-json/oembed/1.0/embed?url=https%3A%2F%2Farabianethicals.ae%2F"><link rel=alternate title="oEmbed (XML)" type=text/xml+oembed href="https://arabianethicals.ae/wp-json/oembed/1.0/embed?url=https%3A%2F%2Farabianethicals.ae%2F&amp;format=xml"><meta name=generator content="Elementor 3.24.7; features: e_font_icon_svg, additional_custom_breakpoints, e_optimized_control_loading, e_element_cache; settings: css_print_method-external, google_font-enabled, font_display-swap"><link rel=icon href=https://arabianethicals.ae/wp-content/uploads/2024/10/Logo.svg sizes=32x32><link rel=icon href=https://arabianethicals.ae/wp-content/uploads/2024/10/Logo.svg sizes=192x192><link rel=apple-touch-icon href=https://arabianethicals.ae/wp-content/uploads/2024/10/Logo.svg><meta name=msapplication-TileImage content=https://arabianethicals.ae/wp-content/uploads/2024/10/Logo.svg><meta name=google-site-verification content=w4xomRuuhllRNpqqjb2wZxOsvvrpPqDSfDYUMmepG_A><noscript><style>img.wpspeed-lazyload,iframe.wpspeed-lazyload{display:none}</style> </noscript> </head><body class="home wp-singular page-template-default page page-id-8 wp-custom-logo wp-theme-hello-elementor elementor-default elementor-kit-6 elementor-page elementor-page-8"><noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-P53K5GKJ" height=0 width=0 style=display:none;visibility:hidden></iframe></noscript> <a class="skip-link screen-reader-text" href=#content>Skip to content</a> <div data-elementor-type=header data-elementor-id=102 class="elementor elementor-102 elementor-location-header" data-elementor-post-type=elementor_library><div class="elementor-element elementor-element-db5ccf8 e-con-full e-flex e-con e-parent" data-id=db5ccf8 data-element_type=container data-settings='{"background_background":"classic","sticky":"top","sticky_effects_offset":100,"sticky_on":["desktop","tablet","mobile"],"sticky_offset":0}'><div class="elementor-element elementor-element-c762652 e-con-full e-flex e-con e-child" data-id=c762652 data-element_type=container><div class="elementor-element elementor-element-1099fa5 elementor-widget elementor-widget-image" data-id=1099fa5 data-element_type=widget data-widget_type=image.default><div class=elementor-widget-container> <a href=https://arabianethicals.ae> <img width=60 height=86 src=https://arabianethicals.ae/wp-content/uploads/2024/10/Logo.svg class="attachment-large size-large wp-image-104" alt=""> </a> </div></div></div><div class="elementor-element elementor-element-6e9722e e-con-full e-flex e-con e-child" data-id=6e9722e data-element_type=container><div class="elementor-element elementor-element-778f810 elementor-nav-menu--dropdown-mobile elementor-nav-menu--stretch elementor-nav-menu__text-align-center elementor-nav-menu__align-start elementor-nav-menu--toggle elementor-nav-menu--burger elementor-widget elementor-widget-nav-menu" data-id=778f810 data-element_type=widget data-settings='{"full_width":"stretch","layout":"horizontal","submenu_icon":{"value":"&lt;svg class=\"e-font-icon-svg e-fas-caret-down\" viewBox=\"0 0 320 512\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\"&gt;&lt;path d=\"M31.3 192h257.3c17.8 0 26.7 21.5 14.1 34.1L174.1 354.8c-7.8 7.8-20.5 7.8-28.3 0L17.2 226.1C4.6 213.5 13.5 192 31.3 192z\"&gt;&lt;\/path&gt;&lt;\/svg&gt;","library":"fa-solid"},"toggle":"burger"}' data-widget_type=nav-menu.default><div class=elementor-widget-container> <nav aria-label=Menu class="elementor-nav-menu--main elementor-nav-menu__container elementor-nav-menu--layout-horizontal e--pointer-underline e--animation-fade"><ul id=menu-1-778f810 class=elementor-nav-menu><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-8 current_page_item menu-item-101"><a href=https://arabianethicals.ae/ aria-current=page class="elementor-item elementor-item-active">Home</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-288"><a href=https://arabianethicals.ae/about-us/ class=elementor-item>About Us</a></li> <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-421"><a href=# class="elementor-item elementor-item-anchor">Our Divisions</a> <ul class="sub-menu elementor-nav-menu--dropdown"> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-425"><a href=https://arabianethicals.ae/pharmaceuticals/ class=elementor-sub-item>Pharmaceuticals</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-424"><a href=https://arabianethicals.ae/consumer-health/ class=elementor-sub-item>Consumer Health</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-423"><a href=https://arabianethicals.ae/veterinary/ class=elementor-sub-item>Veterinary</a></li> </ul> </li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-285"><a href=https://arabianethicals.ae/media-center/ class=elementor-item>Media Center</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-286"><a href=https://arabianethicals.ae/careers/ class=elementor-item>Careers</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-284"><a href=https://arabianethicals.ae/contact-us/ class=elementor-item>Contact Us</a></li> </ul> </nav><div class=elementor-menu-toggle role=button tabindex=0 aria-label="Menu Toggle" aria-expanded=false> <svg aria-hidden=true role=presentation class="elementor-menu-toggle__icon--open e-font-icon-svg e-eicon-menu-bar" viewbox="0 0 1000 1000" xmlns=http://www.w3.org/2000/svg><path d="M104 333H896C929 333 958 304 958 271S929 208 896 208H104C71 208 42 237 42 271S71 333 104 333ZM104 583H896C929 583 958 554 958 521S929 458 896 458H104C71 458 42 487 42 521S71 583 104 583ZM104 833H896C929 833 958 804 958 771S929 708 896 708H104C71 708 42 737 42 771S71 833 104 833Z"></path></svg><svg aria-hidden=true role=presentation class="elementor-menu-toggle__icon--close e-font-icon-svg e-eicon-close" viewbox="0 0 1000 1000" xmlns=http://www.w3.org/2000/svg><path d="M742 167L500 408 258 167C246 154 233 150 217 150 196 150 179 158 167 167 154 179 150 196 150 212 150 229 154 242 171 254L408 500 167 742C138 771 138 800 167 829 196 858 225 858 254 829L496 587 738 829C750 842 767 846 783 846 800 846 817 842 829 829 842 817 846 804 846 783 846 767 842 750 829 737L588 500 833 258C863 229 863 200 833 171 804 137 775 137 742 167Z"></path></svg> <span class=elementor-screen-only>Menu</span> </div><nav class="elementor-nav-menu--dropdown elementor-nav-menu__container" aria-hidden=true><ul id=menu-2-778f810 class=elementor-nav-menu><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-8 current_page_item menu-item-101"><a href=https://arabianethicals.ae/ aria-current=page class="elementor-item elementor-item-active" tabindex=-1>Home</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-288"><a href=https://arabianethicals.ae/about-us/ class=elementor-item tabindex=-1>About Us</a></li> <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-has-children menu-item-421"><a href=# class="elementor-item elementor-item-anchor" tabindex=-1>Our Divisions</a> <ul class="sub-menu elementor-nav-menu--dropdown"> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-425"><a href=https://arabianethicals.ae/pharmaceuticals/ class=elementor-sub-item tabindex=-1>Pharmaceuticals</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-424"><a href=https://arabianethicals.ae/consumer-health/ class=elementor-sub-item tabindex=-1>Consumer Health</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-423"><a href=https://arabianethicals.ae/veterinary/ class=elementor-sub-item tabindex=-1>Veterinary</a></li> </ul> </li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-285"><a href=https://arabianethicals.ae/media-center/ class=elementor-item tabindex=-1>Media Center</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-286"><a href=https://arabianethicals.ae/careers/ class=elementor-item tabindex=-1>Careers</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-284"><a href=https://arabianethicals.ae/contact-us/ class=elementor-item tabindex=-1>Contact Us</a></li> </ul> </nav> </div> </div> </div><div class="elementor-element elementor-element-0652795 e-con-full e-flex e-con e-child" data-id=0652795 data-element_type=container><div class="elementor-element elementor-element-b37a63b elementor-widget elementor-widget-search" data-id=b37a63b data-element_type=widget data-settings='{"submit_trigger":"key_enter"}' data-widget_type=search.default><div class=elementor-widget-container> <search class="e-search hidden" role=search><form class=e-search-form action=https://arabianethicals.ae method=get> <label class=e-search-label for=search-b37a63b> <span class=elementor-screen-only> Search </span> <svg aria-hidden=true class="e-font-icon-svg e-fas-search" viewbox="0 0 512 512" xmlns=http://www.w3.org/2000/svg><path d="M505 442.7L405.3 343c-4.5-4.5-10.6-7-17-7H372c27.6-35.3 44-79.7 44-128C416 93.1 322.9 0 208 0S0 93.1 0 208s93.1 208 208 208c48.3 0 92.7-16.4 128-44v16.3c0 6.4 2.5 12.5 7 17l99.7 99.7c9.4 9.4 24.6 9.4 33.9 0l28.3-28.3c9.4-9.4 9.4-24.6.1-34zM208 336c-70.7 0-128-57.2-128-128 0-70.7 57.2-128 128-128 70.7 0 128 57.2 128 128 0 70.7-57.2 128-128 128z"></path></svg> </label> <div class=e-search-input-wrapper> <input id=search-b37a63b placeholder="" class=e-search-input type=search name=s value="" autocomplete=on role=combobox aria-autocomplete=list aria-expanded=false aria-controls=results-b37a63b aria-haspopup=listbox> <svg aria-hidden=true class="e-font-icon-svg e-fas-times" viewbox="0 0 352 512" xmlns=http://www.w3.org/2000/svg><path d="M242.72 256l100.07-100.07c12.28-12.28 12.28-32.19 0-44.48l-22.24-22.24c-12.28-12.28-32.19-12.28-44.48 0L176 189.28 75.93 89.21c-12.28-12.28-32.19-12.28-44.48 0L9.21 111.45c-12.28 12.28-12.28 32.19 0 44.48L109.28 256 9.21 356.07c-12.28 12.28-12.28 32.19 0 44.48l22.24 22.24c12.28 12.28 32.2 12.28 44.48 0L176 322.72l100.07 100.07c12.28 12.28 32.2 12.28 44.48 0l22.24-22.24c12.28-12.28 12.28-32.19 0-44.48L242.72 256z"></path></svg><output id=results-b37a63b class="e-search-results-container hide-loader" aria-live=polite aria-atomic=true aria-label="Results for search" tabindex=0><div class=e-search-results></div></output></div><button class="e-search-submit elementor-screen-only " type=submit> <span class=elementor-screen-only> </span> </button> <input type=hidden name=e_search_props value=b37a63b-102> </form></search> </div> </div> </div> </div> </div> <main id=content class="site-main post-8 page type-page status-publish hentry"><div class=page-content><div data-elementor-type=wp-page data-elementor-id=8 class="elementor elementor-8" data-elementor-post-type=page><div class="elementor-element elementor-element-9884b2a e-flex e-con-boxed e-con e-parent" data-id=9884b2a data-element_type=container data-settings='{"background_background":"classic"}'><div class=e-con-inner><div class="elementor-element elementor-element-409dc7b elementor-invisible elementor-widget elementor-widget-heading" data-id=409dc7b data-element_type=widget data-settings='{"_animation":"fadeIn"}' data-widget_type=heading.default><div class=elementor-widget-container><h1 class="elementor-heading-title elementor-size-default">Trusted Pharmaceutical Distributor in UAE</h1></div></div><div class="elementor-element elementor-element-9638c7d elementor-invisible elementor-widget elementor-widget-image" data-id=9638c7d data-element_type=widget data-settings='{"_animation":"fadeIn"}' data-widget_type=image.default><div class=elementor-widget-container> <img fetchpriority=high decoding=async width=1254 height=577 src=/wp-content/cache/wpspeed/images/5b0a4a49b1d7badc8a39b97a72d0fc8153e5201a.webp class="attachment-full size-full wp-image-12 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMjU0IiBoZWlnaHQ9IjU3NyI+PC9zdmc+ data-srcset="https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4.png 1254w, https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4-300x138.png 300w, https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4-1024x471.png 1024w, https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4-768x353.png 768w" sizes="(max-width: 1254px) 100vw, 1254px"><noscript><img fetchpriority=high decoding=async width=1254 height=577 src=/wp-content/cache/wpspeed/images/5b0a4a49b1d7badc8a39b97a72d0fc8153e5201a.webp class="attachment-full size-full wp-image-12" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4.png 1254w, https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4-300x138.png 300w, https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4-1024x471.png 1024w, https://arabianethicals.ae/wp-content/uploads/2024/10/Group-4-768x353.png 768w" sizes="(max-width: 1254px) 100vw, 1254px"></noscript></div></div><div class="elementor-element elementor-element-7ffec1b elementor-widget elementor-widget-menu-anchor" data-id=7ffec1b data-element_type=widget data-widget_type=menu-anchor.default><div class=elementor-widget-container><div class=elementor-menu-anchor id=Down></div></div></div><div class="elementor-element elementor-element-fcec1db elementor-view-default elementor-widget elementor-widget-icon" data-id=fcec1db data-element_type=widget data-widget_type=icon.default><div class=elementor-widget-container><div class=elementor-icon-wrapper> <a class=elementor-icon href=#Down> <svg xmlns=http://www.w3.org/2000/svg width=44.987 height=20.972 viewbox="0 0 44.987 20.972"><path id=Arrow d=M938,1058.435l.359-.7-.359-.3.459-.9,21.79,18.192-.073-.142,22.352-18.563.46.9-.36.3.36.7-22.351,18.564-.07-.136-.331.648Z transform="translate(-937.997 -1056.026)" fill=#fff></path></svg> </a> </div></div></div></div></div><div class="elementor-element elementor-element-e6ed027 e-con-full e-flex e-con e-parent" data-id=e6ed027 data-element_type=container><div class="elementor-element elementor-element-152c166 e-con-full e-flex e-con e-child" data-id=152c166 data-element_type=container><div class="elementor-element elementor-element-932f154 elementor-widget elementor-widget-heading" data-id=932f154 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">ADVANCING THE UAE&rsquo;S HEALTHCARE ECOSYSTEM</h2></div></div><div class="elementor-element elementor-element-d5bef8f elementor-hidden-desktop elementor-hidden-tablet elementor-hidden-mobile elementor-widget elementor-widget-text-editor" data-id=d5bef8f data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Arabian Ethicals was established in 1977 to deliver specialized premium pharmaceuticals, veterinary medicines, consumer care and cosmetic solutions to the UAE&rsquo;s growing and evolving healthcare marketplace.</p></div></div><div class="elementor-element elementor-element-32365c8 elementor-widget elementor-widget-text-editor" data-id=32365c8 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>With over 45 years of experience, Arabian Ethicals has been a trusted provider of premium pharmaceuticals, veterinary medicines, and consumer care in the UAE. Established in 1977, the company is now recognized as one of the country&rsquo;s leading healthcare solution providers, offering end-to-end expertise in registration, importation, warehousing, distribution, sales, and market access. Serving both private and government sectors, Arabian Ethicals partners with top multinational brands and supports 2,000+ clients through a dedicated team of 125+ professionals committed to excellence, innovation, and customer satisfaction.</p></div></div></div><div class="elementor-element elementor-element-3f7ae39 e-con-full e-flex e-con e-child" data-id=3f7ae39 data-element_type=container><div class="elementor-element elementor-element-f8cda62 elementor-invisible elementor-widget elementor-widget-image" data-id=f8cda62 data-element_type=widget data-settings='{"_animation":"fadeInRight","_animation_mobile":"fadeIn"}' data-widget_type=image.default><div class=elementor-widget-container> <img decoding=async width=2048 height=1365 src=https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1.webp class="attachment-full size-full wp-image-3782 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyMDQ4IiBoZWlnaHQ9IjEzNjUiPjwvc3ZnPg==" data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1.webp 2048w, https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1-300x200.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1-1024x683.webp 1024w, https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1-768x512.webp 768w, https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1-1536x1024.webp 1536w" sizes="(max-width: 2048px) 100vw, 2048px"><noscript><img decoding=async width=2048 height=1365 src=https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1.webp class="attachment-full size-full wp-image-3782" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1.webp 2048w, https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1-300x200.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1-1024x683.webp 1024w, https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1-768x512.webp 768w, https://arabianethicals.ae/wp-content/uploads/2025/09/DBX00285-Edit-1-2048x1365-1-1536x1024.webp 1536w" sizes="(max-width: 2048px) 100vw, 2048px"></noscript></div></div></div></div><div class="elementor-element elementor-element-c5b7227 e-con-full e-flex e-con e-parent" data-id=c5b7227 data-element_type=container data-settings='{"background_background":"classic"}'><div class="elementor-element elementor-element-bfe236e e-con-full e-flex e-con e-child" data-id=bfe236e data-element_type=container><div class="elementor-element elementor-element-c3c9a37 elementor-widget elementor-widget-heading" data-id=c3c9a37 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">OUR DIVISIONS</h2></div></div><div class="elementor-element elementor-element-4f15ec6 elementor-widget elementor-widget-text-editor" data-id=4f15ec6 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Arabian Ethicals extends excellence through three dedicated divisions, deploying effective &amp; efficient distribution strategies and solutions for some of the leading names in the industry.</p></div></div><div class="elementor-element elementor-element-721fe3f e-con-full e-flex e-con e-child" data-id=721fe3f data-element_type=container><div class="elementor-element elementor-element-6d7800a e-con-full threecol animated-slow e-flex elementor-invisible e-con e-child" data-id=6d7800a data-element_type=container data-settings='{"background_background":"classic","animation":"fadeInRight","animation_mobile":"fadeIn"}'><div class="elementor-element elementor-element-4d342aa elementor-widget elementor-widget-image" data-id=4d342aa data-element_type=widget data-widget_type=image.default><div class=elementor-widget-container> <img loading=lazy decoding=async width=450 height=447 src=https://arabianethicals.ae/wp-content/uploads/2025/09/image-container.webp class="attachment-large size-large wp-image-3786 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI0NTAiIGhlaWdodD0iNDQ3Ij48L3N2Zz4=" data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/image-container.webp 450w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-container-300x298.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-container-150x150.webp 150w" sizes="(max-width: 450px) 100vw, 450px"><noscript><img loading=lazy decoding=async width=450 height=447 src=https://arabianethicals.ae/wp-content/uploads/2025/09/image-container.webp class="attachment-large size-large wp-image-3786" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/image-container.webp 450w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-container-300x298.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-container-150x150.webp 150w" sizes="(max-width: 450px) 100vw, 450px"></noscript></div></div><div class="elementor-element elementor-element-490624d elementor-widget elementor-widget-heading" data-id=490624d data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">Pharmaceuticals</h2></div></div><div class="elementor-element elementor-element-80544f0 elementor-widget elementor-widget-text-editor" data-id=80544f0 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Effective registration, importation, warehousing, sales and promotion&nbsp; coupled with market access strategies development.</p></div></div><div class="elementor-element elementor-element-32244ff btnserv elementor-widget elementor-widget-button" data-id=32244ff data-element_type=widget data-widget_type=button.default><div class=elementor-widget-container><div class=elementor-button-wrapper> <a class="elementor-button elementor-button-link elementor-size-sm" href=https://arabianethicals.ae/pharma/> <span class=elementor-button-content-wrapper> <span class=elementor-button-icon> <svg xmlns=http://www.w3.org/2000/svg xmlns:xlink=http://www.w3.org/1999/xlink width=512 height=512 x=0 y=0 viewbox="0 0 492.004 492.004" style="enable-background:new 0 0 512 512" xml:space=preserve class=""><g><path d="M484.14 226.886 306.46 49.202c-5.072-5.072-11.832-7.856-19.04-7.856-7.216 0-13.972 2.788-19.044 7.856l-16.132 16.136c-5.068 5.064-7.86 11.828-7.86 19.04 0 7.208 2.792 14.2 7.86 19.264L355.9 207.526H26.58C11.732 207.526 0 219.15 0 234.002v22.812c0 14.852 11.732 27.648 26.58 27.648h330.496L252.248 388.926c-5.068 5.072-7.86 11.652-7.86 18.864 0 7.204 2.792 13.88 7.86 18.948l16.132 16.084c5.072 5.072 11.828 7.836 19.044 7.836 7.208 0 13.968-2.8 19.04-7.872l177.68-177.68c5.084-5.088 7.88-11.88 7.86-19.1.016-7.244-2.776-14.04-7.864-19.12z" fill=#ffffff opacity=1 data-original=#000000></path></g></svg> </span> <span class=elementor-button-text>Read More</span> </span> </a> </div></div></div><div class="elementor-element elementor-element-10ed614 dividhover elementor-widget-divider--view-line elementor-widget elementor-widget-divider" data-id=10ed614 data-element_type=widget data-widget_type=divider.default><div class=elementor-widget-container><div class=elementor-divider> <span class=elementor-divider-separator> </span> </div></div></div></div><div class="elementor-element elementor-element-a4671f0 e-con-full threecol animated-slow e-flex elementor-invisible e-con e-child" data-id=a4671f0 data-element_type=container data-settings='{"background_background":"classic","animation":"fadeInRight","animation_mobile":"fadeIn"}'><div class="elementor-element elementor-element-f31d568 elementor-widget elementor-widget-image" data-id=f31d568 data-element_type=widget data-widget_type=image.default><div class=elementor-widget-container> <img loading=lazy decoding=async width=450 height=447 src=https://arabianethicals.ae/wp-content/uploads/2025/09/image-1.webp class="attachment-large size-large wp-image-3787 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI0NTAiIGhlaWdodD0iNDQ3Ij48L3N2Zz4=" data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/image-1.webp 450w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-1-300x298.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-1-150x150.webp 150w" sizes="(max-width: 450px) 100vw, 450px"><noscript><img loading=lazy decoding=async width=450 height=447 src=https://arabianethicals.ae/wp-content/uploads/2025/09/image-1.webp class="attachment-large size-large wp-image-3787" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/image-1.webp 450w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-1-300x298.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-1-150x150.webp 150w" sizes="(max-width: 450px) 100vw, 450px"></noscript></div></div><div class="elementor-element elementor-element-74625a4 elementor-widget elementor-widget-heading" data-id=74625a4 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">Consumer Health</h2></div></div><div class="elementor-element elementor-element-9581942 elementor-widget elementor-widget-text-editor" data-id=9581942 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Wide market reach within modern trade channels, retail, specialty shops and pharmacies.</p></div></div><div class="elementor-element elementor-element-93ae42e btnserv elementor-widget elementor-widget-button" data-id=93ae42e data-element_type=widget data-widget_type=button.default><div class=elementor-widget-container><div class=elementor-button-wrapper> <a class="elementor-button elementor-button-link elementor-size-sm" href=https://arabianethicals.ae/consumer-health/> <span class=elementor-button-content-wrapper> <span class=elementor-button-icon> <svg xmlns=http://www.w3.org/2000/svg xmlns:xlink=http://www.w3.org/1999/xlink width=512 height=512 x=0 y=0 viewbox="0 0 492.004 492.004" style="enable-background:new 0 0 512 512" xml:space=preserve class=""><g><path d="M484.14 226.886 306.46 49.202c-5.072-5.072-11.832-7.856-19.04-7.856-7.216 0-13.972 2.788-19.044 7.856l-16.132 16.136c-5.068 5.064-7.86 11.828-7.86 19.04 0 7.208 2.792 14.2 7.86 19.264L355.9 207.526H26.58C11.732 207.526 0 219.15 0 234.002v22.812c0 14.852 11.732 27.648 26.58 27.648h330.496L252.248 388.926c-5.068 5.072-7.86 11.652-7.86 18.864 0 7.204 2.792 13.88 7.86 18.948l16.132 16.084c5.072 5.072 11.828 7.836 19.044 7.836 7.208 0 13.968-2.8 19.04-7.872l177.68-177.68c5.084-5.088 7.88-11.88 7.86-19.1.016-7.244-2.776-14.04-7.864-19.12z" fill=#ffffff opacity=1 data-original=#000000></path></g></svg> </span> <span class=elementor-button-text>Read More</span> </span> </a> </div></div></div><div class="elementor-element elementor-element-136b862 dividhover elementor-widget-divider--view-line elementor-widget elementor-widget-divider" data-id=136b862 data-element_type=widget data-widget_type=divider.default><div class=elementor-widget-container><div class=elementor-divider> <span class=elementor-divider-separator> </span> </div></div></div></div><div class="elementor-element elementor-element-7296f1e e-con-full threecol animated-slow e-flex elementor-invisible e-con e-child" data-id=7296f1e data-element_type=container data-settings='{"background_background":"classic","animation":"fadeInRight","animation_mobile":"fadeIn"}'><div class="elementor-element elementor-element-268eb48 elementor-widget elementor-widget-image" data-id=268eb48 data-element_type=widget data-widget_type=image.default><div class=elementor-widget-container> <img loading=lazy decoding=async width=450 height=447 src=https://arabianethicals.ae/wp-content/uploads/2025/09/image.webp class="attachment-large size-large wp-image-3788 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI0NTAiIGhlaWdodD0iNDQ3Ij48L3N2Zz4=" data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/image.webp 450w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-300x298.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-150x150.webp 150w" sizes="(max-width: 450px) 100vw, 450px"><noscript><img loading=lazy decoding=async width=450 height=447 src=https://arabianethicals.ae/wp-content/uploads/2025/09/image.webp class="attachment-large size-large wp-image-3788" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/image.webp 450w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-300x298.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/image-150x150.webp 150w" sizes="(max-width: 450px) 100vw, 450px"></noscript></div></div><div class="elementor-element elementor-element-268f24e elementor-widget elementor-widget-heading" data-id=268f24e data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">Veterinary</h2></div></div><div class="elementor-element elementor-element-3f49147 elementor-widget elementor-widget-text-editor" data-id=3f49147 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container> Expertise in animal health and a preferred partner to farms and animal clinics as well as the veterinary society. </div></div><div class="elementor-element elementor-element-408eccb btnserv elementor-widget elementor-widget-button" data-id=408eccb data-element_type=widget data-widget_type=button.default><div class=elementor-widget-container><div class=elementor-button-wrapper> <a class="elementor-button elementor-button-link elementor-size-sm" href=https://arabianethicals.ae/veterinary/> <span class=elementor-button-content-wrapper> <span class=elementor-button-icon> <svg xmlns=http://www.w3.org/2000/svg xmlns:xlink=http://www.w3.org/1999/xlink width=512 height=512 x=0 y=0 viewbox="0 0 492.004 492.004" style="enable-background:new 0 0 512 512" xml:space=preserve class=""><g><path d="M484.14 226.886 306.46 49.202c-5.072-5.072-11.832-7.856-19.04-7.856-7.216 0-13.972 2.788-19.044 7.856l-16.132 16.136c-5.068 5.064-7.86 11.828-7.86 19.04 0 7.208 2.792 14.2 7.86 19.264L355.9 207.526H26.58C11.732 207.526 0 219.15 0 234.002v22.812c0 14.852 11.732 27.648 26.58 27.648h330.496L252.248 388.926c-5.068 5.072-7.86 11.652-7.86 18.864 0 7.204 2.792 13.88 7.86 18.948l16.132 16.084c5.072 5.072 11.828 7.836 19.044 7.836 7.208 0 13.968-2.8 19.04-7.872l177.68-177.68c5.084-5.088 7.88-11.88 7.86-19.1.016-7.244-2.776-14.04-7.864-19.12z" fill=#ffffff opacity=1 data-original=#000000></path></g></svg> </span> <span class=elementor-button-text>Read More</span> </span> </a> </div></div></div><div class="elementor-element elementor-element-bdf6c58 dividhover elementor-widget-divider--view-line elementor-widget elementor-widget-divider" data-id=bdf6c58 data-element_type=widget data-widget_type=divider.default><div class=elementor-widget-container><div class=elementor-divider> <span class=elementor-divider-separator> </span> </div></div></div></div></div></div></div><div class="elementor-element elementor-element-e7d23b0 e-flex e-con-boxed e-con e-parent" data-id=e7d23b0 data-element_type=container><div class=e-con-inner><div class="elementor-element elementor-element-bc85ff7 elementor-widget elementor-widget-heading" data-id=bc85ff7 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">DISCOVER WHO WE ARE</h2></div></div><div class="elementor-element elementor-element-c1243c7 elementor-widget elementor-widget-html" data-id=c1243c7 data-element_type=widget data-widget_type=html.default><div class=elementor-widget-container><div style="padding:56.25% 0 0 0;position:relative;"><iframe class=wpspeed-lazyload data-wpspeed-lazyload=1 src=about:blank data-src="https://player.vimeo.com/video/1083494711?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479&amp;autoplay=1&amp;muted=1&amp;loop=1" frameborder=0 allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy=strict-origin-when-cross-origin style=position:absolute;top:0;left:0;width:100%;height:100%; title="Arabian Ethicals | Corporate Video"></iframe><noscript><iframe src="https://player.vimeo.com/video/1083494711?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479&amp;autoplay=1&amp;muted=1&amp;loop=1" frameborder=0 allow="autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share" referrerpolicy=strict-origin-when-cross-origin style=position:absolute;top:0;left:0;width:100%;height:100%; title="Arabian Ethicals | Corporate Video"></iframe></noscript></div></div></div></div></div><div class="elementor-element elementor-element-358efc4 e-con-full e-flex e-con e-parent" data-id=358efc4 data-element_type=container><div class="elementor-element elementor-element-ba9336b e-con-full e-flex e-con e-child" data-id=ba9336b data-element_type=container><div class="elementor-element elementor-element-1cffed2 elementor-widget elementor-widget-heading" data-id=1cffed2 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">OUR PARTNERS</h2></div></div><div class="elementor-element elementor-element-d8a1b4f elementor-widget elementor-widget-text-editor" data-id=d8a1b4f data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>With a legacy of crafting collaborative opportunities which inspire growth, expansion and market-leadership, Arabian Ethicals takes pride in building long-lasting partnerships with global multinationals.</p></div></div><div class="elementor-element elementor-element-11f7a1a e-con-full e-flex e-con e-child" data-id=11f7a1a data-element_type=container><div class="elementor-element elementor-element-04899d9 elementor-widget elementor-widget-image-carousel" data-id=04899d9 data-element_type=widget data-settings='{"slides_to_show":"7","slides_to_scroll_mobile":"1","navigation":"none","image_spacing_custom":{"unit":"px","size":45,"sizes":[]},"image_spacing_custom_mobile":{"unit":"px","size":58,"sizes":[]},"slides_to_scroll":"1","slides_to_show_mobile":"2","autoplay_speed":1000,"autoplay":"yes","pause_on_hover":"yes","pause_on_interaction":"yes","infinite":"yes","speed":500,"image_spacing_custom_tablet":{"unit":"px","size":"","sizes":[]}}' data-widget_type=image-carousel.default><div class=elementor-widget-container><div class="elementor-image-carousel-wrapper swiper" dir=ltr><div class="elementor-image-carousel swiper-wrapper" aria-live=off><div class=swiper-slide role=group aria-roledescription=slide aria-label="1 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/cbd6eacd3b6446314364afb6183a82228650e710.webp alt=LOGO-ACINO data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/cbd6eacd3b6446314364afb6183a82228650e710.webp alt=LOGO-ACINO data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="2 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/7a06d2b90993d2456093ea5070149b74d9bdd431.webp alt=LOGO-AJANTA-PHARMA-03 data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/7a06d2b90993d2456093ea5070149b74d9bdd431.webp alt=LOGO-AJANTA-PHARMA-03 data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="3 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/3ecd29911f25a9f52932c86e33ff2e7088a307bf.webp alt=LOGO-ALS data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/3ecd29911f25a9f52932c86e33ff2e7088a307bf.webp alt=LOGO-ALS data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="4 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/aba9b2cc6ff18fc390ad7eb893575c6c3bc9ed2e.webp alt=LOGO-API data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/aba9b2cc6ff18fc390ad7eb893575c6c3bc9ed2e.webp alt=LOGO-API data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="5 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/b7d5b4aaa3b136dfaacbf072523ffc17c20094f1.webp alt=LOGO-ANNORA data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/b7d5b4aaa3b136dfaacbf072523ffc17c20094f1.webp alt=LOGO-ANNORA data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="6 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/6aaa17712f7593c40012e213135f4e516acfd37d.webp alt=LOGO-BENTA-GROUP data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/6aaa17712f7593c40012e213135f4e516acfd37d.webp alt=LOGO-BENTA-GROUP data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="7 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/fa9ebd2d24924afa774e2719dbbc6200531a54a0.webp alt=LOGO-BENTA-PHARMA-INDUSTRIES data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/fa9ebd2d24924afa774e2719dbbc6200531a54a0.webp alt=LOGO-BENTA-PHARMA-INDUSTRIES data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="8 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/67b8d67e7487229afc546c42406f850f61438733.webp alt=LOGO-CHANELLE-PHARMA data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/67b8d67e7487229afc546c42406f850f61438733.webp alt=LOGO-CHANELLE-PHARMA data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="9 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/d286d335994fef8bf5c67980fb714bba9195e077.webp alt=LOGO-DONGBANG data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/d286d335994fef8bf5c67980fb714bba9195e077.webp alt=LOGO-DONGBANG data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="10 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/4fd56199aad883f8dfdca6f16374d7bbe9e7b61b.webp alt=LOGO-ELANCO data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/4fd56199aad883f8dfdca6f16374d7bbe9e7b61b.webp alt=LOGO-ELANCO data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="11 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/570c1c20959c7db575a47e837a6e413937d996aa.webp alt=LOGO-FERRING data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/570c1c20959c7db575a47e837a6e413937d996aa.webp alt=LOGO-FERRING data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="12 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/8ca65216127fee84e0109957b3746db64261b672.webp alt=LOGO-HIMALAYA-DRUG-COMPANY data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/8ca65216127fee84e0109957b3746db64261b672.webp alt=LOGO-HIMALAYA-DRUG-COMPANY data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="13 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/48ebf664b0f2c9cd91b437d7ccb38e8f19d06728.webp alt=LOGO-KAESLER-NUTRITION data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/48ebf664b0f2c9cd91b437d7ccb38e8f19d06728.webp alt=LOGO-KAESLER-NUTRITION data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="14 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/334ab133452b3409923a19a1142c1160f37a0dd4.webp alt=LOGO-LIPTIS-PHARMACEUTICALS data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/334ab133452b3409923a19a1142c1160f37a0dd4.webp alt=LOGO-LIPTIS-PHARMACEUTICALS data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="15 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/9cf0bcbdfacc3f978b9c3e33f7f530adf9c474e1.webp alt=LOGO-MEDICHEMIE data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/9cf0bcbdfacc3f978b9c3e33f7f530adf9c474e1.webp alt=LOGO-MEDICHEMIE data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="16 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/1615d8fc5547f8c6447693a81059566bdf045a61.webp alt=LOGO-MEDPHARMA data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/1615d8fc5547f8c6447693a81059566bdf045a61.webp alt=LOGO-MEDPHARMA data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="17 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/1cf62644ac88fe9fb3627d8f1103192cfe4604f2.webp alt=LOGO-MERCK-KGAA data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/1cf62644ac88fe9fb3627d8f1103192cfe4604f2.webp alt=LOGO-MERCK-KGAA data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="18 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/d90a9f7fa9260ff57c31700c7064697136186e64.webp alt=LOGO-MESOESTETIC data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/d90a9f7fa9260ff57c31700c7064697136186e64.webp alt=LOGO-MESOESTETIC data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="19 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/f5f0423ae81b87b7acd7a7e00c93695f68878160.webp alt=LOGO-NERHADOU data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/f5f0423ae81b87b7acd7a7e00c93695f68878160.webp alt=LOGO-NERHADOU data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="20 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/ad7b1201798d3f3b1f824bfe6cd9961135c010cc.webp alt=LOGO-NORBROOK data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/ad7b1201798d3f3b1f824bfe6cd9961135c010cc.webp alt=LOGO-NORBROOK data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="21 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/1e3895627dbc48a655463b14148a3b1adb74d6f3.webp alt=LOGO-NUK data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/1e3895627dbc48a655463b14148a3b1adb74d6f3.webp alt=LOGO-NUK data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="22 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=https://arabianethicals.ae/wp-content/uploads/2024/11/LOGO-PERRIGO-1.png alt=LOGO-PERRIGO data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=https://arabianethicals.ae/wp-content/uploads/2024/11/LOGO-PERRIGO-1.png alt=LOGO-PERRIGO data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="23 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/006210ffaa81f2d1fa92fdd85415a1ac5435d3e5.webp alt=LOGO-PHARMA-SCIENCE data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/006210ffaa81f2d1fa92fdd85415a1ac5435d3e5.webp alt=LOGO-PHARMA-SCIENCE data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="24 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/e7d334809d3cd23c198a849902475a983b5226f7.webp alt=LOGO-PRISTOL data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/e7d334809d3cd23c198a849902475a983b5226f7.webp alt=LOGO-PRISTOL data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="25 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/cb7e87ec38861265822dae525977ac342a4f2466.webp alt=LOGO-SANDOZ data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/cb7e87ec38861265822dae525977ac342a4f2466.webp alt=LOGO-SANDOZ data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="26 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/f03ee1013a320202ceb14a3ae67b5265ae788cb7.webp alt=LOGO-UNITED-PHARMA data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/f03ee1013a320202ceb14a3ae67b5265ae788cb7.webp alt=LOGO-UNITED-PHARMA data-width=158 data-height=51></noscript></figure></div><div class=swiper-slide role=group aria-roledescription=slide aria-label="27 of 27"><figure class=swiper-slide-inner><img decoding=async class="swiper-slide-image wpspeed-lazyload" data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNTgiIGhlaWdodD0iNTEiPjwvc3ZnPg==" data-src=/wp-content/cache/wpspeed/images/e0ba5421cd1b8d71473c9805ee8926482be024cf.webp alt=uvedco data-width=158 data-height=51><noscript><img decoding=async class=swiper-slide-image src=/wp-content/cache/wpspeed/images/e0ba5421cd1b8d71473c9805ee8926482be024cf.webp alt=uvedco data-width=158 data-height=51></noscript></figure></div></div></div></div></div></div><div class="elementor-element elementor-element-5413508 elementor-invisible elementor-widget elementor-widget-text-editor" data-id=5413508 data-element_type=widget data-settings='{"_animation":"fadeInUp"}' data-widget_type=text-editor.default><div class=elementor-widget-container><p>Building on our vision for the future, Arabian Ethicals welcomes potential partnerships with progressive principals delivering innovative products and services that meet the growing healthcare needs of the UAE&rsquo;s public and private sectors.</p></div></div></div></div><div class="elementor-element elementor-element-c295114 e-con-full e-flex e-con e-parent" data-id=c295114 data-element_type=container><div class="elementor-element elementor-element-aa8179d e-con-full e-flex e-con e-child" data-id=aa8179d data-element_type=container><div class="elementor-element elementor-element-25e93ae elementor-widget elementor-widget-image" data-id=25e93ae data-element_type=widget data-widget_type=image.default><div class=elementor-widget-container> <img loading=lazy decoding=async width=1280 height=960 src=https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo.webp class="attachment-full size-full wp-image-3789 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMjgwIiBoZWlnaHQ9Ijk2MCI+PC9zdmc+ data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo.webp 1280w, https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo-300x225.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo-1024x768.webp 1024w, https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo-768x576.webp 768w" sizes="(max-width: 1280px) 100vw, 1280px"><noscript><img loading=lazy decoding=async width=1280 height=960 src=https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo.webp class="attachment-full size-full wp-image-3789" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo.webp 1280w, https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo-300x225.webp 300w, https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo-1024x768.webp 1024w, https://arabianethicals.ae/wp-content/uploads/2025/09/external-warehouse-photo-768x576.webp 768w" sizes="(max-width: 1280px) 100vw, 1280px"></noscript></div></div></div><div class="elementor-element elementor-element-4a958c4 e-con-full e-flex e-con e-child" data-id=4a958c4 data-element_type=container><div class="elementor-element elementor-element-045921c elementor-widget elementor-widget-heading" data-id=045921c data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">OUR FACILITIES</h2></div></div><div class="elementor-element elementor-element-60b91a6 elementor-widget elementor-widget-text-editor" data-id=60b91a6 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Arabian Ethicals operates agile and adaptable facilities, strategically equipped to manage the growing complexities of pharmaceutical distribution with efficiency and reliability.</p></div></div><div class="elementor-element elementor-element-b52748f dividhover elementor-widget-divider--view-line elementor-widget elementor-widget-divider" data-id=b52748f data-element_type=widget data-widget_type=divider.default><div class=elementor-widget-container><div class=elementor-divider> <span class=elementor-divider-separator> </span> </div></div></div><div class="elementor-element elementor-element-e927fa3 elementor-widget elementor-widget-n-accordion" data-id=e927fa3 data-element_type=widget data-settings='{"default_state":"expanded","max_items_expended":"one","n_accordion_animation_duration":{"unit":"ms","size":400,"sizes":[]}}' data-widget_type=nested-accordion.default><div class=elementor-widget-container><div class=e-n-accordion aria-label="Accordion. Open links with Enter or Space, close with Escape, and navigate with Arrow Keys"> <details id=e-n-accordion-item-2440 class=e-n-accordion-item open> <summary class=e-n-accordion-item-title data-accordion-index=1 tabindex=0 aria-expanded=true aria-controls=e-n-accordion-item-2440> <span class=e-n-accordion-item-title-header><div class=e-n-accordion-item-title-text> Strategic Location </div></span> <span class=e-n-accordion-item-title-icon> <span class=e-opened><svg xmlns=http://www.w3.org/2000/svg width=24 height=24 viewbox="0 0 24 24" fill=none><rect width=24 height=24 rx=10.0645 fill=#0857DE></rect><g clip-path=url('/#clip0_1_8')><path fill-rule=evenodd clip-rule=evenodd d="M11.4496 15.6054L7.06994 11.2258L8.16465 10.1311L11.9969 13.9634L15.8292 10.1311L16.9239 11.2258L12.5443 15.6054C12.3991 15.7506 12.2022 15.8321 11.9969 15.8321C11.7916 15.8321 11.5947 15.7506 11.4496 15.6054Z" fill=white></path></g><defs><clippath id=clip0_1_8><rect width=9.29032 height=18.5806 fill=white transform="translate(21.2903 7.74194) rotate(90)"></rect></clippath></defs></svg></span> <span class=e-closed><svg xmlns=http://www.w3.org/2000/svg width=24 height=24 viewbox="0 0 24 24" fill=none><rect width=24 height=24 rx=10.0645 fill=#042B6F></rect><path fill-rule=evenodd clip-rule=evenodd d="M15.2183 12.9375L10.8387 17.3172L9.744 16.2225L13.5763 12.3902L9.744 8.55794L10.8387 7.46323L15.2183 11.8428C15.3635 11.988 15.445 12.1849 15.445 12.3902C15.445 12.5955 15.3635 12.7924 15.2183 12.9375Z" fill=white></path></svg></span> </span> </summary><div role=region aria-labelledby=e-n-accordion-item-2440 class="elementor-element elementor-element-a510b7b e-con-full e-flex e-con e-child" data-id=a510b7b data-element_type=container><div class="elementor-element elementor-element-7230191 elementor-widget elementor-widget-text-editor" data-id=7230191 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Strategically headquartered in Dubai Silicon Oasis, our facilities extend unparalleled connectivity and accessibility with proximity to major transportation networks, including Dubai International Airport and Jebel Ali Port. This prime location allows Arabian Ethicals to optimize its distribution channels, reducing lead times as well as improving overall supply chain efficiency.</p></div></div></div></details> <details id=e-n-accordion-item-2441 class=e-n-accordion-item> <summary class=e-n-accordion-item-title data-accordion-index=2 tabindex=-1 aria-expanded=false aria-controls=e-n-accordion-item-2441> <span class=e-n-accordion-item-title-header><div class=e-n-accordion-item-title-text> State-of-the-Art Facilities with Enhanced Capacity </div></span> <span class=e-n-accordion-item-title-icon> <span class=e-opened><svg xmlns=http://www.w3.org/2000/svg width=24 height=24 viewbox="0 0 24 24" fill=none><rect width=24 height=24 rx=10.0645 fill=#0857DE></rect><g clip-path=url('/#clip0_1_8')><path fill-rule=evenodd clip-rule=evenodd d="M11.4496 15.6054L7.06994 11.2258L8.16465 10.1311L11.9969 13.9634L15.8292 10.1311L16.9239 11.2258L12.5443 15.6054C12.3991 15.7506 12.2022 15.8321 11.9969 15.8321C11.7916 15.8321 11.5947 15.7506 11.4496 15.6054Z" fill=white></path></g><defs><clippath id=clip0_1_8><rect width=9.29032 height=18.5806 fill=white transform="translate(21.2903 7.74194) rotate(90)"></rect></clippath></defs></svg></span> <span class=e-closed><svg xmlns=http://www.w3.org/2000/svg width=24 height=24 viewbox="0 0 24 24" fill=none><rect width=24 height=24 rx=10.0645 fill=#042B6F></rect><path fill-rule=evenodd clip-rule=evenodd d="M15.2183 12.9375L10.8387 17.3172L9.744 16.2225L13.5763 12.3902L9.744 8.55794L10.8387 7.46323L15.2183 11.8428C15.3635 11.988 15.445 12.1849 15.445 12.3902C15.445 12.5955 15.3635 12.7924 15.2183 12.9375Z" fill=white></path></svg></span> </span> </summary><div role=region aria-labelledby=e-n-accordion-item-2441 class="elementor-element elementor-element-4bb8c00 e-con-full e-flex e-con e-child" data-id=4bb8c00 data-element_type=container><div class="elementor-element elementor-element-d3f326e elementor-widget elementor-widget-text-editor" data-id=d3f326e data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>We operate from light industrial units (LIUs) that span a total of 5,700 square meters, delivering enhanced operational efficiencies and innovations, including climate-controlled environments to ensure the integrity and safety of pharmaceutical products. Our warehousing LIUs also feature automated inventory management systems which streamline the supply chain process and ensure timely and accurate deliveries.</p></div></div></div></details> <details id=e-n-accordion-item-2442 class=e-n-accordion-item> <summary class=e-n-accordion-item-title data-accordion-index=3 tabindex=-1 aria-expanded=false aria-controls=e-n-accordion-item-2442> <span class=e-n-accordion-item-title-header><div class=e-n-accordion-item-title-text> The Highest Standards of Safety and Compliance </div></span> <span class=e-n-accordion-item-title-icon> <span class=e-opened><svg xmlns=http://www.w3.org/2000/svg width=24 height=24 viewbox="0 0 24 24" fill=none><rect width=24 height=24 rx=10.0645 fill=#0857DE></rect><g clip-path=url('/#clip0_1_8')><path fill-rule=evenodd clip-rule=evenodd d="M11.4496 15.6054L7.06994 11.2258L8.16465 10.1311L11.9969 13.9634L15.8292 10.1311L16.9239 11.2258L12.5443 15.6054C12.3991 15.7506 12.2022 15.8321 11.9969 15.8321C11.7916 15.8321 11.5947 15.7506 11.4496 15.6054Z" fill=white></path></g><defs><clippath id=clip0_1_8><rect width=9.29032 height=18.5806 fill=white transform="translate(21.2903 7.74194) rotate(90)"></rect></clippath></defs></svg></span> <span class=e-closed><svg xmlns=http://www.w3.org/2000/svg width=24 height=24 viewbox="0 0 24 24" fill=none><rect width=24 height=24 rx=10.0645 fill=#042B6F></rect><path fill-rule=evenodd clip-rule=evenodd d="M15.2183 12.9375L10.8387 17.3172L9.744 16.2225L13.5763 12.3902L9.744 8.55794L10.8387 7.46323L15.2183 11.8428C15.3635 11.988 15.445 12.1849 15.445 12.3902C15.445 12.5955 15.3635 12.7924 15.2183 12.9375Z" fill=white></path></svg></span> </span> </summary><div role=region aria-labelledby=e-n-accordion-item-2442 class="elementor-element elementor-element-020807d e-con-full e-flex e-con e-child" data-id=020807d data-element_type=container><div class="elementor-element elementor-element-b6ff7db elementor-widget elementor-widget-text-editor" data-id=b6ff7db data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Our facilities are also a testament to our commitment to sustainability, incorporating eco-friendly features such as energy-efficient lighting, waste reduction systems, and water conservation measures, which align with our broader environmental goals.</p></div></div></div></details> </div> <script type=application/ld+json>{"@context":"https:\/\/schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Strategic Location","acceptedAnswer":{"@type":"Answer","text":"Strategically headquartered in Dubai Silicon Oasis, our facilities extend unparalleled connectivity and accessibility with proximity to major transportation networks, including Dubai International Airport and Jebel Ali Port. This prime location allows Arabian Ethicals to optimize its distribution channels, reducing lead times as well as improving overall supply chain efficiency."}},{"@type":"Question","name":"State-of-the-Art Facilities with Enhanced Capacity","acceptedAnswer":{"@type":"Answer","text":"We operate from light industrial units (LIUs) that span a total of 5,700 square meters, delivering enhanced operational efficiencies and innovations, including climate-controlled environments to ensure the integrity and safety of pharmaceutical products. Our warehousing LIUs also feature automated inventory management systems which streamline the supply chain process and ensure timely and accurate deliveries."}},{"@type":"Question","name":"The Highest Standards of Safety and Compliance","acceptedAnswer":{"@type":"Answer","text":"Our facilities are also a testament to our commitment to sustainability, incorporating eco-friendly features such as energy-efficient lighting, waste reduction systems, and water conservation measures, which align with our broader environmental goals."}}]}</script> </div> </div> </div> </div><div class="elementor-element elementor-element-9722f0c e-con-full e-flex e-con e-parent" data-id=9722f0c data-element_type=container><div class="elementor-element elementor-element-7ae42bc e-con-full e-flex e-con e-child" data-id=7ae42bc data-element_type=container data-settings='{"background_background":"classic"}'><div class="elementor-element elementor-element-1aea721 e-con-full e-flex e-con e-child" data-id=1aea721 data-element_type=container><div class="elementor-element elementor-element-aabef23 elementor-widget elementor-widget-heading" data-id=aabef23 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">Your Trusted Partner in Pharmaceutical Distribution in the UAE</h2></div></div><div class="elementor-element elementor-element-3c30673 elementor-widget elementor-widget-text-editor" data-id=3c30673 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Arabian Ethicals was established in 1977 to deliver specialized premium pharmaceuticals, veterinary medicines, consumer care and cosmetic solutions to the UAE&rsquo;s growing and evolving Healthcare Industry.</p></div></div><div class="elementor-element elementor-element-c1c1ade elementor-hidden-desktop elementor-hidden-tablet elementor-hidden-mobile elementor-widget elementor-widget-html" data-id=c1c1ade data-element_type=widget data-widget_type=html.default><div class=elementor-widget-container><meta charset=UTF-8><meta name=viewport content="width=device-width, initial-scale=1.0"><title>Button with Arrow</title><div class=button-container> <a href=https://arabianethicals.ae/about-us/ target=_blank style="text-decoration: none;"> <button class=learn-more-button> Learn More <span class=arrow-box> <img decoding=async data-wpspeed-lazyload=1 src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxIiBoZWlnaHQ9IjEiPjwvc3ZnPg==" data-src=https://arabianethicals.ae/wp-content/uploads/2024/12/right-arrow-1.svg alt="Arrow Icon" class="arrow-icon wpspeed-lazyload"><noscript><img decoding=async src=https://arabianethicals.ae/wp-content/uploads/2024/12/right-arrow-1.svg alt="Arrow Icon" class=arrow-icon></noscript></span> </button> </a> </div> <script src=/wp-content/cache/wpspeed/js/0777ae78f92ca557f3091e9d630bf9d4.js async></script> </div> </div> </div><div class="elementor-element elementor-element-131078a e-con-full e-flex elementor-invisible e-con e-child" data-id=131078a data-element_type=container data-settings='{"background_background":"classic","animation":"fadeInRight","animation_mobile":"fadeIn"}'><div class="elementor-element elementor-element-4d8c509 elementor-widget elementor-widget-heading" data-id=4d8c509 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">Get in Touch</h2></div></div><div class="elementor-element elementor-element-53bda4d elementor-widget elementor-widget-text-editor" data-id=53bda4d data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Fill out the form below to connect with us and explore how we can support your needs.</p></div></div><div class="elementor-element elementor-element-53ea133 elementor-button-align-start elementor-widget elementor-widget-form" data-id=53ea133 data-element_type=widget data-settings='{"step_next_label":"Next","step_previous_label":"Previous","step_type":"number_text","step_icon_shape":"circle"}' data-widget_type=form.default><div class=elementor-widget-container><form class=elementor-form method=post name="New Form"> <input type=hidden name=post_id value=8> <input type=hidden name=form_id value=53ea133> <input type=hidden name=referer_title value="Home - Arabian Ethical"> <input type=hidden name=queried_id value=8> <div class="elementor-form-fields-wrapper elementor-labels-above"><div class="elementor-field-type-text elementor-field-group elementor-column elementor-field-group-name elementor-col-50 elementor-field-required"> <input size=1 type=text name=form_fields[name] id=form-field-name class="elementor-field elementor-size-md  elementor-field-textual" placeholder=Name* required=required aria-required=true> </div><div class="elementor-field-type-email elementor-field-group elementor-column elementor-field-group-email elementor-col-50 elementor-field-required"> <input size=1 type=email name=form_fields[email] id=form-field-email class="elementor-field elementor-size-md  elementor-field-textual" placeholder=Email* required=required aria-required=true> </div><div class="elementor-field-type-select elementor-field-group elementor-column elementor-field-group-field_c9018c2 elementor-col-50 elementor-field-required"><div class="elementor-field elementor-select-wrapper remove-before "><div class=select-caret-down-wrapper> <svg aria-hidden=true class="e-font-icon-svg e-eicon-caret-down" viewbox="0 0 571.4 571.4" xmlns=http://www.w3.org/2000/svg><path d="M571 393Q571 407 561 418L311 668Q300 679 286 679T261 668L11 418Q0 407 0 393T11 368 36 357H536Q550 357 561 368T571 393Z"></path></svg> </div> <select name=form_fields[field_c9018c2] id=form-field-field_c9018c2 class="elementor-field-textual elementor-size-md" required=required aria-required=true> <option value="General Inquiry">General Inquiry</option> <option value="Investor Relations">Investor Relations</option> <option value="Media Relations">Media Relations</option> <option value="Website Feedback">Website Feedback</option> <option value="Education &amp; Internship Opportunities">Education &amp; Internship Opportunities</option> </select> </div></div><div class="elementor-field-type-tel elementor-field-group elementor-column elementor-field-group-field_44c7b47 elementor-col-50 elementor-field-required"> <input size=1 type=tel name=form_fields[field_44c7b47] id=form-field-field_44c7b47 class="elementor-field elementor-size-md  elementor-field-textual" placeholder=Phone* required=required aria-required=true pattern="[0-9()#&amp;+*-=.]+" title="Only numbers and phone characters (#, -, *, etc) are accepted."> </div><div class="elementor-field-type-textarea elementor-field-group elementor-column elementor-field-group-message elementor-col-100 elementor-field-required"> <textarea class="elementor-field-textual elementor-field  elementor-size-md" name=form_fields[message] id=form-field-message rows=4 placeholder=Message* required=required aria-required=true></textarea> </div><div class="elementor-field-group elementor-column elementor-field-type-submit elementor-col-100 e-form__buttons"> <button class="elementor-button elementor-size-sm" type=submit id=read-more-btn> <span class=elementor-button-content-wrapper> <span class=elementor-button-icon> <svg xmlns=http://www.w3.org/2000/svg xmlns:xlink=http://www.w3.org/1999/xlink width=512 height=512 x=0 y=0 viewbox="0 0 492.004 492.004" style="enable-background:new 0 0 512 512" xml:space=preserve class=""><g><path d="M484.14 226.886 306.46 49.202c-5.072-5.072-11.832-7.856-19.04-7.856-7.216 0-13.972 2.788-19.044 7.856l-16.132 16.136c-5.068 5.064-7.86 11.828-7.86 19.04 0 7.208 2.792 14.2 7.86 19.264L355.9 207.526H26.58C11.732 207.526 0 219.15 0 234.002v22.812c0 14.852 11.732 27.648 26.58 27.648h330.496L252.248 388.926c-5.068 5.072-7.86 11.652-7.86 18.864 0 7.204 2.792 13.88 7.86 18.948l16.132 16.084c5.072 5.072 11.828 7.836 19.044 7.836 7.208 0 13.968-2.8 19.04-7.872l177.68-177.68c5.084-5.088 7.88-11.88 7.86-19.1.016-7.244-2.776-14.04-7.864-19.12z" fill=#ffffff opacity=1 data-original=#000000></path></g></svg> </span> <span class=elementor-button-text>Submit Form</span> </span> </button> </div> </div> </form> </div> </div> </div> </div> </div><div class="elementor-element elementor-element-6326911 e-con-full e-flex e-con e-parent" data-id=6326911 data-element_type=container><div class="elementor-element elementor-element-4ba7048 e-con-full e-flex e-con e-child" data-id=4ba7048 data-element_type=container><div class="elementor-element elementor-element-c3fe45d elementor-widget elementor-widget-heading" data-id=c3fe45d data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">MEDIA CENTER</h2></div></div><div class="elementor-element elementor-element-151b873 e-con-full e-flex e-con e-child" data-id=151b873 data-element_type=container><div class="elementor-element elementor-element-0192c9f elementor-hidden-desktop elementor-hidden-tablet elementor-hidden-mobile elementor-grid-3 elementor-grid-tablet-2 elementor-grid-mobile-1 elementor-posts--thumbnail-top elementor-widget elementor-widget-posts" data-id=0192c9f data-element_type=widget data-settings='{"classic_columns":"3","classic_columns_tablet":"2","classic_columns_mobile":"1","classic_row_gap":{"unit":"px","size":35,"sizes":[]},"classic_row_gap_tablet":{"unit":"px","size":"","sizes":[]},"classic_row_gap_mobile":{"unit":"px","size":"","sizes":[]}}' data-widget_type=posts.classic><div class=elementor-widget-container><div class="elementor-posts-container elementor-posts elementor-posts--skin-classic elementor-grid"><article class="elementor-post elementor-grid-item post-3556 post type-post status-publish format-standard has-post-thumbnail hentry category-press-release"> <a class=elementor-post__thumbnail__link href=https://arabianethicals.ae/arabian-ethicals-debuts-nuks-perfect-match-line-at-baby-expo-2025/ tabindex=-1 target='"_blank"'><div class=elementor-post__thumbnail><img loading=lazy decoding=async width=1600 height=1125 src=/wp-content/cache/wpspeed/images/563cd70c50973234cbfea62338cfdcc7981e9487.webp class="attachment-full size-full wp-image-3560 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNjAwIiBoZWlnaHQ9IjExMjUiPjwvc3ZnPg==" data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4.jpg 1600w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-300x211.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-1024x720.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-768x540.jpg 768w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-1536x1080.jpg 1536w" sizes="(max-width: 1600px) 100vw, 1600px"><noscript><img loading=lazy decoding=async width=1600 height=1125 src=/wp-content/cache/wpspeed/images/563cd70c50973234cbfea62338cfdcc7981e9487.webp class="attachment-full size-full wp-image-3560" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4.jpg 1600w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-300x211.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-1024x720.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-768x540.jpg 768w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-1536x1080.jpg 1536w" sizes="(max-width: 1600px) 100vw, 1600px"></noscript></div></a> <div class=elementor-post__text><h3 class=elementor-post__title> <a href=https://arabianethicals.ae/arabian-ethicals-debuts-nuks-perfect-match-line-at-baby-expo-2025/ target='"_blank"'> Arabian Ethicals Debuts NUK&rsquo;s Perfect Match line at Baby Expo 2025 </a> </h3><div class=elementor-post__meta-data> <span class=elementor-post-author> arabian </span> <span class=elementor-post-date> May 23, 2025 </span> </div><div class=elementor-post__excerpt><p>Arabian Ethicals proudly participated in Baby Expo 2025, the Middle East&rsquo;s largest maternity, baby, and toddler event, held at the Dubai World Trade Centre from</p></div><div class=elementor-post__read-more-wrapper> <a class=elementor-post__read-more href=https://arabianethicals.ae/arabian-ethicals-debuts-nuks-perfect-match-line-at-baby-expo-2025/ aria-label="Read more about Arabian Ethicals Debuts NUK&rsquo;s Perfect Match line at Baby Expo 2025" tabindex=-1 target=_blank> Read More </a> </div></div></article><article class="elementor-post elementor-grid-item post-3562 post type-post status-publish format-standard has-post-thumbnail hentry category-press-release"> <a class=elementor-post__thumbnail__link href=https://arabianethicals.ae/arabian-ethicals-represents-leading-womens-health-brands-at-mego-2025/ tabindex=-1 target='"_blank"'><div class=elementor-post__thumbnail><img loading=lazy decoding=async width=1280 height=960 src=/wp-content/cache/wpspeed/images/7031329b77a2997e950b913f7f2fb826298d60cb.webp class="attachment-full size-full wp-image-3558 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMjgwIiBoZWlnaHQ9Ijk2MCI+PC9zdmc+ data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3.jpg 1280w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-300x225.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-1024x768.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-768x576.jpg 768w" sizes="(max-width: 1280px) 100vw, 1280px"><noscript><img loading=lazy decoding=async width=1280 height=960 src=/wp-content/cache/wpspeed/images/7031329b77a2997e950b913f7f2fb826298d60cb.webp class="attachment-full size-full wp-image-3558" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3.jpg 1280w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-300x225.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-1024x768.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-768x576.jpg 768w" sizes="(max-width: 1280px) 100vw, 1280px"></noscript></div></a> <div class=elementor-post__text><h3 class=elementor-post__title> <a href=https://arabianethicals.ae/arabian-ethicals-represents-leading-womens-health-brands-at-mego-2025/ target='"_blank"'> Arabian Ethicals Represents Leading Women&rsquo;s Health Brands at MEGO 2025 </a> </h3><div class=elementor-post__meta-data> <span class=elementor-post-author> arabian </span> <span class=elementor-post-date> May 9, 2025 </span> </div><div class=elementor-post__excerpt><p>Arabian Ethicals was proud to participate in the Middle East Obstetrics and Gynecology Conference (MEGO 2025), one of the region&rsquo;s most recognized gatherings focused on</p></div><div class=elementor-post__read-more-wrapper> <a class=elementor-post__read-more href=https://arabianethicals.ae/arabian-ethicals-represents-leading-womens-health-brands-at-mego-2025/ aria-label="Read more about Arabian Ethicals Represents Leading Women&rsquo;s Health Brands at MEGO 2025" tabindex=-1 target=_blank> Read More </a> </div></div></article><article class="elementor-post elementor-grid-item post-3564 post type-post status-publish format-standard has-post-thumbnail hentry category-press-release"> <a class=elementor-post__thumbnail__link href=https://arabianethicals.ae/arabian-ethicals-showcases-healthcare-commitment-at-icpm-2025/ tabindex=-1 target='"_blank"'><div class=elementor-post__thumbnail><img loading=lazy decoding=async width=1600 height=1200 src=/wp-content/cache/wpspeed/images/00e2bd9945c3440604ec930e6fe37bee5a6d0089.webp class="attachment-full size-full wp-image-3557 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNjAwIiBoZWlnaHQ9IjEyMDAiPjwvc3ZnPg==" data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2.jpg 1600w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-300x225.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-1024x768.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-768x576.jpg 768w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-1536x1152.jpg 1536w" sizes="(max-width: 1600px) 100vw, 1600px"><noscript><img loading=lazy decoding=async width=1600 height=1200 src=/wp-content/cache/wpspeed/images/00e2bd9945c3440604ec930e6fe37bee5a6d0089.webp class="attachment-full size-full wp-image-3557" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2.jpg 1600w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-300x225.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-1024x768.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-768x576.jpg 768w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-1536x1152.jpg 1536w" sizes="(max-width: 1600px) 100vw, 1600px"></noscript></div></a> <div class=elementor-post__text><h3 class=elementor-post__title> <a href=https://arabianethicals.ae/arabian-ethicals-showcases-healthcare-commitment-at-icpm-2025/ target='"_blank"'> Arabian Ethicals Showcases Healthcare Commitment at ICPM 2025 </a> </h3><div class=elementor-post__meta-data> <span class=elementor-post-author> arabian </span> <span class=elementor-post-date> January 28, 2025 </span> </div><div class=elementor-post__excerpt><p>Arabian Ethicals joined the International Conference on Pharmacy and Medicine (ICPM), held in sharjah research technology &amp; innovation park from the 21th-23th January 2025. The</p></div><div class=elementor-post__read-more-wrapper> <a class=elementor-post__read-more href=https://arabianethicals.ae/arabian-ethicals-showcases-healthcare-commitment-at-icpm-2025/ aria-label="Read more about Arabian Ethicals Showcases Healthcare Commitment at ICPM 2025" tabindex=-1 target=_blank> Read More </a> </div></div></article></div></div></div><div class="elementor-element elementor-element-0658592 elementor-widget elementor-widget-shortcode" data-id=0658592 data-element_type=widget data-widget_type=shortcode.default><div class=elementor-widget-container><div class=elementor-shortcode><div class=custom-news-grid><div class=news-item><div class=news-image> <a href=https://arabianethicals.ae/arabian-ethicals-debuts-nuks-perfect-match-line-at-baby-expo-2025/> <img loading=lazy decoding=async width=1600 height=1125 src=/wp-content/cache/wpspeed/images/563cd70c50973234cbfea62338cfdcc7981e9487.webp class="attachment-full size-full wp-post-image wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNjAwIiBoZWlnaHQ9IjExMjUiPjwvc3ZnPg==" data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4.jpg 1600w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-300x211.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-1024x720.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-768x540.jpg 768w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-1536x1080.jpg 1536w" sizes="(max-width: 1600px) 100vw, 1600px"><noscript><img loading=lazy decoding=async width=1600 height=1125 src=/wp-content/cache/wpspeed/images/563cd70c50973234cbfea62338cfdcc7981e9487.webp class="attachment-full size-full wp-post-image" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4.jpg 1600w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-300x211.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-1024x720.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-768x540.jpg 768w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-Baby-Expo-Report-4-1536x1080.jpg 1536w" sizes="(max-width: 1600px) 100vw, 1600px"></noscript></a> </div><div class=news-meta><div class=news-date>May 23, 2025</div></div><h3 class=news-title>Arabian Ethicals Debuts NUK&rsquo;s Perfect Match line at Baby Expo 2025</h3><p class=news-excerpt>Arabian Ethicals proudly participated in Baby Expo 2025, the Middle East&rsquo;s largest maternity, baby, and toddler event, held&hellip;</p> <a href=https://arabianethicals.ae/arabian-ethicals-debuts-nuks-perfect-match-line-at-baby-expo-2025/ class=read-more-btn>Read More</a> </div><div class=news-item><div class=news-image> <a href=https://arabianethicals.ae/arabian-ethicals-represents-leading-womens-health-brands-at-mego-2025/> <img loading=lazy decoding=async width=1280 height=960 src=/wp-content/cache/wpspeed/images/7031329b77a2997e950b913f7f2fb826298d60cb.webp class="attachment-full size-full wp-post-image wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMjgwIiBoZWlnaHQ9Ijk2MCI+PC9zdmc+ data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3.jpg 1280w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-300x225.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-1024x768.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-768x576.jpg 768w" sizes="(max-width: 1280px) 100vw, 1280px"><noscript><img loading=lazy decoding=async width=1280 height=960 src=/wp-content/cache/wpspeed/images/7031329b77a2997e950b913f7f2fb826298d60cb.webp class="attachment-full size-full wp-post-image" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3.jpg 1280w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-300x225.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-1024x768.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-MEGO-Report-3-768x576.jpg 768w" sizes="(max-width: 1280px) 100vw, 1280px"></noscript></a> </div><div class=news-meta><div class=news-date>May 9, 2025</div></div><h3 class=news-title>Arabian Ethicals Represents Leading Women&rsquo;s Health Brands at MEGO 2025</h3><p class=news-excerpt>Arabian Ethicals was proud to participate in the Middle East Obstetrics and Gynecology Conference (MEGO 2025), one of&hellip;</p> <a href=https://arabianethicals.ae/arabian-ethicals-represents-leading-womens-health-brands-at-mego-2025/ class=read-more-btn>Read More</a> </div><div class=news-item><div class=news-image> <a href=https://arabianethicals.ae/arabian-ethicals-showcases-healthcare-commitment-at-icpm-2025/> <img loading=lazy decoding=async width=1600 height=1200 src=/wp-content/cache/wpspeed/images/00e2bd9945c3440604ec930e6fe37bee5a6d0089.webp class="attachment-full size-full wp-post-image wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNjAwIiBoZWlnaHQ9IjEyMDAiPjwvc3ZnPg==" data-srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2.jpg 1600w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-300x225.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-1024x768.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-768x576.jpg 768w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-1536x1152.jpg 1536w" sizes="(max-width: 1600px) 100vw, 1600px"><noscript><img loading=lazy decoding=async width=1600 height=1200 src=/wp-content/cache/wpspeed/images/00e2bd9945c3440604ec930e6fe37bee5a6d0089.webp class="attachment-full size-full wp-post-image" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2.jpg 1600w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-300x225.jpg 300w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-1024x768.jpg 1024w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-768x576.jpg 768w, https://arabianethicals.ae/wp-content/uploads/2025/06/Arabian-Ethicals-ICPM-Report-2-1536x1152.jpg 1536w" sizes="(max-width: 1600px) 100vw, 1600px"></noscript></a> </div><div class=news-meta><div class=news-date>January 28, 2025</div></div><h3 class=news-title>Arabian Ethicals Showcases Healthcare Commitment at ICPM 2025</h3><p class=news-excerpt>Arabian Ethicals joined the International Conference on Pharmacy and Medicine (ICPM), held in sharjah research technology &amp; innovation&hellip;</p> <a href=https://arabianethicals.ae/arabian-ethicals-showcases-healthcare-commitment-at-icpm-2025/ class=read-more-btn>Read More</a> </div></div></div></div></div><div class="elementor-element elementor-element-94d4ee2 elementor-icon-list--layout-inline elementor-align-center elementor-list-item-link-full_width elementor-widget elementor-widget-icon-list" data-id=94d4ee2 data-element_type=widget data-widget_type=icon-list.default><div class=elementor-widget-container><ul class="elementor-icon-list-items elementor-inline-items"> <li class="elementor-icon-list-item elementor-inline-item"> <a href=https://arabianethicals.ae/media-center/> <span class=elementor-icon-list-text>Explore More Articles</span> </a> </li> <li class="elementor-icon-list-item elementor-inline-item"> <a href=https://arabianethicals.ae/media-center/> <span class=elementor-icon-list-icon> <svg aria-hidden=true class="e-font-icon-svg e-fas-arrow-right" viewbox="0 0 448 512" xmlns=http://www.w3.org/2000/svg><path d="M190.5 66.9l22.2-22.2c9.4-9.4 24.6-9.4 33.9 0L441 239c9.4 9.4 9.4 24.6 0 33.9L246.6 467.3c-9.4 9.4-24.6 9.4-33.9 0l-22.2-22.2c-9.5-9.5-9.3-25 .4-34.3L311.4 296H24c-13.3 0-24-10.7-24-24v-32c0-13.3 10.7-24 24-24h287.4L190.9 101.2c-9.8-9.3-10-24.8-.4-34.3z"></path></svg> </span> <span class=elementor-icon-list-text></span> </a> </li> </ul> </div> </div> </div> </div> </div> </div> </div> </main><div data-elementor-type=footer data-elementor-id=109 class="elementor elementor-109 elementor-location-footer" data-elementor-post-type=elementor_library><div class="elementor-element elementor-element-7af9b65 e-con-full e-flex e-con e-parent" data-id=7af9b65 data-element_type=container data-settings='{"background_background":"classic"}'><div class="elementor-element elementor-element-cb8286c e-con-full e-flex e-con e-child" data-id=cb8286c data-element_type=container><div class="elementor-element elementor-element-99a2d6c elementor-widget elementor-widget-heading" data-id=99a2d6c data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">Quick Contacts</h2></div></div><div class="elementor-element elementor-element-60af996 elementor-widget elementor-widget-text-editor" data-id=60af996 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>If you have questions or require any assistance, feel free to contact our team.</p></div></div><div class="elementor-element elementor-element-06ef3da elementor-icon-list--layout-traditional elementor-list-item-link-full_width elementor-widget elementor-widget-icon-list" data-id=06ef3da data-element_type=widget data-widget_type=icon-list.default><div class=elementor-widget-container><ul class=elementor-icon-list-items> <li class=elementor-icon-list-item> <a href=tel:+971%204%20208%2084%2000> <span class=elementor-icon-list-icon> <svg aria-hidden=true class="e-font-icon-svg e-fas-phone-alt" viewbox="0 0 512 512" xmlns=http://www.w3.org/2000/svg><path d="M497.39 361.8l-112-48a24 24 0 0 0-28 6.9l-49.6 60.6A370.66 370.66 0 0 1 130.6 204.11l60.6-49.6a23.94 23.94 0 0 0 6.9-28l-48-112A24.16 24.16 0 0 0 122.6.61l-104 24A24 24 0 0 0 0 48c0 256.5 207.9 464 464 464a24 24 0 0 0 23.4-18.6l24-104a24.29 24.29 0 0 0-14.01-27.6z"></path></svg> </span> <span class=elementor-icon-list-text>+971 4 208 84 00</span> </a> </li> </ul> </div> </div><div class="elementor-element elementor-element-a3b4efa elementor-icon-list--layout-traditional elementor-list-item-link-full_width elementor-widget elementor-widget-icon-list" data-id=a3b4efa data-element_type=widget data-widget_type=icon-list.default><div class=elementor-widget-container><ul class=elementor-icon-list-items> <li class=elementor-icon-list-item> <a href=mailto:customercomplaints@arabianethicals.ae> <span class=elementor-icon-list-icon> <svg aria-hidden=true class="e-font-icon-svg e-fas-envelope" viewbox="0 0 512 512" xmlns=http://www.w3.org/2000/svg><path d="M502.3 190.8c3.9-3.1 9.7-.2 9.7 4.7V400c0 26.5-21.5 48-48 48H48c-26.5 0-48-21.5-48-48V195.6c0-5 5.7-7.8 9.7-4.7 22.4 17.4 52.1 39.5 154.1 113.6 21.1 15.4 56.7 47.8 92.2 47.6 35.7.3 72-32.8 92.3-47.6 102-74.1 131.6-96.3 154-113.7zM256 320c23.2.4 56.6-29.2 73.4-41.4 132.7-96.3 142.8-104.7 173.4-128.7 5.8-4.5 9.2-11.5 9.2-18.9v-19c0-26.5-21.5-48-48-48H48C21.5 64 0 85.5 0 112v19c0 7.4 3.4 14.3 9.2 18.9 30.6 23.9 40.7 32.4 173.4 128.7 16.8 12.2 50.2 41.8 73.4 41.4z"></path></svg> </span> <span class=elementor-icon-list-text>customercomplaints@arabianethicals.ae</span> </a> </li> </ul> </div> </div><div class="elementor-element elementor-element-ef4f56b elementor-icon-list--layout-traditional elementor-list-item-link-full_width elementor-widget elementor-widget-icon-list" data-id=ef4f56b data-element_type=widget data-widget_type=icon-list.default><div class=elementor-widget-container><ul class=elementor-icon-list-items> <li class=elementor-icon-list-item> <a href=mailto:pv@arabianethicals.ae> <span class=elementor-icon-list-icon> <svg aria-hidden=true class="e-font-icon-svg e-fas-envelope" viewbox="0 0 512 512" xmlns=http://www.w3.org/2000/svg><path d="M502.3 190.8c3.9-3.1 9.7-.2 9.7 4.7V400c0 26.5-21.5 48-48 48H48c-26.5 0-48-21.5-48-48V195.6c0-5 5.7-7.8 9.7-4.7 22.4 17.4 52.1 39.5 154.1 113.6 21.1 15.4 56.7 47.8 92.2 47.6 35.7.3 72-32.8 92.3-47.6 102-74.1 131.6-96.3 154-113.7zM256 320c23.2.4 56.6-29.2 73.4-41.4 132.7-96.3 142.8-104.7 173.4-128.7 5.8-4.5 9.2-11.5 9.2-18.9v-19c0-26.5-21.5-48-48-48H48C21.5 64 0 85.5 0 112v19c0 7.4 3.4 14.3 9.2 18.9 30.6 23.9 40.7 32.4 173.4 128.7 16.8 12.2 50.2 41.8 73.4 41.4z"></path></svg> </span> <span class=elementor-icon-list-text>pv@arabianethicals.ae</span> </a> </li> </ul> </div> </div><div class="elementor-element elementor-element-be9f7d4 elementor-widget elementor-widget-text-editor" data-id=be9f7d4 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>Light Industrial Unit Phase 6 &amp; 7, Nadd Hessa, Dubai Silicon Oasis Authority,<br>Dubai, United Arab Emirates</p></div></div><div class="elementor-element elementor-element-ce5f2c9 elementor-icon-list--layout-traditional elementor-list-item-link-full_width elementor-widget elementor-widget-icon-list" data-id=ce5f2c9 data-element_type=widget data-widget_type=icon-list.default><div class=elementor-widget-container><ul class=elementor-icon-list-items> <li class=elementor-icon-list-item> <a href=https://maps.app.goo.gl/x6RqZnUuP2jheZ7AA> <span class=elementor-icon-list-icon> <svg aria-hidden=true class="e-font-icon-svg e-fas-map-marker-alt" viewbox="0 0 384 512" xmlns=http://www.w3.org/2000/svg><path d="M172.268 501.67C26.97 291.031 0 269.413 0 192 0 85.961 85.961 0 192 0s192 85.961 192 192c0 77.413-26.97 99.031-172.268 309.67-9.535 13.774-29.93 13.773-39.464 0zM192 272c44.183 0 80-35.817 80-80s-35.817-80-80-80-80 35.817-80 80 35.817 80 80 80z"></path></svg> </span> <span class=elementor-icon-list-text>Get Directions</span> </a> </li> </ul> </div> </div> </div><div class="elementor-element elementor-element-e30ff4f e-con-full e-flex e-con e-child" data-id=e30ff4f data-element_type=container><div class="elementor-element elementor-element-267edf2 elementor-widget elementor-widget-heading" data-id=267edf2 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">Links</h2></div></div><div class="elementor-element elementor-element-2d023ad elementor-nav-menu__align-start elementor-nav-menu--dropdown-none elementor-hidden-mobile elementor-widget elementor-widget-nav-menu" data-id=2d023ad data-element_type=widget data-settings='{"layout":"vertical","submenu_icon":{"value":"&lt;svg class=\"e-font-icon-svg e-fas-caret-down\" viewBox=\"0 0 320 512\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\"&gt;&lt;path d=\"M31.3 192h257.3c17.8 0 26.7 21.5 14.1 34.1L174.1 354.8c-7.8 7.8-20.5 7.8-28.3 0L17.2 226.1C4.6 213.5 13.5 192 31.3 192z\"&gt;&lt;\/path&gt;&lt;\/svg&gt;","library":"fa-solid"}}' data-widget_type=nav-menu.default><div class=elementor-widget-container> <nav aria-label=Menu class="elementor-nav-menu--main elementor-nav-menu__container elementor-nav-menu--layout-vertical e--pointer-text e--animation-none"><ul id=menu-1-2d023ad class="elementor-nav-menu sm-vertical"><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-8 current_page_item menu-item-657"><a href=https://arabianethicals.ae/ aria-current=page class="elementor-item elementor-item-active">Home</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-658"><a href=https://arabianethicals.ae/about-us/ class=elementor-item>About Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-663"><a href=https://arabianethicals.ae/media-center/ class=elementor-item>Media Center</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-660"><a href=https://arabianethicals.ae/careers/ class=elementor-item>Careers</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-662"><a href=https://arabianethicals.ae/contact-us/ class=elementor-item>Contact Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-665"><a href=https://arabianethicals.ae/pharmacovigilance-form/ class=elementor-item>Pharmacovigilance Form</a></li> </ul> </nav> <nav class="elementor-nav-menu--dropdown elementor-nav-menu__container" aria-hidden=true><ul id=menu-2-2d023ad class="elementor-nav-menu sm-vertical"><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-8 current_page_item menu-item-657"><a href=https://arabianethicals.ae/ aria-current=page class="elementor-item elementor-item-active" tabindex=-1>Home</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-658"><a href=https://arabianethicals.ae/about-us/ class=elementor-item tabindex=-1>About Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-663"><a href=https://arabianethicals.ae/media-center/ class=elementor-item tabindex=-1>Media Center</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-660"><a href=https://arabianethicals.ae/careers/ class=elementor-item tabindex=-1>Careers</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-662"><a href=https://arabianethicals.ae/contact-us/ class=elementor-item tabindex=-1>Contact Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-665"><a href=https://arabianethicals.ae/pharmacovigilance-form/ class=elementor-item tabindex=-1>Pharmacovigilance Form</a></li> </ul> </nav> </div> </div><div class="elementor-element elementor-element-dc75cb5 elementor-nav-menu__align-start elementor-nav-menu--dropdown-none elementor-hidden-desktop elementor-hidden-tablet elementor-widget elementor-widget-nav-menu" data-id=dc75cb5 data-element_type=widget data-settings='{"layout":"vertical","submenu_icon":{"value":"&lt;svg class=\"e-font-icon-svg e-fas-caret-down\" viewBox=\"0 0 320 512\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\"&gt;&lt;path d=\"M31.3 192h257.3c17.8 0 26.7 21.5 14.1 34.1L174.1 354.8c-7.8 7.8-20.5 7.8-28.3 0L17.2 226.1C4.6 213.5 13.5 192 31.3 192z\"&gt;&lt;\/path&gt;&lt;\/svg&gt;","library":"fa-solid"}}' data-widget_type=nav-menu.default><div class=elementor-widget-container> <nav aria-label=Menu class="elementor-nav-menu--main elementor-nav-menu__container elementor-nav-menu--layout-vertical e--pointer-none"><ul id=menu-1-dc75cb5 class="elementor-nav-menu sm-vertical"><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-8 current_page_item menu-item-657"><a href=https://arabianethicals.ae/ aria-current=page class="elementor-item elementor-item-active">Home</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-658"><a href=https://arabianethicals.ae/about-us/ class=elementor-item>About Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-663"><a href=https://arabianethicals.ae/media-center/ class=elementor-item>Media Center</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-660"><a href=https://arabianethicals.ae/careers/ class=elementor-item>Careers</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-662"><a href=https://arabianethicals.ae/contact-us/ class=elementor-item>Contact Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-665"><a href=https://arabianethicals.ae/pharmacovigilance-form/ class=elementor-item>Pharmacovigilance Form</a></li> </ul> </nav> <nav class="elementor-nav-menu--dropdown elementor-nav-menu__container" aria-hidden=true><ul id=menu-2-dc75cb5 class="elementor-nav-menu sm-vertical"><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-8 current_page_item menu-item-657"><a href=https://arabianethicals.ae/ aria-current=page class="elementor-item elementor-item-active" tabindex=-1>Home</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-658"><a href=https://arabianethicals.ae/about-us/ class=elementor-item tabindex=-1>About Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-663"><a href=https://arabianethicals.ae/media-center/ class=elementor-item tabindex=-1>Media Center</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-660"><a href=https://arabianethicals.ae/careers/ class=elementor-item tabindex=-1>Careers</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-662"><a href=https://arabianethicals.ae/contact-us/ class=elementor-item tabindex=-1>Contact Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-665"><a href=https://arabianethicals.ae/pharmacovigilance-form/ class=elementor-item tabindex=-1>Pharmacovigilance Form</a></li> </ul> </nav> </div> </div> </div><div class="elementor-element elementor-element-b3e21ed e-con-full e-flex e-con e-child" data-id=b3e21ed data-element_type=container><div class="elementor-element elementor-element-0871793 elementor-widget elementor-widget-heading" data-id=0871793 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">Our Divisions</h2></div></div><div class="elementor-element elementor-element-05725d7 elementor-nav-menu__align-start elementor-nav-menu--dropdown-none elementor-widget elementor-widget-nav-menu" data-id=05725d7 data-element_type=widget data-settings='{"layout":"vertical","submenu_icon":{"value":"&lt;svg class=\"e-font-icon-svg e-fas-caret-down\" viewBox=\"0 0 320 512\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\"&gt;&lt;path d=\"M31.3 192h257.3c17.8 0 26.7 21.5 14.1 34.1L174.1 354.8c-7.8 7.8-20.5 7.8-28.3 0L17.2 226.1C4.6 213.5 13.5 192 31.3 192z\"&gt;&lt;\/path&gt;&lt;\/svg&gt;","library":"fa-solid"}}' data-widget_type=nav-menu.default><div class=elementor-widget-container> <nav aria-label=Menu class="elementor-nav-menu--main elementor-nav-menu__container elementor-nav-menu--layout-vertical e--pointer-text e--animation-none"><ul id=menu-1-05725d7 class="elementor-nav-menu sm-vertical"><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1374"><a href=https://arabianethicals.ae/pharmaceuticals/ class=elementor-item>Pharmaceuticals</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1373"><a href=https://arabianethicals.ae/consumer-health/ class=elementor-item>Consumer Health</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1372"><a href=https://arabianethicals.ae/veterinary/ class=elementor-item>Veterinary</a></li> </ul> </nav> <nav class="elementor-nav-menu--dropdown elementor-nav-menu__container" aria-hidden=true><ul id=menu-2-05725d7 class="elementor-nav-menu sm-vertical"><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1374"><a href=https://arabianethicals.ae/pharmaceuticals/ class=elementor-item tabindex=-1>Pharmaceuticals</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1373"><a href=https://arabianethicals.ae/consumer-health/ class=elementor-item tabindex=-1>Consumer Health</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-1372"><a href=https://arabianethicals.ae/veterinary/ class=elementor-item tabindex=-1>Veterinary</a></li> </ul> </nav> </div> </div><div class="elementor-element elementor-element-1dbc482 elementor-nav-menu__align-start elementor-nav-menu--dropdown-none elementor-hidden-desktop elementor-hidden-tablet elementor-hidden-mobile elementor-widget elementor-widget-nav-menu" data-id=1dbc482 data-element_type=widget data-settings='{"layout":"horizontal","submenu_icon":{"value":"&lt;svg class=\"e-font-icon-svg e-fas-caret-down\" viewBox=\"0 0 320 512\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\"&gt;&lt;path d=\"M31.3 192h257.3c17.8 0 26.7 21.5 14.1 34.1L174.1 354.8c-7.8 7.8-20.5 7.8-28.3 0L17.2 226.1C4.6 213.5 13.5 192 31.3 192z\"&gt;&lt;\/path&gt;&lt;\/svg&gt;","library":"fa-solid"}}' data-widget_type=nav-menu.default><div class=elementor-widget-container> <nav aria-label=Menu class="elementor-nav-menu--main elementor-nav-menu__container elementor-nav-menu--layout-horizontal e--pointer-text e--animation-grow"><ul id=menu-1-1dbc482 class=elementor-nav-menu><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-8 current_page_item menu-item-657"><a href=https://arabianethicals.ae/ aria-current=page class="elementor-item elementor-item-active">Home</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-658"><a href=https://arabianethicals.ae/about-us/ class=elementor-item>About Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-663"><a href=https://arabianethicals.ae/media-center/ class=elementor-item>Media Center</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-660"><a href=https://arabianethicals.ae/careers/ class=elementor-item>Careers</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-662"><a href=https://arabianethicals.ae/contact-us/ class=elementor-item>Contact Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-665"><a href=https://arabianethicals.ae/pharmacovigilance-form/ class=elementor-item>Pharmacovigilance Form</a></li> </ul> </nav> <nav class="elementor-nav-menu--dropdown elementor-nav-menu__container" aria-hidden=true><ul id=menu-2-1dbc482 class=elementor-nav-menu><li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-8 current_page_item menu-item-657"><a href=https://arabianethicals.ae/ aria-current=page class="elementor-item elementor-item-active" tabindex=-1>Home</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-658"><a href=https://arabianethicals.ae/about-us/ class=elementor-item tabindex=-1>About Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-663"><a href=https://arabianethicals.ae/media-center/ class=elementor-item tabindex=-1>Media Center</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-660"><a href=https://arabianethicals.ae/careers/ class=elementor-item tabindex=-1>Careers</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-662"><a href=https://arabianethicals.ae/contact-us/ class=elementor-item tabindex=-1>Contact Us</a></li> <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-665"><a href=https://arabianethicals.ae/pharmacovigilance-form/ class=elementor-item tabindex=-1>Pharmacovigilance Form</a></li> </ul> </nav> </div> </div> </div><div class="elementor-element elementor-element-447267e e-con-full e-flex e-con e-child" data-id=447267e data-element_type=container><div class="elementor-element elementor-element-26d8f8a elementor-widget elementor-widget-heading" data-id=26d8f8a data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default">Follow Us</h2></div></div><div class="elementor-element elementor-element-fb8c845 e-grid-align-mobile-left e-grid-align-left elementor-widget__width-auto elementor-shape-rounded elementor-grid-0 elementor-widget elementor-widget-social-icons" data-id=fb8c845 data-element_type=widget data-widget_type=social-icons.default><div class=elementor-widget-container><div class="elementor-social-icons-wrapper elementor-grid"> <span class=elementor-grid-item> <a class="elementor-icon elementor-social-icon elementor-social-icon-linkedin-in elementor-repeater-item-ab0b13f" href=https://www.linkedin.com/company/arabian-ethicals/ target=_blank> <span class=elementor-screen-only>Linkedin-in</span> <svg class="e-font-icon-svg e-fab-linkedin-in" viewbox="0 0 448 512" xmlns=http://www.w3.org/2000/svg><path d="M100.28 448H7.4V148.9h92.88zM53.79 108.1C24.09 108.1 0 83.5 0 53.8a53.79 53.79 0 0 1 107.58 0c0 29.7-24.1 54.3-53.79 54.3zM447.9 448h-92.68V302.4c0-34.7-.7-79.2-48.29-79.2-48.29 0-55.69 37.7-55.69 76.7V448h-92.78V148.9h89.08v40.8h1.3c12.4-23.5 42.69-48.3 87.88-48.3 94 0 111.28 61.9 111.28 142.3V448z"></path></svg> </a> </span> </div></div></div><div class="elementor-element elementor-element-a42e5dc elementor-widget elementor-widget-image" data-id=a42e5dc data-element_type=widget data-widget_type=image.default><div class=elementor-widget-container> <img width=800 height=372 src=/wp-content/cache/wpspeed/images/32f70a312fa343cc72bc5187fa489b860512856f.webp class="attachment-large size-large wp-image-3551 wpspeed-lazyload" alt="" data-wpspeed-lazyload=1 srcset="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI4MDAiIGhlaWdodD0iMzcyIj48L3N2Zz4=" data-srcset="https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-1024x476.png 1024w, https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-300x139.png 300w, https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-768x357.png 768w, https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-1536x714.png 1536w, https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-2048x952.png 2048w" sizes="(max-width: 800px) 100vw, 800px"><noscript><img width=800 height=372 src=/wp-content/cache/wpspeed/images/32f70a312fa343cc72bc5187fa489b860512856f.webp class="attachment-large size-large wp-image-3551" alt="" srcset="https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-1024x476.png 1024w, https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-300x139.png 300w, https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-768x357.png 768w, https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-1536x714.png 1536w, https://arabianethicals.ae/wp-content/uploads/2024/10/BV_Cert_ISO9001-2015-01-1-2048x952.png 2048w" sizes="(max-width: 800px) 100vw, 800px"></noscript></div></div></div></div><div class="elementor-element elementor-element-cdc7f8a e-con-full e-flex e-con e-parent" data-id=cdc7f8a data-element_type=container><div class="elementor-element elementor-element-29ae56d e-con-full e-flex e-con e-child" data-id=29ae56d data-element_type=container><div class="elementor-element elementor-element-9c6bd17 elementor-widget elementor-widget-text-editor" data-id=9c6bd17 data-element_type=widget data-widget_type=text-editor.default><div class=elementor-widget-container><p>&copy;2024 Arabian Ethicals. All Rights Reserved.</p></div></div></div><div class="elementor-element elementor-element-2a89239 e-con-full e-flex e-con e-child" data-id=2a89239 data-element_type=container><div class="elementor-element elementor-element-7ab0459 elementor-widget elementor-widget-heading" data-id=7ab0459 data-element_type=widget data-widget_type=heading.default><div class=elementor-widget-container><h2 class="elementor-heading-title elementor-size-default"><a href=https://arabianethicals.ae/privacy-policy>Privacy Policy</a></h2></div></div></div></div></div> <script type="speculationrules">
{"prefetch":[{"source":"document","where":{"and":[{"href_matches":"\/*"},{"not":{"href_matches":["\/wp-*.php","\/wp-admin\/*","\/wp-content\/uploads\/*","\/wp-content\/*","\/wp-content\/plugins\/*","\/wp-content\/themes\/hello-elementor\/*","\/*\\?(.+)"]}},{"not":{"selector_matches":"a[rel~=\"nofollow\"]"}},{"not":{"selector_matches":".no-prefetch, .no-prefetch a"}}]},"eagerness":"conservative"}]}
</script> </body> </html>