diff --git a/augur/api/routes/dei.py b/augur/api/routes/dei.py
index dea79b79c2..82324a8d62 100644
--- a/augur/api/routes/dei.py
+++ b/augur/api/routes/dei.py
@@ -52,7 +52,7 @@ def dei_track_repo(application: ClientApplication):
         return jsonify({"status": "Repo already exists"})
     
     frontend_repo_group: RepoGroup = session.query(RepoGroup).filter(RepoGroup.rg_name == FRONTEND_REPO_GROUP_NAME).first()
-    repo_id = Repo.insert(session, repo_url, frontend_repo_group.repo_group_id, "API.DEI", repo_type="")
+    repo_id = Repo.insert_github_repo(session, repo_url, frontend_repo_group.repo_group_id, "API.DEI", repo_type="")
     if not repo_id:
         return jsonify({"status": "Error adding repo"})
     
diff --git a/augur/api/routes/user.py b/augur/api/routes/user.py
index dfaeb81f7f..62bc44068a 100644
--- a/augur/api/routes/user.py
+++ b/augur/api/routes/user.py
@@ -227,7 +227,7 @@ def add_user_repo():
     repo = request.args.get("repo_url")
     group_name = request.args.get("group_name")
 
-    result = current_user.add_repo(group_name, repo)
+    result = current_user.add_github_repo(group_name, repo)
 
     return jsonify(result[1])
 
@@ -260,7 +260,7 @@ def add_user_org():
     org = request.args.get("org_url")
     group_name = request.args.get("group_name")
 
-    result = current_user.add_org(group_name, org)
+    result = current_user.add_github_org(group_name, org)
 
     return jsonify(result[1])
 
diff --git a/augur/api/view/api.py b/augur/api/view/api.py
index 287b079436..598c0cdb6d 100644
--- a/augur/api/view/api.py
+++ b/augur/api/view/api.py
@@ -102,7 +102,18 @@ def av_add_user_repo():
                 if rg_obj:
                     # add the orgs repos to the group
                     add_existing_org_to_group(session, current_user.user_id, group, rg_obj.repo_group_id)
-            
+
+            # matches https://gitlab.com/{org}/{repo}/ or http://gitlab.com/{org}/{repo}
+            elif Repo.parse_gitlab_repo_url(url)[0]:
+
+                org_name, repo_name = Repo.parse_github_repo_url(url)
+                repo_git = f"https://gitlab.com/{org_name}/{repo_name}"
+
+                # TODO: gitlab ensure the whole repo git is inserted so it can be found here
+                repo_obj = Repo.get_by_repo_git(session, repo_git)
+                if repo_obj:
+                    add_existing_repo_to_group(session, current_user.user_id, group, repo_obj.repo_id)
+                
             else:
                 invalid_urls.append(url)
 
diff --git a/augur/application/db/models/augur_data.py b/augur/application/db/models/augur_data.py
index f5efceb4e7..cfbcdca1d7 100644
--- a/augur/application/db/models/augur_data.py
+++ b/augur/application/db/models/augur_data.py
@@ -929,6 +929,44 @@ def is_valid_github_repo(gh_session, url: str) -> bool:
                 return False, {"status": f"Github Error: {data['message']}"}
 
             return True, {"status": "Valid repo", "repo_type": data["owner"]["type"]}
+        
+    @staticmethod
+    def is_valid_gitlab_repo(gl_session, url: str) -> bool:
+        """Determine whether a GitLab repo URL is valid.
+
+        Args:
+            gl_session: GitLab session object with API key
+            url: Repository URL
+
+        Returns:
+            True if repo URL is valid, False otherwise
+        """
+        from augur.tasks.github.util.github_paginator import hit_api
+
+        REPO_ENDPOINT = "https://gitlab.com/api/v4/projects/{}/"
+
+        owner, repo = Repo.parse_gitlab_repo_url(url)
+        if not owner or not repo:
+            return False, {"status": "Invalid repo URL"}
+
+        # Encode namespace and project name for the API request
+        project_identifier = f"{owner}%2F{repo}"
+        url = REPO_ENDPOINT.format(project_identifier)
+
+        attempts = 0
+        while attempts < 10:
+            response = hit_api(gl_session.oauths, url, logger)
+
+            if response.status_code == 404:
+                return False, {"status": "Invalid repo"}
+
+            if response.status_code == 200:
+                return True, {"status": "Valid repo"}
+
+            attempts += 1
+
+        return False, {"status": "Failed to validate repo after multiple attempts"}
+
 
     @staticmethod
     def parse_github_repo_url(url: str) -> tuple:
@@ -948,6 +986,29 @@ def parse_github_repo_url(url: str) -> tuple:
 
         capturing_groups = result.groups()
 
+        owner = capturing_groups[0]
+        repo = capturing_groups[1]
+
+        return owner, repo
+    
+    @staticmethod
+    def parse_gitlab_repo_url(url: str) -> tuple:
+        """ Gets the owner and repo from a gitlab url.
+
+        Args:
+            url: Gitlab url
+
+        Returns:
+            Tuple of owner and repo. Or a tuple of None and None if the url is invalid.
+        """
+        
+        result = re.search(r"https?:\/\/gitlab\.com\/([A-Za-z0-9 \- _]+)\/([A-Za-z0-9 \- _ \.]+)(.git)?\/?$", url)
+
+        if not result:
+            return None, None
+
+        capturing_groups = result.groups()
+
 
         owner = capturing_groups[0]
         repo = capturing_groups[1]
@@ -974,7 +1035,54 @@ def parse_github_org_url(url):
         return result.groups()[0]
 
     @staticmethod
-    def insert(session, url: str, repo_group_id: int, tool_source, repo_type):
+    def insert_gitlab_repo(session, url: str, repo_group_id: int, tool_source):
+        """Add a repo to the repo table.
+
+        Args:
+            url: repo url
+            repo_group_id: group to assign repo to
+
+        Note:
+            If repo row exists then it will update the repo_group_id if param repo_group_id is not a default. If it does not exist is will simply insert the repo.
+        """
+
+        if not isinstance(url, str) or not isinstance(repo_group_id, int) or not isinstance(tool_source, str):
+            return None
+
+        if not RepoGroup.is_valid_repo_group_id(session, repo_group_id):
+            return None
+        
+        if url.endswith("/"):
+            url = url[:-1]
+        
+        url = url.lower()
+        
+        owner, repo = Repo.parse_gitlab_repo_url(url)
+        if not owner or not repo:
+            return None
+
+        repo_data = {
+            "repo_group_id": repo_group_id,
+            "repo_git": url,
+            "repo_path": f"gitlab.com/{owner}/",
+            "repo_name": repo,
+            "repo_type": None,
+            "tool_source": tool_source,
+            "tool_version": "1.0",
+            "data_source": "Git"
+        }
+
+        repo_unique = ["repo_git"]
+        return_columns = ["repo_id"]
+        result = session.insert_data(repo_data, Repo, repo_unique, return_columns, on_conflict_update=False)
+
+        if not result:
+            return None
+
+        return result[0]["repo_id"]
+
+    @staticmethod
+    def insert_github_repo(session, url: str, repo_group_id: int, tool_source, repo_type):
         """Add a repo to the repo table.
 
         Args:
diff --git a/augur/application/db/models/augur_operations.py b/augur/application/db/models/augur_operations.py
index 63b9144b35..8da2b397fa 100644
--- a/augur/application/db/models/augur_operations.py
+++ b/augur/application/db/models/augur_operations.py
@@ -449,17 +449,30 @@ def remove_group(self, group_name):
 
         return result
 
-    def add_repo(self, group_name, repo_url):
+    def add_github_repo(self, group_name, repo_url):
 
         from augur.tasks.github.util.github_task_session import GithubTaskSession
         from augur.tasks.github.util.github_api_key_handler import NoValidKeysError
         try:
             with GithubTaskSession(logger) as session:
-                result = UserRepo.add(session, repo_url, self.user_id, group_name)
+                result = UserRepo.add_github_repo(session, repo_url, self.user_id, group_name)
         except NoValidKeysError:
             return False, {"status": "No valid keys"}
 
         return result
+    
+    def add_gitlab_repo(self, group_name, repo_url):
+        
+        from augur.tasks.gitlab.gitlab_task_session import GitlabTaskSession
+        from augur.tasks.github.util.github_api_key_handler import NoValidKeysError
+        try:
+            with GitlabTaskSession(logger) as session:
+                result = UserRepo.add_gitlab_repo(session, repo_url, self.user_id, group_name)
+        except NoValidKeysError:
+            return False, {"status": "No valid keys"}
+
+        return result
+
 
     def remove_repo(self, group_name, repo_id):
 
@@ -468,14 +481,14 @@ def remove_repo(self, group_name, repo_id):
 
         return result
 
-    def add_org(self, group_name, org_url):
+    def add_github_org(self, group_name, org_url):
 
         from augur.tasks.github.util.github_task_session import GithubTaskSession
         from augur.tasks.github.util.github_api_key_handler import NoValidKeysError
 
         try:
             with GithubTaskSession(logger) as session:
-                result = UserRepo.add_org_repos(session, org_url, self.user_id, group_name)
+                result = UserRepo.add_github_org_repos(session, org_url, self.user_id, group_name)
         except NoValidKeysError:
             return False, {"status": "No valid keys"}
 
@@ -769,9 +782,69 @@ def insert(session, repo_id: int, group_id:int = 1) -> bool:
             return False
 
         return data[0]["group_id"] == group_id and data[0]["repo_id"] == repo_id
+    
+    @staticmethod
+    def add_gitlab_repo(session, url: List[str], user_id: int, group_name=None, group_id=None, from_org_list=False, repo_group_id=None) -> dict:
+        """Add repo to the user repo table
+
+        Args:
+            urls: list of repo urls
+            user_id: id of user_id from users table
+            group_name: name of group to add repo to.
+            group_id: id of the group
+            valid_repo: boolean that indicates whether the repo has already been validated
+
+        Note:
+            Either the group_name or group_id can be passed not both
+
+        Returns:
+            Dict that contains the key "status" and additional useful data
+        """
+
+        if group_name and group_id:
+            return False, {"status": "Pass only the group name or group id not both"}
+
+        if not group_name and not group_id:
+            return False, {"status": "Need group name or group id to add a repo"}
+
+        if group_id is None:
+
+            group_id = UserGroup.convert_group_name_to_id(session, user_id, group_name)
+            if group_id is None:
+                return False, {"status": "Invalid group name"}
+
+        if not from_org_list:
+            result = Repo.is_valid_gitlab_repo(session, url)
+            if not result[0]:
+                return False, {"status": result[1]["status"], "repo_url": url}
+
+        # if no repo_group_id is passed then assign the repo to the frontend repo group
+        if repo_group_id is None:
+
+            frontend_repo_group = session.query(RepoGroup).filter(RepoGroup.rg_name == FRONTEND_REPO_GROUP_NAME).first()
+            if not frontend_repo_group:
+                return False, {"status": "Could not find repo group with name 'Frontend Repos'", "repo_url": url}
+
+            repo_group_id = frontend_repo_group.repo_group_id
+
+
+        repo_id = Repo.insert_gitlab_repo(session, url, repo_group_id, "Frontend")
+        if not repo_id:
+            return False, {"status": "Repo insertion failed", "repo_url": url}
+
+        result = UserRepo.insert(session, repo_id, group_id)
+        if not result:
+            return False, {"status": "repo_user insertion failed", "repo_url": url}
+
+        #collection_status records are now only added during collection -IM 5/1/23
+        #status = CollectionStatus.insert(session, repo_id)
+        #if not status:
+        #    return False, {"status": "Failed to create status for repo", "repo_url": url}
+
+        return True, {"status": "Repo Added", "repo_url": url}
 
     @staticmethod
-    def add(session, url: List[str], user_id: int, group_name=None, group_id=None, from_org_list=False, repo_type=None, repo_group_id=None) -> dict:
+    def add_github_repo(session, url: List[str], user_id: int, group_name=None, group_id=None, from_org_list=False, repo_type=None, repo_group_id=None) -> dict:
         """Add repo to the user repo table
 
         Args:
@@ -820,7 +893,7 @@ def add(session, url: List[str], user_id: int, group_name=None, group_id=None, f
             repo_group_id = frontend_repo_group.repo_group_id
 
 
-        repo_id = Repo.insert(session, url, repo_group_id, "Frontend", repo_type)
+        repo_id = Repo.insert_github_repo(session, url, repo_group_id, "Frontend", repo_type)
         if not repo_id:
             return False, {"status": "Repo insertion failed", "repo_url": url}
 
@@ -862,7 +935,7 @@ def delete(session, repo_id:int, user_id:int, group_name:str) -> dict:
         return True, {"status": "Repo Removed"}
 
     @staticmethod
-    def add_org_repos(session, url: List[str], user_id: int, group_name: int):
+    def add_github_org_repos(session, url: List[str], user_id: int, group_name: int):
         """Add list of orgs and their repos to a users repos.
 
         Args:
@@ -911,7 +984,7 @@ def add_org_repos(session, url: List[str], user_id: int, group_name: int):
         failed_repos = []
         for repo in repos:
 
-            result = UserRepo.add(session, repo, user_id, group_id=group_id, from_org_list=True, repo_type=type, repo_group_id=repo_group_id)
+            result = UserRepo.add_github_repo(session, repo, user_id, group_id=group_id, from_org_list=True, repo_type=type, repo_group_id=repo_group_id)
 
             # keep track of all the repos that failed
             if not result[0]:
diff --git a/augur/tasks/frontend.py b/augur/tasks/frontend.py
index b8eb8b203c..fffd79d330 100644
--- a/augur/tasks/frontend.py
+++ b/augur/tasks/frontend.py
@@ -30,15 +30,15 @@ def add_org_repo_list(user_id, group_name, urls):
     valid_repos = []
     for url in urls:
 
-        # matches https://github.com/{org}/ or htts://github.com/{org}
+        # matches https://github.com/{org}/ or http://github.com/{org}
         if Repo.parse_github_org_url(url):
-            added = user.add_org(group_name, url)[0]
+            added = user.add_github_org(group_name, url)[0]
             if added:
                 valid_orgs.append(url)
 
-        # matches https://github.com/{org}/{repo}/ or htts://github.com/{org}/{repo}
+        # matches https://github.com/{org}/{repo}/ or http://github.com/{org}/{repo}
         elif Repo.parse_github_repo_url(url)[0]:
-            added = user.add_repo(group_name, url)[0]
+            added = user.add_github_repo(group_name, url)[0]
             if added:
                 valid_repos.append(url)
 
@@ -46,7 +46,7 @@ def add_org_repo_list(user_id, group_name, urls):
         elif (match := parse_org_and_repo_name(url)):
             org, repo = match.groups()
             repo_url = f"https://github.com/{org}/{repo}/"
-            added = user.add_repo(group_name, repo_url)[0]
+            added = user.add_github_repo(group_name, repo_url)[0]
             if added:
                 valid_repos.append(url)
 
@@ -54,9 +54,17 @@ def add_org_repo_list(user_id, group_name, urls):
         elif (match := parse_org_name(url)):
             org = match.group(1)
             org_url = f"https://github.com/{org}/"
-            added = user.add_org(group_name, org_url)[0]
+            added = user.add_github_org(group_name, org_url)[0]
             if added:
                 valid_orgs.append(url)
+
+        # matches https://gitlab.com/{org}/{repo}/ or http://gitlab.com/{org}/{repo}
+        elif Repo.parse_gitlab_repo_url(url)[0]:
+
+            added = user.add_gitlab_repo(group_name, url)[0]
+            if added:
+                valid_repos.append(url)
+
         else:
             invalid_urls.append(url)
 
@@ -66,24 +74,25 @@ def add_org_repo_list(user_id, group_name, urls):
     
 
 
-
+# TODO: Change to github specific
 @celery.task
 def add_repo(user_id, group_name, repo_url):
 
     logger = logging.getLogger(add_org.__name__) 
 
     with GithubTaskSession(logger) as session:
-        result = UserRepo.add(session, repo_url, user_id, group_name)
+        result = UserRepo.add_github_repo(session, repo_url, user_id, group_name)
 
     print(repo_url, result)
 
 
+# TODO: Change to github specific
 @celery.task
 def add_org(user_id, group_name, org_url):
 
     logger = logging.getLogger(add_org.__name__) 
 
     with GithubTaskSession(logger) as session:
-            result = UserRepo.add_org_repos(session, org_url, user_id, group_name)
+            result = UserRepo.add_github_org_repos(session, org_url, user_id, group_name)
 
     print(org_url, result)
diff --git a/augur/tasks/github/util/github_api_key_handler.py b/augur/tasks/github/util/github_api_key_handler.py
index 8a19430e87..20ce07f066 100644
--- a/augur/tasks/github/util/github_api_key_handler.py
+++ b/augur/tasks/github/util/github_api_key_handler.py
@@ -32,7 +32,7 @@ def __init__(self, session: DatabaseSession):
         self.logger = session.logger
         self.config = AugurConfig(self.logger, session)
 
-        self.oauth_redis_key = "oauth_keys_list"
+        self.oauth_redis_key = "github_oauth_keys_list"
 
         self.redis_key_list = RedisList(self.oauth_redis_key)
 
diff --git a/augur/tasks/gitlab/gitlab_api_key_handler.py b/augur/tasks/gitlab/gitlab_api_key_handler.py
new file mode 100644
index 0000000000..7e6b359f5e
--- /dev/null
+++ b/augur/tasks/gitlab/gitlab_api_key_handler.py
@@ -0,0 +1,169 @@
+import httpx
+import time
+import random
+
+from typing import Optional, List
+
+from augur.tasks.util.redis_list import RedisList
+from augur.application.db.session import DatabaseSession
+from augur.application.config import AugurConfig
+from sqlalchemy import func 
+
+
+class NoValidKeysError(Exception):
+    pass
+
+
+class GitlabApiKeyHandler():
+    """Handles Gitlab API key retrieval from the database and redis
+
+    Attributes:
+        session (DatabaseSession): Database connection
+        logger (logging.Logger): Handles all logs
+        oauth_redis_key (str): The key where the github api keys are cached in redis
+        redis_key_list (RedisList): Acts like a python list, and interacts directly with the redis cache
+        config_key (str): The api key that is stored in the users config table
+        key: (List[str]): List of keys retrieve from database or cache
+    """
+
+    def __init__(self, session: DatabaseSession):
+
+        self.session = session
+        self.logger = session.logger
+        self.config = AugurConfig(self.logger, session)
+
+        self.oauth_redis_key = "gitlab_oauth_keys_list"
+
+        self.redis_key_list = RedisList(self.oauth_redis_key)
+
+        self.config_key = self.get_config_key()
+
+        self.keys = self.get_api_keys()
+
+        self.logger.info(f"Retrieved {len(self.keys)} gitlab api keys for use")
+
+    def get_random_key(self):
+        """Retrieves a random key from the list of keys
+
+        Returns:
+            A random github api key
+        """
+
+        return random.choice(self.keys)
+
+    def get_config_key(self) -> str:
+        """Retrieves the users github api key from their config table
+
+        Returns:
+            Github API key from config table
+        """
+        return self.config.get_value("Keys", "gitlab_api_key")
+
+    def get_api_keys_from_database(self) -> List[str]:
+        """Retieves all github api keys from database
+
+        Note:
+            It retrieves all the keys from the database except the one defined in the users config
+
+        Returns:
+            Github api keys that are in the database
+        """
+        from augur.application.db.models import WorkerOauth
+
+        select = WorkerOauth.access_token
+        # randomizing the order at db time
+        #select.order_by(func.random())
+        where = [WorkerOauth.access_token != self.config_key, WorkerOauth.platform == 'gitlab']
+
+        return [key_tuple[0] for key_tuple in self.session.query(select).filter(*where).order_by(func.random()).all()]
+        #return [key_tuple[0] for key_tuple in self.session.query(select).filter(*where).all()]
+
+
+    def get_api_keys(self) -> List[str]:
+        """Retrieves all valid Github API Keys
+
+        Note:
+            It checks to see if the keys are in the redis cache first.
+            It removes bad keys before returning.
+            If keys were taken from the database, it caches all the valid keys that were found
+
+        Returns:
+            Valid Github api keys
+        """
+
+        redis_keys = list(self.redis_key_list)
+
+        if redis_keys:
+            return redis_keys
+
+        attempts = 0
+        while attempts < 3:
+
+            try:
+                keys = self.get_api_keys_from_database()
+                break
+            except:
+                time.sleep(5)
+                attempts += 1
+
+        if self.config_key is not None:
+            keys += [self.config_key]
+
+        if len(keys) == 0:
+            return []
+
+        valid_keys = []
+        with httpx.Client() as client:
+
+            for key in keys:
+
+                # removes key if it returns "Bad Credentials"
+                if self.is_bad_api_key(client, key) is False:
+                    valid_keys.append(key)
+                else:
+                    print(f"WARNING: The key '{key}' is not a valid key. Hint: If valid in past it may have expired")
+
+        # just in case the mulitprocessing adds extra values to the list.
+        # we are clearing it before we push the values we got
+        self.redis_key_list.clear()
+
+        # add all the keys to redis
+        self.redis_key_list.extend(valid_keys)
+
+        if not valid_keys:
+            raise NoValidKeysError("No valid github api keys found in the config or worker oauth table")
+
+
+        # shuffling the keys so not all processes get the same keys in the same order
+        valid_now = valid_keys
+        #try: 
+            #self.logger.info(f'valid keys before shuffle: {valid_keys}')
+            #valid_keys = random.sample(valid_keys, len(valid_keys))
+            #self.logger.info(f'valid keys AFTER shuffle: {valid_keys}')
+        #except Exception as e: 
+         #   self.logger.debug(f'{e}')
+         #   valid_keys = valid_now
+         #   pass 
+
+        return valid_keys
+
+    def is_bad_api_key(self, client: httpx.Client, oauth_key: str) -> bool:
+        """Determines if a Gitlab API key is bad
+
+        Args:
+            client: makes the http requests
+            oauth_key: github api key that is being tested
+
+        Returns:
+            True if key is bad. False if the key is good
+        """
+
+        url = "https://gitlab.com/api/v4/user"
+
+        headers = {'Authorization': f'Bearer {oauth_key}'}
+
+        response = client.request(method="GET", url=url, headers=headers, timeout=180)
+        if response.status_code == 401:
+            return True
+        
+        return False
\ No newline at end of file
diff --git a/augur/tasks/gitlab/gitlab_random_key_auth.py b/augur/tasks/gitlab/gitlab_random_key_auth.py
new file mode 100644
index 0000000000..86ad64b056
--- /dev/null
+++ b/augur/tasks/gitlab/gitlab_random_key_auth.py
@@ -0,0 +1,26 @@
+"""Defines the GitlabRandomKeyAuth class"""
+
+from augur.tasks.util.random_key_auth import RandomKeyAuth
+from augur.tasks.gitlab.gitlab_api_key_handler import GitlabApiKeyHandler
+from augur.application.db.session import DatabaseSession
+
+
+class GitlabRandomKeyAuth(RandomKeyAuth):
+    """Defines a github specific RandomKeyAuth class so 
+    github collections can have a class randomly selects an api key for each request    
+    """
+
+    def __init__(self, session: DatabaseSession, logger):
+        """Creates a GitlabRandomKeyAuth object and initializes the RandomKeyAuth parent class"""
+
+    
+        # gets the gitlab api keys from the database via the GitlabApiKeyHandler
+        gitlab_api_keys = GitlabApiKeyHandler(session).keys
+
+        if not gitlab_api_keys:
+            print("Failed to find github api keys. This is usually because your key has expired")
+
+        header_name = "Authorization"
+        key_format = "Bearer {0}"
+
+        super().__init__(gitlab_api_keys, header_name, session.logger, key_format)
\ No newline at end of file
diff --git a/augur/tasks/gitlab/gitlab_task_session.py b/augur/tasks/gitlab/gitlab_task_session.py
new file mode 100644
index 0000000000..1871e46c50
--- /dev/null
+++ b/augur/tasks/gitlab/gitlab_task_session.py
@@ -0,0 +1,43 @@
+from logging import Logger
+
+from augur.tasks.gitlab.gitlab_random_key_auth import GitlabRandomKeyAuth
+from augur.application.db.session import DatabaseSession
+
+class GitlabTaskManifest:
+
+    def __init__(self, logger):
+
+        from augur.tasks.init.celery_app import engine
+        from augur.application.db.session import DatabaseSession
+
+        self.augur_db = DatabaseSession(logger, engine)
+        self.key_auth = GitlabRandomKeyAuth(self.augur_db.session, logger)
+        self.logger = logger
+        self.platform_id = 2
+
+    def __enter__(self):
+
+        return self
+
+    def __exit__(self, exception_type, exception_value, exception_traceback):
+
+        self.augur_db.close()
+
+class GitlabTaskSession(DatabaseSession):
+    """ORM session used in gitlab tasks.
+        This class adds the platform_id and the gitlab key authentication class,
+        to the already existing DatabaseSession so there is a central location to access
+        api keys and a single platform_id reference
+
+    Attributes:
+        oauths (GitlabRandomKeyAuth): Class that handles randomly assigning gitlab api keys to httpx requests
+        platform_id (int): The id that refers to the Gitlab platform
+    """
+
+    def __init__(self, logger: Logger, engine=None):
+
+        super().__init__(logger, engine=engine)
+
+        self.oauths = GitlabRandomKeyAuth(self, logger)
+        self.platform_id = 2
+        
diff --git a/augur/tasks/util/collection_util.py b/augur/tasks/util/collection_util.py
index 4d5b663a20..1d5ddd79c5 100644
--- a/augur/tasks/util/collection_util.py
+++ b/augur/tasks/util/collection_util.py
@@ -587,27 +587,28 @@ def send_messages(self):
         for col_hook in self.collection_hooks:
 
             self.logger.info(f"Starting collection on {len(col_hook.repo_list)} {col_hook.name} repos")
-
+            
             for repo_git in col_hook.repo_list:
 
-                #repo = self.session.query(Repo).filter(Repo.repo_git == repo_git).one()
-                #repo_id = repo.repo_id
-
-                augur_collection_sequence = []
-                for job in col_hook.phases:
-                    #Add the phase to the sequence in order as a celery task.
-                    #The preliminary task creates the larger task chain 
-                    augur_collection_sequence.append(job(repo_git))
-
-                #augur_collection_sequence.append(core_task_success_util.si(repo_git))
-                #Link all phases in a chain and send to celery
-                augur_collection_chain = chain(*augur_collection_sequence)
-                task_id = augur_collection_chain.apply_async().task_id
-
-                self.logger.info(f"Setting repo {col_hook.name} status to collecting for repo: {repo_git}")
-
-                #yield the value of the task_id to the calling method so that the proper collectionStatus field can be updated
-                yield repo_git, task_id, col_hook.name
+                repo = self.session.query(Repo).filter(Repo.repo_git == repo_git).one()
+                if "github" in repo.repo_git:
+                    augur_collection_sequence = []
+                    for job in col_hook.phases:
+                        #Add the phase to the sequence in order as a celery task.
+                        #The preliminary task creates the larger task chain 
+                        augur_collection_sequence.append(job(repo_git))
+
+                    #augur_collection_sequence.append(core_task_success_util.si(repo_git))
+                    #Link all phases in a chain and send to celery
+                    augur_collection_chain = chain(*augur_collection_sequence)
+                    task_id = augur_collection_chain.apply_async().task_id
+
+                    self.logger.info(f"Setting repo {col_hook.name} status to collecting for repo: {repo_git}")
+
+                    #yield the value of the task_id to the calling method so that the proper collectionStatus field can be updated
+                    yield repo_git, task_id, col_hook.name
+                else:
+                    print(f"Unable to start collection for {repo.repo_git}")
 
 #def start_block_of_repos(logger,session,repo_git_identifiers,phases,repos_type,hook="core"):
 #
diff --git a/augur/util/repo_load_controller.py b/augur/util/repo_load_controller.py
index b5ff5d07a0..943e3373a6 100644
--- a/augur/util/repo_load_controller.py
+++ b/augur/util/repo_load_controller.py
@@ -62,7 +62,7 @@ def add_cli_repo(self, repo_data: Dict[str, Any], from_org_list=False, repo_type
 
 
         # if the repo doesn't exist it adds it
-        repo_id = Repo.insert(self.session, url, repo_group_id, "CLI", repo_type)
+        repo_id = Repo.insert_github_repo(self.session, url, repo_group_id, "CLI", repo_type)
 
         if not repo_id:
             logger.warning(f"Invalid repo group id specified for {url}, skipping.")
diff --git a/tests/test_applicaton/test_db/test_models/test_augur_data/test_repo.py b/tests/test_applicaton/test_db/test_models/test_augur_data/test_repo.py
index bf22254244..1c32472f32 100644
--- a/tests/test_applicaton/test_db/test_models/test_augur_data/test_repo.py
+++ b/tests/test_applicaton/test_db/test_models/test_augur_data/test_repo.py
@@ -77,20 +77,20 @@ def test_insert_repo(test_db_engine):
 
         with DatabaseSession(logger, test_db_engine) as session:
             
-            assert Repo.insert(session, data["repo_urls"][0], data["rg_id"], data["tool_source"]) is not None
-            assert Repo.insert(session, data["repo_urls"][1], data["rg_id"], data["tool_source"]) is not None
+            assert Repo.insert_github_repo(session, data["repo_urls"][0], data["rg_id"], data["tool_source"]) is not None
+            assert Repo.insert_github_repo(session, data["repo_urls"][1], data["rg_id"], data["tool_source"]) is not None
 
             # invalid rg_id
-            assert Repo.insert(session, data["repo_urls"][0], 12, data["tool_source"]) is None
+            assert Repo.insert_github_repo(session, data["repo_urls"][0], 12, data["tool_source"]) is None
 
             # invalid type for repo url
-            assert Repo.insert(session, 1, data["rg_id"], data["tool_source"]) is None
+            assert Repo.insert_github_repo(session, 1, data["rg_id"], data["tool_source"]) is None
 
             # invalid type for rg_id
-            assert Repo.insert(session, data["repo_urls"][1], "1", data["tool_source"]) is None
+            assert Repo.insert_github_repo(session, data["repo_urls"][1], "1", data["tool_source"]) is None
 
             # invalid type for tool_source
-            assert Repo.insert(session, data["repo_urls"][1], data["rg_id"], 52) is None
+            assert Repo.insert_github_repo(session, data["repo_urls"][1], data["rg_id"], 52) is None
 
         with test_db_engine.connect() as connection:
 
diff --git a/tests/test_applicaton/test_db/test_models/test_augur_operations/test_user_repo.py b/tests/test_applicaton/test_db/test_models/test_augur_operations/test_user_repo.py
index 3fc5451791..4b288cbabb 100644
--- a/tests/test_applicaton/test_db/test_models/test_augur_operations/test_user_repo.py
+++ b/tests/test_applicaton/test_db/test_models/test_augur_operations/test_user_repo.py
@@ -124,7 +124,7 @@ def test_add_frontend_repos_with_invalid_repo(test_db_engine):
 
         with GithubTaskSession(logger, test_db_engine) as session:
 
-            result = UserRepo.add(session, url, data["user_id"], data["user_group_name"])
+            result = UserRepo.add_github_repo(session, url, data["user_id"], data["user_group_name"])
 
             assert result[1]["status"] == "Invalid repo"
 
@@ -163,11 +163,11 @@ def test_add_frontend_repos_with_duplicates(test_db_engine):
 
         with GithubTaskSession(logger, test_db_engine) as session:
 
-            result = UserRepo.add(session, url, data["user_id"], data["user_group_name"])
-            result2 = UserRepo.add(session, url, data["user_id"], data["user_group_name"])
+            result = UserRepo.add_github_repo(session, url, data["user_id"], data["user_group_name"])
+            result2 = UserRepo.add_github_repo(session, url, data["user_id"], data["user_group_name"])
 
             # add repo with invalid group name
-            result3 = UserRepo.add(session, url, data["user_id"], "Invalid group name")
+            result3 = UserRepo.add_github_repo(session, url, data["user_id"], "Invalid group name")
 
             assert result[1]["status"] == "Repo Added"
             assert result2[1]["status"] == "Repo Added"
@@ -263,11 +263,11 @@ def test_add_frontend_org_with_invalid_org(test_db_engine):
         with GithubTaskSession(logger, test_db_engine) as session:
 
             url = f"https://github.com/{data['org_name']}/"
-            result = UserRepo.add_org_repos(session, url, data["user_id"], data["user_group_name"])
+            result = UserRepo.add_github_org_repos(session, url, data["user_id"], data["user_group_name"])
             assert result[1]["status"] == "Invalid owner url"
 
             # test with invalid group name
-            result = UserRepo.add_org_repos(session, url, data["user_id"], "Invalid group name")
+            result = UserRepo.add_github_org_repos(session, url, data["user_id"], "Invalid group name")
             assert result[1]["status"] == "Invalid group name"
 
         with test_db_engine.connect() as connection:
@@ -305,7 +305,7 @@ def test_add_frontend_org_with_valid_org(test_db_engine):
         with GithubTaskSession(logger, test_db_engine) as session:
 
             url = "https://github.com/{}/".format(data["org_name"])
-            result = UserRepo.add_org_repos(session, url, data["user_id"], data["user_group_name"])
+            result = UserRepo.add_github_org_repos(session, url, data["user_id"], data["user_group_name"])
             assert result[1]["status"] == "Org repos added"
 
         with test_db_engine.connect() as connection: