diff --git a/public/main/admin/add_users_to_usergroup.php b/public/main/admin/add_users_to_usergroup.php
index 98d6f2b04c0..262a7ff85c3 100644
--- a/public/main/admin/add_users_to_usergroup.php
+++ b/public/main/admin/add_users_to_usergroup.php
@@ -125,14 +125,23 @@ function change_select(val) {
 
     if (1 == $form_sent) {
         // Added a parameter to send emails when registering a user
-        $usergroup->subscribe_users_to_usergroup(
+        $result = $usergroup->subscribe_users_to_usergroup(
             $id,
             $elements_posted,
             true,
             $relation
         );
-        $_SESSION['usergroup_flash_message'] = get_lang('Update successful');
-        $_SESSION['usergroup_flash_type'] = 'success';
+
+        if ($result) {
+            // Success: users were subscribed to usergroup (and related courses/sessions)
+            $_SESSION['usergroup_flash_message'] = get_lang('Update successful');
+            $_SESSION['usergroup_flash_type'] = 'success';
+        } else {
+            // Global hosting limit reached: full operation cancelled.
+            $_SESSION['usergroup_flash_message'] = CourseManager::getGlobalLimitCancelMessage();
+            $_SESSION['usergroup_flash_type'] = 'warning';
+        }
+
         header('Location: usergroups.php');
         exit;
     }
diff --git a/public/main/admin/course_user_import.php b/public/main/admin/course_user_import.php
index cb7207c08ae..1297b72f9b2 100644
--- a/public/main/admin/course_user_import.php
+++ b/public/main/admin/course_user_import.php
@@ -66,11 +66,14 @@ function validate_data($users_courses)
  */
 function save_data($users_courses)
 {
+    global $globalLimitUserCoursePairs;
+
     $course_user_table = Database::get_main_table(TABLE_MAIN_COURSE_USER);
     $csv_data = [];
     $inserted_in_course = [];
     $courseListCache = [];
     $courseListById = [];
+
     foreach ($users_courses as $user_course) {
         if (!in_array($user_course['CourseCode'], array_keys($courseListCache))) {
             $courseInfo = api_get_course_info($user_course['CourseCode']);
@@ -80,6 +83,12 @@ function save_data($users_courses)
         } else {
             $courseInfo = $courseListCache[$user_course['CourseCode']];
         }
+
+        if (empty($courseInfo) || empty($courseInfo['real_id'])) {
+            // Skip invalid course info.
+            continue;
+        }
+
         $courseListById[$courseInfo['real_id']] = $courseInfo;
         $csv_data[$user_course['UserName']][$courseInfo['real_id']] = $user_course['Status'];
     }
@@ -91,6 +100,7 @@ function save_data($users_courses)
         }
 
         $user_id = $userInfo['user_id'];
+
         $sql = "SELECT * FROM $course_user_table cu
                 WHERE cu.user_id = $user_id AND cu.relation_type <> ".COURSE_RELATION_TYPE_RRHH.' ';
         $res = Database::query($sql);
@@ -104,7 +114,23 @@ function save_data($users_courses)
 
         if (isset($_POST['subscribe']) && $_POST['subscribe']) {
             foreach ($to_subscribe as $courseId) {
+                if (!isset($courseListById[$courseId])) {
+                    // Safety check in case of inconsistent data.
+                    continue;
+                }
+
                 $courseInfo = $courseListById[$courseId];
+
+                // Check global hosting limit for this user/course pair.
+                if (CourseManager::wouldOperationExceedGlobalLimit((int) $courseId, [$user_id])) {
+                    // Collect pair for later reporting in a single batch message.
+                    $pairLabel = $username.' / '.$courseInfo['title'];
+                    $globalLimitUserCoursePairs[] = $pairLabel;
+
+                    // Do not subscribe this user to this course; continue with next course.
+                    continue;
+                }
+
                 $result = CourseManager::subscribeUser(
                     $user_id,
                     $courseId,
@@ -123,6 +149,11 @@ function save_data($users_courses)
                 } else {
                     $courseInfo = api_get_course_info_by_id($courseId);
                 }
+
+                if (empty($courseInfo) || empty($courseInfo['code'])) {
+                    continue;
+                }
+
                 $courseCode = $courseInfo['code'];
                 CourseManager::unsubscribe_user($user_id, $courseCode);
             }
@@ -159,6 +190,7 @@ function parse_csv_data($file)
 $interbreadcrumb[] = ['url' => 'index.php', 'name' => get_lang('Administration')];
 
 set_time_limit(0);
+$globalLimitUserCoursePairs = [];
 
 // Creating the form.
 $form = new FormValidator('course_user_import');
@@ -182,6 +214,16 @@ function parse_csv_data($file)
         if (0 == count($errors)) {
             $inserted_in_course = save_data($users_courses);
 
+            // Show global hosting limit warning if some subscriptions were blocked.
+            if (!empty($globalLimitUserCoursePairs)) {
+                $limitMessage = CourseManager::getGlobalLimitPartialImportMessage($globalLimitUserCoursePairs);
+                Display::addFlash(
+                    Display::return_message($limitMessage, 'warning', false)
+                );
+                // Reset for safety in case of reuse within the same request.
+                $globalLimitUserCoursePairs = [];
+            }
+
             if (!empty($inserted_in_course)) {
                 $warn = get_lang('File imported');
             } else {
diff --git a/public/main/admin/subscribe_user2course.php b/public/main/admin/subscribe_user2course.php
index 8a9d10f158c..d45893c99be 100644
--- a/public/main/admin/subscribe_user2course.php
+++ b/public/main/admin/subscribe_user2course.php
@@ -95,30 +95,87 @@ function validate_filter() {
             echo Display::return_message(get_lang('You must select at least one user and one course'), 'error');
         } else {
             $errorDrh = 0;
-            foreach ($courses as $course_code) {
-                foreach ($users as $user_id) {
-                    $user = api_get_user_info($user_id);
-                    if (DRH != $user['status']) {
-                        $courseInfo = api_get_course_info($course_code);
-                        CourseManager::subscribeUser($user_id, $courseInfo['real_id']);
-                    } else {
-                        $errorDrh = 1;
+
+            // -----------------------------------------------------------------
+            // Build user info map once and list of users allowed for subscription
+            // (DRH users are excluded from global limit computation and from
+            // course subscription).
+            // -----------------------------------------------------------------
+            $usersInfo = [];
+            $subscribableUserIds = [];
+
+            foreach ($users as $user_id) {
+                $user = api_get_user_info($user_id);
+                $usersInfo[$user_id] = $user;
+
+                if (DRH != $user['status']) {
+                    $subscribableUserIds[] = $user_id;
+                } else {
+                    // Keep original behaviour: mark DRH presence to show message later
+                    $errorDrh = 1;
+                }
+            }
+
+            // -----------------------------------------------------------------
+            // Global hosting limit: cancel whole operation if any selected
+            // course would exceed platform.hosting_limit_users_per_course.
+            // -----------------------------------------------------------------
+            $limitExceeded = false;
+
+            if (!empty($subscribableUserIds)) {
+                foreach ($courses as $course_code) {
+                    $courseInfo = api_get_course_info($course_code);
+                    if (empty($courseInfo) || empty($courseInfo['real_id'])) {
+                        continue; // Skip invalid course records.
+                    }
+
+                    $courseId = (int) $courseInfo['real_id'];
+
+                    if (CourseManager::wouldOperationExceedGlobalLimit($courseId, $subscribableUserIds)) {
+                        $limitExceeded = true;
+                        break;
                     }
                 }
             }
 
-            if (0 == $errorDrh) {
+            if ($limitExceeded) {
+                // No subscription is executed if the global limit would be exceeded.
                 echo Display::return_message(
-                    get_lang('The selected users are subscribed to the selected course'),
-                    'confirm'
+                    CourseManager::getGlobalLimitCancelMessage(),
+                    'warning'
                 );
             } else {
-                echo Display::return_message(
-                    get_lang(
-                        'Human resources managers should not be registered to courses. The corresponding users you selected have not been subscribed.'
-                    ),
-                    'error'
-                );
+                // -----------------------------------------------------------------
+                // Original behaviour: subscribe all non-DRH users to all selected courses.
+                // DRH users are skipped and reported.
+                // -----------------------------------------------------------------
+                foreach ($courses as $course_code) {
+                    $courseInfo = api_get_course_info($course_code);
+
+                    foreach ($users as $user_id) {
+                        $user = $usersInfo[$user_id] ?? api_get_user_info($user_id);
+
+                        if (DRH != $user['status']) {
+                            CourseManager::subscribeUser($user_id, $courseInfo['real_id']);
+                        } else {
+                            $errorDrh = 1;
+                        }
+                    }
+                }
+
+                if (0 == $errorDrh) {
+                    echo Display::return_message(
+                        get_lang('The selected users are subscribed to the selected course'),
+                        'confirm'
+                    );
+                } else {
+                    echo Display::return_message(
+                        get_lang(
+                            'Human resources managers should not be registered to courses. The corresponding users you selected have not been subscribed.'
+                        ),
+                        'error'
+                    );
+                }
             }
         }
     }
diff --git a/public/main/admin/user_import.php b/public/main/admin/user_import.php
index 017ff8e87e1..e852379fa9a 100644
--- a/public/main/admin/user_import.php
+++ b/public/main/admin/user_import.php
@@ -20,6 +20,7 @@
 api_protect_admin_script(true, null);
 api_protect_limit_for_session_admin();
 set_time_limit(0);
+$globalLimitUserCoursePairs = [];
 
 /**
  * @param array $users
@@ -202,7 +203,12 @@ function complete_missing_data($user)
  */
 function save_data($users, $sendMail = false)
 {
-    global $inserted_in_course, $extra_fields;
+    global $inserted_in_course, $extra_fields, $globalLimitUserCoursePairs;
+
+    // Ensure array for global limit tracking.
+    if (!isset($globalLimitUserCoursePairs) || !is_array($globalLimitUserCoursePairs)) {
+        $globalLimitUserCoursePairs = [];
+    }
 
     // Not all scripts declare the $inserted_in_course array (although they should).
     if (!isset($inserted_in_course)) {
@@ -254,12 +260,33 @@ function save_data($users, $sendMail = false)
             if ($user_id) {
                 $returnMessage = Display::return_message(get_lang('The user has been added'), 'success');
 
+                // Normalize Courses for both CSV and XML imports.
+                if (isset($user['Courses']) && !is_array($user['Courses'])) {
+                    $user['Courses'] = explode('|', trim((string) $user['Courses']));
+                }
+
                 if (isset($user['Courses']) && is_array($user['Courses'])) {
                     foreach ($user['Courses'] as $course) {
                         if (CourseManager::course_exists($course)) {
                             $course_info = api_get_course_info($course);
+                            if (empty($course_info) || empty($course_info['real_id'])) {
+                                // Skip invalid course records.
+                                continue;
+                            }
+
+                            $courseId = (int) $course_info['real_id'];
+
+                            // Check global hosting limit for this user/course pair.
+                            if (CourseManager::wouldOperationExceedGlobalLimit($courseId, [$user_id])) {
+                                // Collect pair for later reporting in a single batch message.
+                                $pairLabel = $user['UserName'].' / '.$course_info['title'];
+                                $globalLimitUserCoursePairs[] = $pairLabel;
+
+                                // Do not subscribe this user to this course; continue with next course.
+                                continue;
+                            }
 
-                            $result = CourseManager::subscribeUser($user_id, $course_info['real_id'], $user['Status']);
+                            $result = CourseManager::subscribeUser($user_id, $courseId, $user['Status']);
                             if ($result) {
                                 $inserted_in_course[$course] = $course_info['title'];
                             }
@@ -449,6 +476,8 @@ function parse_xml_data($file)
  */
 function processUsers(&$users, $sendMail)
 {
+    global $globalLimitUserCoursePairs;
+
     $users = save_data($users, $sendMail);
 
     $warningMessage = '';
@@ -481,6 +510,22 @@ function processUsers(&$users, $sendMail)
         $warningMessage = $table->toHtml();
     }
 
+    // Append global hosting limit report if needed (batch imports).
+    if (!empty($globalLimitUserCoursePairs)) {
+        $limitMessage = CourseManager::getGlobalLimitPartialImportMessage($globalLimitUserCoursePairs);
+
+        // Show the warning once as a flash message.
+        Display::addFlash(
+            Display::return_message($limitMessage, 'warning', false)
+        );
+
+        // Also append to the per-import log that is shown in the "Results and feedback" section.
+        $warningMessage .= Display::return_message($limitMessage, 'warning', false);
+
+        // Reset for potential subsequent imports in the same request.
+        $globalLimitUserCoursePairs = [];
+    }
+
     // if the warning message is too long then we display the warning message trough a session
     Display::addFlash(Display::return_message(get_lang('File imported'), 'confirmation', false));
 
diff --git a/public/main/admin/usergroups.php b/public/main/admin/usergroups.php
index 8327c07f99b..ee57e98e103 100644
--- a/public/main/admin/usergroups.php
+++ b/public/main/admin/usergroups.php
@@ -183,7 +183,13 @@
 }
 
 Display::display_header();
-
+if (!empty($_SESSION['usergroup_flash_message'])) {
+    echo Display::return_message(
+        $_SESSION['usergroup_flash_message'],
+        $_SESSION['usergroup_flash_type']
+    );
+    unset($_SESSION['usergroup_flash_message'], $_SESSION['usergroup_flash_type']);
+}
 ?>
     <script>
         $(function() {
diff --git a/public/main/inc/lib/course.lib.php b/public/main/inc/lib/course.lib.php
index fa482594394..8408353113c 100644
--- a/public/main/inc/lib/course.lib.php
+++ b/public/main/inc/lib/course.lib.php
@@ -6814,4 +6814,136 @@ private static function fillCourse(Course $course, array $params, ?int $authorId
         $courseFieldValue = new ExtraFieldValue('course');
         //$courseFieldValue->saveFieldValues($params);
     }
+
+    /**
+     * Global hosting limit for users per course.
+     * Returns 0 when the limit is disabled.
+     */
+    public static function getGlobalUsersPerCourseLimit(): int
+    {
+        return (int) api_get_setting('platform.hosting_limit_users_per_course');
+    }
+
+    /**
+     * Count current users in course for the global limit.
+     * Excludes HR relation type (keeps legacy behaviour).
+     */
+    public static function countUsersForGlobalLimit(int $courseId): int
+    {
+        $courseId = (int) $courseId;
+        if ($courseId <= 0) {
+            return 0;
+        }
+
+        $table = Database::get_main_table(TABLE_MAIN_COURSE_USER);
+
+        $sql = "SELECT COUNT(*) AS total
+                FROM $table
+                WHERE c_id = $courseId
+                  AND relation_type <> ".COURSE_RELATION_TYPE_RRHH;
+
+        $res = Database::query($sql);
+        $row = Database::fetch_array($res, 'ASSOC') ?: [];
+
+        return (int) ($row['total'] ?? 0);
+    }
+
+    /**
+     * Check if subscribing the given users (no session) would exceed the global limit.
+     *
+     * @param int   $courseId
+     * @param int[] $userIds
+     */
+    public static function wouldOperationExceedGlobalLimit(int $courseId, array $userIds): bool
+    {
+        $limit = self::getGlobalUsersPerCourseLimit();
+        if ($limit <= 0) {
+            // No global limit configured.
+            return false;
+        }
+
+        $courseId = (int) $courseId;
+        if ($courseId <= 0 || empty($userIds)) {
+            return false;
+        }
+
+        // Keep unique, positive IDs only.
+        $userIds = array_values(array_unique(array_map('intval', $userIds)));
+        $userIds = array_filter(
+            $userIds,
+            static function (int $id): bool {
+                return $id > 0;
+            }
+        );
+
+        if (empty($userIds)) {
+            return false;
+        }
+
+        $table  = Database::get_main_table(TABLE_MAIN_COURSE_USER);
+        $idList = implode(',', $userIds);
+
+        // How many of these users are already in the course?
+        $sql = "SELECT COUNT(DISTINCT user_id) AS already
+                FROM $table
+                WHERE c_id = $courseId
+                  AND relation_type <> ".COURSE_RELATION_TYPE_RRHH."
+                  AND user_id IN ($idList)";
+
+        $res = Database::query($sql);
+        $row = Database::fetch_array($res, 'ASSOC') ?: [];
+        $already = (int) ($row['already'] ?? 0);
+
+        $newCount = count($userIds) - $already;
+        if ($newCount <= 0) {
+            // Nothing new to subscribe, cannot exceed.
+            return false;
+        }
+
+        $current = self::countUsersForGlobalLimit($courseId);
+
+        return ($current + $newCount) > $limit;
+    }
+
+    /**
+     * Build message when a *manual* subscription operation must be cancelled.
+     */
+    public static function getGlobalLimitCancelMessage(): string
+    {
+        $limit = self::getGlobalUsersPerCourseLimit();
+
+        return sprintf(
+            get_lang(
+                'This operation would exceed the limit of %d users per course set by the administrators. The whole subscription operation has been cancelled.'
+            ),
+            $limit
+        );
+    }
+
+    /**
+     * Build message for *batch imports* when some subscriptions hit the limit.
+     *
+     * @param string[] $pairs List of "username / Course title" strings.
+     */
+    public static function getGlobalLimitPartialImportMessage(array $pairs): string
+    {
+        $limit = self::getGlobalUsersPerCourseLimit();
+
+        $safePairs = array_map(
+            static function (string $pair): string {
+                return Security::remove_XSS($pair);
+            },
+            $pairs
+        );
+
+        $list = implode(', ', $safePairs);
+
+        return sprintf(
+            get_lang(
+                'Some or all the subscriptions could not be executed because they reached the limit of %d users per course set by the administrators. Please make sure that limit is raised and try executing this operation again. Users/Courses affected: %s'
+            ),
+            $limit,
+            $list
+        );
+    }
 }
diff --git a/public/main/inc/lib/usergroup.lib.php b/public/main/inc/lib/usergroup.lib.php
index 5e0ee026cb4..b1aec700b9e 100644
--- a/public/main/inc/lib/usergroup.lib.php
+++ b/public/main/inc/lib/usergroup.lib.php
@@ -1224,44 +1224,70 @@ public function subscribe_users_to_usergroup(
         $delete_users_not_present_in_list = true,
         $relationType = 0
     ) {
+        $usergroup_id = (int) $usergroup_id;
+        $relationType = (int) $relationType;
+
         $current_list = $this->get_users_by_usergroup($usergroup_id);
         $course_list = $this->get_courses_by_usergroup($usergroup_id);
         $session_list = $this->get_sessions_by_usergroup($usergroup_id);
         $session_list = array_filter($session_list);
-        $relationType = (int) $relationType;
 
         $delete_items = [];
         $new_items = [];
 
+        // Build new_items = users newly added to the group
         if (!empty($list)) {
             foreach ($list as $user_id) {
-                if (!in_array($user_id, $current_list)) {
+                $user_id = (int) $user_id;
+                if (!in_array($user_id, $current_list, true)) {
                     $new_items[] = $user_id;
                 }
             }
         }
 
+        // Build delete_items = users removed from the group
         if (!empty($current_list)) {
             foreach ($current_list as $user_id) {
-                if (!in_array($user_id, $list)) {
+                if (!in_array($user_id, $list, true)) {
                     $delete_items[] = $user_id;
                 }
             }
         }
 
-        // Deleting items
+        // Global hosting limit check (all or nothing for classes)
+        $globalLimit = CourseManager::getGlobalUsersPerCourseLimit();
+        if ($globalLimit > 0 && !empty($new_items) && !empty($course_list)) {
+            foreach ($course_list as $course_id) {
+                $course_id = (int) $course_id;
+
+                // Only check "direct course" limit; sessions are exempt.
+                if (CourseManager::wouldOperationExceedGlobalLimit($course_id, $new_items)) {
+                    // Do not touch DB if this operation would exceed the limit.
+                    return false;
+                }
+            }
+        }
+
+        // Deleting items (if requested)
         if (!empty($delete_items) && $delete_users_not_present_in_list) {
             foreach ($delete_items as $user_id) {
+                $user_id = (int) $user_id;
+
                 // Removing courses
                 if (!empty($course_list)) {
                     foreach ($course_list as $course_id) {
+                        $course_id = (int) $course_id;
                         $course_info = api_get_course_info_by_id($course_id);
-                        CourseManager::unsubscribe_user($user_id, $course_info['code']);
+                        if (!empty($course_info)) {
+                            CourseManager::unsubscribe_user($user_id, $course_info['code']);
+                        }
                     }
                 }
+
                 // Removing sessions
                 if (!empty($session_list)) {
                     foreach ($session_list as $session_id) {
+                        $session_id = (int) $session_id;
                         SessionManager::unsubscribe_user_from_session($session_id, $user_id);
                     }
                 }
@@ -1293,20 +1319,25 @@ public function subscribe_users_to_usergroup(
 
         // Adding new relationships
         if (!empty($new_items)) {
-            // Adding sessions
+            // Subscribe users to sessions (sessions are exempt from global limit)
             if (!empty($session_list)) {
                 foreach ($session_list as $session_id) {
+                    $session_id = (int) $session_id;
                     SessionManager::subscribeUsersToSession($session_id, $new_items, null, false);
                 }
             }
 
+            // Subscribe users to courses (limit already checked above)
             foreach ($new_items as $user_id) {
-                // Adding courses.
+                $user_id = (int) $user_id;
+
                 if (!empty($course_list)) {
                     foreach ($course_list as $course_id) {
+                        $course_id = (int) $course_id;
                         CourseManager::subscribeUser($user_id, $course_id);
                     }
                 }
+
                 $params = [
                     'user_id' => $user_id,
                     'usergroup_id' => $usergroup_id,
@@ -1315,6 +1346,8 @@ public function subscribe_users_to_usergroup(
                 Database::insert($this->usergroup_rel_user_table, $params);
             }
         }
+
+        return true;
     }
 
     /**
diff --git a/public/main/user/subscribe_user.php b/public/main/user/subscribe_user.php
index 5ba89e758dd..d80572ed185 100644
--- a/public/main/user/subscribe_user.php
+++ b/public/main/user/subscribe_user.php
@@ -61,27 +61,70 @@
 if (isset($_REQUEST['Registerister'])) {
     $userInfo = api_get_user_info($_REQUEST['user_id']);
     if ($userInfo) {
+        // Global hosting limit applies only when NOT in a session.
+        if (empty($sessionId)) {
+            // Single registration would add exactly 1 new user.
+            $canSubscribe = can_subscribe_more_users_for_course((int) $courseInfo['real_id'], 1, true);
+            if (!$canSubscribe) {
+                // Operation cancelled: redirect back to course users list.
+                header('Location:'.api_get_path(WEB_CODE_PATH).'user/user.php?'.api_get_cidreq().'&type='.$type);
+                exit;
+            }
+        }
+
         if (COURSEMANAGER === $type) {
             if (!empty($sessionId)) {
                 $message = $userInfo['complete_name_with_username'].' '.get_lang('has been registered to your course');
-                SessionManager::set_coach_to_course_session(
+                $ok = SessionManager::set_coach_to_course_session(
                     $_REQUEST['user_id'],
                     $sessionId,
                     $courseInfo['real_id']
                 );
-                Display::addFlash(Display::return_message($message));
+                Display::addFlash(
+                    Display::return_message(
+                        $ok ? $message : get_lang('Unexpected error while subscribing the user'),
+                        $ok ? 'normal' : 'warning'
+                    )
+                );
             } else {
-                CourseManager::subscribeUser(
+                // Use structured result from CourseManager::subscribeUser to centralize limit checks and messages.
+                $res = CourseManager::subscribeUser(
                     $_REQUEST['user_id'],
                     $courseInfo['real_id'],
-                    COURSEMANAGER
+                    COURSEMANAGER,
+                    0,
+                    0,
+                    true,
+                    ['result' => true, 'flash' => false, 'emails' => true] // UI handles flash here
                 );
+                if (is_array($res) && isset($res['message'])) {
+                    Display::addFlash(
+                        Display::return_message(
+                            $res['message'],
+                            !empty($res['ok']) ? 'normal' : 'warning'
+                        )
+                    );
+                }
             }
         } else {
-            CourseManager::subscribeUser(
+            // Students subscription
+            $res = CourseManager::subscribeUser(
                 $_REQUEST['user_id'],
-                $courseInfo['real_id']
+                $courseInfo['real_id'],
+                STUDENT,
+                0,
+                0,
+                true,
+                ['result' => true, 'flash' => false, 'emails' => true]
             );
+            if (is_array($res) && isset($res['message'])) {
+                Display::addFlash(
+                    Display::return_message(
+                        $res['message'],
+                        !empty($res['ok']) ? 'normal' : 'warning'
+                    )
+                );
+            }
         }
     }
     header('Location:'.api_get_path(WEB_CODE_PATH).'user/user.php?'.api_get_cidreq().'&type='.$type);
@@ -92,26 +135,83 @@
     switch ($_POST['action']) {
         case 'subscribe':
             if (is_array($_POST['user'])) {
+                // Normalize user IDs list (avoid duplicates)
+                $selectedUserIds = array_unique(array_map('intval', $_POST['user']));
+
                 $isSuscribe = [];
-                foreach ($_POST['user'] as $index => $user_id) {
+                $errorMessages = [];
+                $limitReached = false;
+
+                foreach ($selectedUserIds as $index => $user_id) {
                     $userInfo = api_get_user_info($user_id);
-                    if ($userInfo) {
-                        if (COURSEMANAGER === $type) {
-                            if (!empty($sessionId)) {
-                                $message = $userInfo['complete_name_with_username'].' '.get_lang('has been registered to your course');
-                                $result = SessionManager::set_coach_to_course_session(
-                                    $user_id,
-                                    $sessionId,
-                                    $courseInfo['real_id']
-                                );
-                                if ($result) {
-                                    $isSuscribe[] = $message;
-                                }
+                    if (!$userInfo) {
+                        continue;
+                    }
+
+                    // Global hosting limit applies only for direct course subscriptions (no session).
+                    // For bulk operations, we check the limit *per user* so that we can
+                    // subscribe as many users as possible until the limit is reached.
+                    if (empty($sessionId)) {
+                        if (!can_subscribe_more_users_for_course(
+                            (int) $courseInfo['real_id'],
+                            1,
+                            !$limitReached // emit flash only the first time we hit the limit
+                        )) {
+                            $limitReached = true;
+                            // Stop processing further users: the course is full.
+                            break;
+                        }
+                    }
+
+                    if (COURSEMANAGER === $type) {
+                        if (!empty($sessionId)) {
+                            $message = $userInfo['complete_name_with_username'].' '.get_lang('has been registered to your course');
+                            $result = SessionManager::set_coach_to_course_session(
+                                $user_id,
+                                $sessionId,
+                                $courseInfo['real_id']
+                            );
+                            if ($result) {
+                                $isSuscribe[] = $message;
                             } else {
-                                CourseManager::subscribeUser($user_id, $courseInfo['real_id'], COURSEMANAGER);
+                                $errorMessages[] = $userInfo['complete_name_with_username'].': '.get_lang('Unexpected error while subscribing the user');
                             }
                         } else {
-                            CourseManager::subscribeUser($user_id, $courseInfo['real_id']);
+                            // Use structured result when subscribing a teacher directly to the course.
+                            $res = CourseManager::subscribeUser(
+                                $user_id,
+                                $courseInfo['real_id'],
+                                COURSEMANAGER,
+                                0,
+                                0,
+                                true,
+                                ['result' => true, 'flash' => false, 'emails' => true]
+                            );
+                            if (is_array($res)) {
+                                if (!empty($res['ok'])) {
+                                    $isSuscribe[] = $res['message'];
+                                } else {
+                                    $errorMessages[] = $res['message'] ?? get_lang('Unexpected error while subscribing the user');
+                                }
+                            }
+                        }
+                    } else {
+                        // Student subscription
+                        $res = CourseManager::subscribeUser(
+                            $user_id,
+                            $courseInfo['real_id'],
+                            STUDENT,
+                            0,
+                            0,
+                            true,
+                            ['result' => true, 'flash' => false, 'emails' => true]
+                        );
+                        if (is_array($res)) {
+                            if (!empty($res['ok'])) {
+                                $isSuscribe[] = $res['message'];
+                            } else {
+                                $errorMessages[] = $res['message'] ?? get_lang('Unexpected error while subscribing the user');
+                            }
                         }
                     }
                 }
@@ -121,11 +221,16 @@
                         Display::addFlash(Display::return_message($info));
                     }
                 }
+
+                if (!empty($errorMessages)) {
+                    $errHtml = implode('<br>', array_map('Security::remove_XSS', $errorMessages));
+                    Display::addFlash(Display::return_message($errHtml, 'warning'));
+                }
             }
 
             header('Location:'.api_get_path(WEB_CODE_PATH).'user/user.php?'.api_get_cidreq().'&type='.$type);
             exit;
-        break;
+            break;
     }
 }
 
@@ -826,8 +931,10 @@ function search_additional_profile_fields($keyword)
         $profiling_field_options_exact_values[] = $profiling_field_options;
     }
     $profiling_field_options_exact_values_sql = '';
-    foreach ($profiling_field_options_exact_values as $profilingkey => $profilingvalue) {
-        $profiling_field_options_exact_values_sql .= " OR (field_id = '".$profilingvalue['field_id']."' AND value='".$profilingvalue['option_value']."') ";
+    if (!empty($profiling_field_options_exact_values)) {
+        foreach ($profiling_field_options_exact_values as $profilingkey => $profilingvalue) {
+            $profiling_field_options_exact_values_sql .= " OR (field_id = '".$profilingvalue['field_id']."' AND value='".$profilingvalue['option_value']."') ";
+        }
     }
 
     $extraFieldType = ExtraField::USER_FIELD_TYPE;
@@ -906,3 +1013,71 @@ function display_extra_profile_fields_filter()
 
     return $html;
 }
+
+/**
+ * Check global hosting_limit_users_per_course for a given course.
+ * This helper is used by manual subscription screens to cancel the
+ * operation *before* calling CourseManager::subscribeUser().
+ *
+ * It tries to reuse CourseManager helpers when available, and falls
+ * back to a direct SQL count if needed.
+ *
+ * @param int  $courseId   Internal course ID (c_id)
+ * @param int  $nbNewUsers Number of new users we want to subscribe
+ * @param bool $emitFlash  When true, shows a warning flash message if the limit would be exceeded
+ *
+ * @return bool True if the operation can continue, false if it must be cancelled
+ */
+function can_subscribe_more_users_for_course(int $courseId, int $nbNewUsers, bool $emitFlash = true): bool
+{
+    $courseId = (int) $courseId;
+    $globalLimit = 0;
+    $current = 0;
+
+    // Prefer centralized helpers on CourseManager when available.
+    if (class_exists('CourseManager')
+        && method_exists('CourseManager', 'getGlobalUsersPerCourseLimit')
+        && method_exists('CourseManager', 'countUsersForGlobalLimit')
+    ) {
+        $globalLimit = (int) CourseManager::getGlobalUsersPerCourseLimit();
+        if ($globalLimit <= 0) {
+            // Global limit disabled.
+            return true;
+        }
+
+        $current = (int) CourseManager::countUsersForGlobalLimit($courseId);
+    } else {
+        // Fallback to direct setting access and SQL counting.
+        $globalLimit = (int) api_get_setting('platform.hosting_limit_users_per_course'); // 0 => disabled
+        if ($globalLimit <= 0) {
+            return true;
+        }
+
+        $tblCourseUser = Database::get_main_table(TABLE_MAIN_COURSE_USER);
+        $sql = "SELECT COUNT(*) AS total
+                FROM $tblCourseUser
+                WHERE c_id = $courseId
+                  AND relation_type <> ".COURSE_RELATION_TYPE_RRHH;
+        $res = Database::query($sql);
+        $row = Database::fetch_array($res, 'ASSOC') ?: [];
+        $current = (int) ($row['total'] ?? 0);
+    }
+
+    if ($current + $nbNewUsers > $globalLimit) {
+        if ($emitFlash) {
+            $msg = sprintf(
+                get_lang(
+                    'This operation would exceed the limit of %s users per course set by the administrators. The subscription has been cancelled.'
+                ),
+                $globalLimit
+            );
+            Display::addFlash(Display::return_message($msg, 'warning'));
+        }
+
+        // Limit reached: cancel the operation.
+        return false;
+    }
+
+    // Still below the limit: allow the operation.
+    return true;
+}
diff --git a/public/main/user/user.php b/public/main/user/user.php
index 33a28a78614..58f7f40dcee 100644
--- a/public/main/user/user.php
+++ b/public/main/user/user.php
@@ -481,6 +481,22 @@
     }
 }
 
+// Global hosting limit: precompute a simple snapshot for UI purposes only.
+$globalLimitUsersPerCourse = 0;
+$currentUsersForGlobalLimit = 0;
+$courseIsFullForGlobalLimit = false;
+
+if ($canEdit && 0 === (int) $sessionId) {
+    // Read the global limit through CourseManager helper to keep logic centralized.
+    $globalLimitUsersPerCourse = (int) CourseManager::getGlobalUsersPerCourseLimit();
+
+    if ($globalLimitUsersPerCourse > 0) {
+        // Count current users for the limit, excluding HR relation type.
+        $currentUsersForGlobalLimit = (int) CourseManager::countUsersForGlobalLimit($courseId);
+        $courseIsFullForGlobalLimit = $currentUsersForGlobalLimit >= $globalLimitUsersPerCourse;
+    }
+}
+
 // $is_allowed_in_course is first defined in local.inc.php
 if (!api_is_allowed_in_course()) {
     api_not_allowed(true);
@@ -612,7 +628,16 @@
 
     $actionsLeft = '';
     if ($canEdit) {
-        $actionsLeft .= $icon;
+        // When the global hosting limit is enabled and already reached (no session),
+        // we hide the "Add" icon to avoid actions that would add more users.
+        $canShowAddIcon = true;
+        if (0 === (int) $sessionId && $globalLimitUsersPerCourse > 0 && $courseIsFullForGlobalLimit) {
+            $canShowAddIcon = false;
+        }
+
+        if ($canShowAddIcon) {
+            $actionsLeft .= $icon;
+        }
     }
 
     if ($canRead) {
@@ -656,6 +681,18 @@
     }
 
     echo Display::toolbarAction('toolbar', [$actionsLeft, $actionsRight]);
+
+    // When the course is full according to the global limit (no session),
+    // show an explicit warning so teachers understand why the Add icon is hidden.
+    if ($canEdit && 0 === (int) $sessionId && $globalLimitUsersPerCourse > 0 && $courseIsFullForGlobalLimit) {
+        $msg = sprintf(
+            get_lang(
+                'This course already reached the global limit of %d users set by the administrators. To add more users, please ask an administrator to raise this limit or use sessions.'
+            ),
+            $globalLimitUsersPerCourse
+        );
+        echo Display::return_message($msg, 'warning');
+    }
 }
 
 echo UserManager::getUserSubscriptionTab($selectedTab);
@@ -732,7 +769,7 @@ function get_number_of_users()
 
     foreach ($users as $user) {
         if ((
-            isset($_GET['keyword']) &&
+                isset($_GET['keyword']) &&
                 searchUserKeyword(
                     $user['firstname'],
                     $user['lastname'],
@@ -870,7 +907,7 @@ function get_user_data($from, $number_of_items, $column, $direction)
 
     foreach ($users as $user_id => $userData) {
         if ((
-            isset($_GET['keyword']) &&
+                isset($_GET['keyword']) &&
                 searchUserKeyword(
                     $userData['firstname'],
                     $userData['lastname'],