diff --git a/.gitignore b/.gitignore
index 22c24e8..d9b0a1c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -35,7 +35,7 @@ __pycache__/
 tests/*.log
 
 # Project-specific things to ignore ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
+venv
 build
 dist
 docs/_build
diff --git a/dev/scripts/filter-github-orgs b/dev/scripts/filter-github-orgs
index 456cdf0..65105a4 100755
--- a/dev/scripts/filter-github-orgs
+++ b/dev/scripts/filter-github-orgs
@@ -451,8 +451,16 @@ def _alert(ctx, msg, print_usage=True):
         STYLE_OPTION,
         STYLE_ARGUMENT,
         STYLE_SWITCH,
-        OptionHighlighter,
     )
+    from rich.highlighter import RegexHighlighter
+    class OptionHighlighter(RegexHighlighter):
+            """Highlights our special options."""
+
+            highlights = [
+                r"(^|[^\w\-])(?P<switch>-([^\W0-9][\w\-]*\w|[^\W0-9]))",
+                r"(^|[^\w\-])(?P<option>--([^\W0-9][\w\-]*\w|[^\W0-9]))",
+                r"(?P<metavar><[^>]+>)",
+            ]
     highlighter = OptionHighlighter()
     console = Console(theme=Theme({
         "option": STYLE_OPTION,
diff --git a/dev/scripts/list-github-orgs b/dev/scripts/list-github-orgs
index f53f626..7ed92bf 100755
--- a/dev/scripts/list-github-orgs
+++ b/dev/scripts/list-github-orgs
@@ -308,8 +308,16 @@ def _alert(ctx, msg, print_usage=True):
         STYLE_OPTION,
         STYLE_ARGUMENT,
         STYLE_SWITCH,
-        OptionHighlighter,
     )
+    from rich.highlighter import RegexHighlighter
+    class OptionHighlighter(RegexHighlighter):
+            """Highlights our special options."""
+
+            highlights = [
+                r"(^|[^\w\-])(?P<switch>-([^\W0-9][\w\-]*\w|[^\W0-9]))",
+                r"(^|[^\w\-])(?P<option>--([^\W0-9][\w\-]*\w|[^\W0-9]))",
+                r"(?P<metavar><[^>]+>)",
+            ]
     highlighter = OptionHighlighter()
     console = Console(theme=Theme({
         "option": STYLE_OPTION,
diff --git a/iga/cli.py b/iga/cli.py
index 22990e3..0d1778e 100644
--- a/iga/cli.py
+++ b/iga/cli.py
@@ -10,6 +10,7 @@
 
 import bdb
 import os
+import urllib.parse
 import rich
 from   rich.console import Console
 from   rich.style import Style
@@ -21,12 +22,13 @@
 from iga import __version__
 from iga.exit_codes import ExitCode
 from iga.exceptions import GitHubError, InvenioRDMError, RecordNotFound
-from iga.github import (
-    github_account_repo_tag,
-    github_release,
-    github_release_assets,
-    valid_github_release_url,
+
+from iga.githublab import (
+    valid_release_url,
+    git_release_assets,
+    git_account_repo_tag,
 )
+
 from iga.id_utils import is_inveniordm_id
 from iga.invenio import (
     invenio_api_available,
@@ -39,7 +41,6 @@
     invenio_upload,
 )
 
-
 # Main command-line interface.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -133,6 +134,12 @@ def _read_github_token(ctx, param, value):
                              'GitHub personal access token', required=False)
 
 
+def _read_gitlab_token(ctx, param, value):
+    '''Read the file and set the environment variable GITLAB_TOKEN.'''
+    return _read_param_value(ctx, param, value, 'GITLAB_TOKEN',
+                             'GitLab personal access token', required=False)
+
+
 def _read_invenio_token(ctx, param, value):
     '''Read the file and set the environment variable INVENIO_TOKEN.'''
     return _read_param_value(ctx, param, value, 'INVENIO_TOKEN',
@@ -275,8 +282,16 @@ def _alert(ctx, msg, print_usage=True):
         STYLE_OPTION,
         STYLE_ARGUMENT,
         STYLE_SWITCH,
-        OptionHighlighter,
     )
+    from rich.highlighter import RegexHighlighter
+    class OptionHighlighter(RegexHighlighter):
+            """Highlights our special options."""
+
+            highlights = [
+                r"(^|[^\w\-])(?P<switch>-([^\W0-9][\w\-]*\w|[^\W0-9]))",
+                r"(^|[^\w\-])(?P<option>--([^\W0-9][\w\-]*\w|[^\W0-9]))",
+                r"(?P<metavar><[^>]+>)",
+            ]
     highlighter = OptionHighlighter()
     console = Console(theme=Theme({
         "option": STYLE_OPTION,
@@ -377,6 +392,20 @@ def _list_communities(ctx, param, value):
 #
 @click.option('--github-token', '-t', metavar='STR', callback=_read_github_token,
               help="GitHub acccess token (**avoid – use variable**)")
+#
+@click.option('--gitlab-token', '-t', metavar='STR', callback=_read_gitlab_token,
+              help="GitLab acccess token (**avoid – use variable**)")
+
+#
+@click.option('--gitlab', is_flag=True, help='Use GitLab mode')
+#
+@click.option('--gitlab-url', '-gu', metavar='STR',
+              help='GiLab base url (like https://gitlab.com or https://code.jlab.org)')
+#
+@click.option('--gitlab-projectid', '-gp', metavar='STR',
+              help='GiLab project ID (The ID or NAMESPACE/PROJECT_PATH)')
+
+
 #
 @click.help_option('--help', '-h', help='Show this help message and exit')
 #
@@ -421,16 +450,17 @@ def _list_communities(ctx, param, value):
 @click.argument('url_or_tag', required=True)
 @click.pass_context
 def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
-        files_to_upload=None, account=None, repo=None, github_token=None,
+        files_to_upload=None, account=None, repo=None, github_token=None, 
+        gitlab_token=None, gitlab_projectid=None, gitlab=False, gitlab_url=None,
         print_doi=False, server=None, invenio_token=None, list_communities=False,
         open_in_browser=False, log_dest=None, mode='normal', parent_id=None,
         all_metadata=False, source=None, dest=None, timeout=None,
         help=False, version=False):  # noqa A002
     '''InvenioRDM GitHub Archiver (IGA) command-line interface.
 \r
-IGA creates a metadata record in an InvenioRDM server and attaches a GitHub
-release archive to the record. The GitHub release can be specified using
-_either_ a full release URL, _or_ a combination of GitHub account + repository
+IGA creates a metadata record in an InvenioRDM server and attaches a GitHub/GitLab
+release archive to the record. The GitHub/GitLab release can be specified using
+_either_ a full release URL, _or_ a combination of  account + repository
 \\+ tag. Different command-line options can be used to adjust this behavior.
 \r
 _**Specification of the InvenioRDM server and access token**_
@@ -451,7 +481,9 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
 \r
 _**Specification of a GitHub release**_
 \r
-A GitHub release can be specified to IGA in one of two mutually-exclusive ways:
+A GitHub/GitLab release can be specified to IGA in one of two mutually-exclusive ways:
+\r
+For GitHub:
  1. The full URL of the web page on GitHub of a tagged release. In this case,
     the URL must be the final argument on the command line invocation of IGA
     and the options `--account` and `--repo` must be omitted.
@@ -459,31 +491,59 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
     case, the final argument on the command line must be the _tag_, and in
     addition, values for the options `--account` and `--repo` must be provided.
 \r
+For GitLab:
+ 1. The full URL of the web page on GitLab of a tagged release with `--gitlab`. In this case,
+    the URL must be the final argument on the command line invocation of IGA
+ 2. A combination of (`--gitlab`, `--github-account`, `--github-repo` and _tag_ ) or 
+    a combination of (`--gitlab`, `--gitlab-projectid` and __tag_ ) must be provided.
+    The `--gitlab-projectid` can be a id of the project. specified in,
+    (https://docs.gitlab.com/ee/user/project/working_with_projects.html#access-a-project-by-using-the-project-id)
+    or a full path of the project NAMESPACE/PROJECT_PATH .
+\r
 Here's an example using approach #1 (assuming environment variables
 INVENIO_SERVER, INVENIO_TOKEN, and GITHUB_TOKEN have all been set):
+\r
+Using GitHub:
 ```shell
   iga https://github.com/mhucka/taupe/releases/tag/v1.2.0
 ```
+\r
+Using GitLab (assuming environment variables GITLAB_TOKEN has been set):
+```shell
+  iga --gitlab https://code.jlab.org/panta/hcana_container_doc/-/releases/0.0.2  
+```
 and here's the equivalent using approach #2:
+\r
+Using GitHub:
 ```shell
   iga --github-account mhucka --github-repo taupe v1.2.0
+  ```
+\r
+Using GitLab:
+```shell
+  iga --gitlab-url https://code.jlab.org --gitlab --github-account panta --github-repo  hcana_container_doc  0.0.2
+  iga --gitlab-url https://code.jlab.org --gitlab --gitlab-projectid 31 0.1.0
+  iga --gitlab-url https://code.jlab.org --gitlab --gitlab-projectid physdiv/jrdb/inveniordm_jlab  0.1.0
 ```
-Note that when using this form of the command, the release tag ("v1.2.0" above)
+Note that when using this form of the command, the release tag ("v1.2.0"/"0.1.0"/"0.0.2" above)
 must be the last item given on the command line.
 \r
-_**Use of a GitHub access token**_
+_**Use of a GitHub/GitLab access token**_
 \r
 It is possible to run IGA without providing a GitHub access token. GitHub
-allows up to 60 API calls per minute when running without credentials, and
+allows up to 60 API calls per minute (and for GITLAB dpends upon configuration)
+when running without credentials, and
 though IGA makes several API calls to GitHub each time it runs, for many
 repositories, IGA will not hit the limit. However, if you run IGA multiple
 times in a row or your repository has many contributors, then you may need to
-supply a GitHub access token. The preferred way of doing that is to set the
-value of the environment variable `GITHUB_TOKEN`. Alternatively, you can use
-the option `--github-token` to pass the token on the command line, but **you
+supply a GitHub/GITLAB access token. The preferred way of doing that is to set the
+value of the environment variable `GITHUB_TOKEN`/`GITLAB_TOKEN`. Alternatively, you can use
+the option `--github-token`/`--gitlab_token` to pass the token on the command line, but **you
 are strongly advised to avoid this practice because it is insecure**.
 To obtain a PAT from GitHub, visit https://docs.github.com/en/authentication
 and follow the instructions for creating a "classic" personal access token.
+Or to obtain PAT from GitLab , visit 
+https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html .
 \r
 _**Construction of an InvenioRDM record**_
 \r
@@ -492,10 +552,10 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
 includes the following:
  * (if one exists) a `codemeta.json` file in the GitHub repository
  * (if one exists) a `CITATION.cff` file in the GitHub repository
- * data available from GitHub for the release
- * data available from GitHub for the repository
- * data available from GitHub for the account of the owner
- * data available from GitHub for the accounts of repository contributors
+ * data available from GitHub/GitLab for the release
+ * data available from GitHub/GitLab for the repository
+ * data available from GitHub/GitLab for the account of the owner
+ * data available from GitHub/GitLab for the accounts of repository contributors
  * file assets associated with the GitHub release
  * data available from ORCID.org for ORCID identifiers
  * data available from ROR.org for Research Organization Registry identifiers
@@ -504,7 +564,7 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
 \r
 IGA tries to use `CodeMeta.json` first and `CITATION.cff` second to fill out
 the fields of the InvenioRDM record. If neither of those files are present, IGA
-uses values from the GitHub repository instead. You can make it always use all
+uses values from the GitHub/GitLab repository instead. You can make it always use all
 sources of info with the option `--all-metadata`. Depending on how complete and
 up-to-date your `CodeMeta.json` and `CITATION.cff` are, this may or may not
 make the record more comprehensive and may or may not introduce redundancies or
@@ -513,18 +573,18 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
 To override the auto-created record, use the option `--read-record` followed
 by the path to a JSON file structured according to the InvenioRDM schema used
 by the destination server. When `--read-record` is provided, IGA does _not_
-extract the data above, but still obtains the file assets from GitHub.
+extract the data above, but still obtains the file assets from GitHub/GitLab.
 \r
-_**Specification of GitHub file assets**_
+_**Specification of GitHub/GitLab file assets**_
 \r
 By default, IGA attaches to the InvenioRDM record _only_ the ZIP file asset
-created by GitHub for the release. To make IGA attach all assets associated
-with the GitHub release, use the option `--all-assets`.
+created by GitHub/GitLab for the release. To make IGA attach all assets associated
+with the GitHub/GitLab release, use the option `--all-assets`.
 \r
 To upload specific file assets and override the default selections made by IGA,
 you can use the option `--file` followed by a path to a file to be uploaded.
 You can repeat the option `--file` to upload multiple file assets. Note that if
-`--file` is provided, then IGA _does not use any file assets from GitHub_; it
+`--file` is provided, then IGA _does not use any file assets from GitHub_ / GitLab_; it
 is the user's responsibility to supply all the files that should be uploaded.
 \r
 If both `--read-record` and `--file` are used, then IGA does not actually
@@ -627,13 +687,16 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
   1 = interrupted  
   2 = encountered a bad or missing value for an option  
   3 = encountered a problem with a file or directory  
-  4 = encountered a problem interacting with GitHub  
+  4 = encountered a problem interacting with GitHub/GitLab 
   5 = encountered a problem interacting with InvenioRDM  
   6 = the personal access token was rejected  
   7 = an exception or fatal error occurred  
 '''
+    if gitlab:
+        os.environ['GITLAB'] = 'True'
+    if gitlab_url:
+        os.environ['GITLAB_URL'] = gitlab_url
     # Process arguments & handle early exits ..................................
-
     if url_or_tag == 'help':  # Detect if the user typed "help" without dashes.
         _print_help_and_exit(ctx)
     elif url_or_tag.startswith('http'):
@@ -641,21 +704,51 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
             _alert(ctx, 'The use of a URL and the use of options `--account`'
                    " and `--repo` are mutually exclusive; can't use both.")
             sys.exit(int(ExitCode.bad_arg))
-        elif not valid_github_release_url(url_or_tag):
+        elif not valid_release_url(url_or_tag):
+                _alert(ctx, 'Malformed release URL: ' + str(url_or_tag))
+                sys.exit(int(ExitCode.bad_arg))
+        else:
+            account, repo, tag = git_account_repo_tag(url_or_tag)
+
+    elif not gitlab:
+        if not all([account, repo, url_or_tag]):
+            _alert(ctx, 'When not using a release URL, all of the following must be'
+                ' provided: the options `--account`, `--repo`, and a tag name.')
+            sys.exit(int(ExitCode.bad_arg))
+        tag = url_or_tag
+        url_or_tag = f'https://github.com/{account}/{repo}/releases/tag/{tag}'
+        if not valid_release_url(url_or_tag):
             _alert(ctx, 'Malformed release URL: ' + str(url_or_tag))
             sys.exit(int(ExitCode.bad_arg))
+
+    elif gitlab:
+        if gitlab_projectid and (account or repo):
+            _alert(ctx, 'Cannot use --gitlab-projectid with --github-account or --github-repo')
+            sys.exit(int(ExitCode.bad_arg))
+        if not (all([gitlab_url, gitlab_projectid, url_or_tag]) or all([gitlab_url, account, repo, url_or_tag])):
+            _alert(ctx, 'When using GitLab, all of the following must be'
+                ' provided: the options `--gitlab-url` and `--gitlab-projectid`. or  `--gitlab-url , --account , --repo ')
+            sys.exit(int(ExitCode.bad_arg))
+        if all([gitlab_url, gitlab_projectid, url_or_tag]):
+            tag = url_or_tag
+            gitlab_projectid = urllib.parse.quote_plus(gitlab_projectid)
+            url_or_tag = f'{gitlab_url}/api/v4/projects/{gitlab_projectid}/releases/{tag}'
+            if not valid_release_url(url_or_tag):
+                _alert(ctx, 'Malformed release URL: ' + str(url_or_tag))
+                sys.exit(int(ExitCode.bad_arg))
+        elif all([gitlab_url, account, repo, url_or_tag]):
+            tag = url_or_tag
+            gitlab_projectid = f'{account}%2F{repo}'
+            url_or_tag = f'{gitlab_url}/api/v4/projects/{gitlab_projectid}/releases/{tag}'
+            if not valid_release_url(url_or_tag):
+                _alert(ctx, 'Malformed release URL: ' + str(url_or_tag))
+                sys.exit(int(ExitCode.bad_arg))
         else:
-            account, repo, tag = github_account_repo_tag(url_or_tag)
-    elif not all([account, repo, url_or_tag]):
-        _alert(ctx, 'When not using a release URL, all of the following must be'
-               ' provided: the options `--account`, `--repo`, and a tag name.')
-        sys.exit(int(ExitCode.bad_arg))
+            _alert(ctx, 'Malformed release URL: ' + str(url_or_tag))
+            sys.exit(int(ExitCode.bad_arg))
+        repo = gitlab_projectid
     else:
-        tag = url_or_tag
-
-    if not github_release(account, repo, tag, test_only=True):
-        _alert(ctx, f'There does not appear to be a release **{tag}** in'
-               f' repository **{repo}** of account **{account}**.')
+        _alert(ctx, 'Malformed release URL: ' + str(url_or_tag))
         sys.exit(int(ExitCode.bad_arg))
 
     if files_to_upload and all_assets:
@@ -682,7 +775,7 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
     exit_code = ExitCode.success
     try:
         record = None
-        github_assets = []
+        release_assets = []
         if source:
             _inform(f'Using {source.name} instead of building a record.')
             metadata = metadata_from_file(source)
@@ -692,7 +785,7 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
         else:
             _inform(f'Building record for {account}/{repo} release "{tag}"', end='...')
             metadata = metadata_for_release(account, repo, tag, all_metadata)
-            github_assets = github_release_assets(account, repo, tag, all_assets)
+            release_assets = git_release_assets(repo, tag, account, all_assets)
             _inform(' done.')
 
         if dest:
@@ -712,7 +805,7 @@ def cli(ctx, url_or_tag, all_assets=False, community=None, draft=False,
             _inform(' done.')
 
             _inform('Attaching assets:')
-            for item in files_to_upload or github_assets:
+            for item in files_to_upload or release_assets:
                 invenio_upload(record, item, _print_text)
 
             if draft:
diff --git a/iga/github.py b/iga/github.py
index d41708e..02957a4 100644
--- a/iga/github.py
+++ b/iga/github.py
@@ -18,8 +18,9 @@
 from   types import SimpleNamespace
 
 from iga.exceptions import GitHubError, InternalError
+from iga.name_utils import split_name
+
 
-
 # Constants.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -33,7 +34,7 @@
 '''List of words such that, if one of the words is the last word in an account
 name, mean the account will be assumed to be a software bot of some kind.'''
 
-
+
 # Classes.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -98,7 +99,7 @@ class GitHubFile(SimpleNamespace):
     def __init__(self, file_dict):
         super().__init__(**file_dict)
 
-
+
 # Exported module functions.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -331,7 +332,7 @@ def valid_github_release_url(url):
             and split_url[6] == 'tag')
 
 
-def probable_bot(account):
+def github_probable_bot(account):
     '''Return True if this account is probably a bot.
 
     Bot accounts on GitHub are supposed to have an explicit type value of "bot"
@@ -349,7 +350,48 @@ def probable_bot(account):
     log(f'account {account.login} looks like it {"is" if is_bot else "is NOT"} a bot')
     return is_bot
 
-
+def identity_from_github(account, role=None):
+    if account.type == 'User':
+        if account.name:
+            (given, family) = split_name(account.name)
+            person_or_org = {'given_name': given,
+                             'family_name': family,
+                             'type': 'personal'}
+        else:
+            # The GitHub account record has no name, and InvenioRDM won't pass
+            # a record without a family name. All we have is the login name.
+            person_or_org = {'given_name': '',
+                             'family_name': account.login,
+                             'type': 'personal'}
+
+    else:
+        name = account.name.strip() if account.name else ''
+        person_or_org = {'name': name,
+                         'type': 'organizational'}
+    result = {'person_or_org': person_or_org}
+    if account.company and account.type == 'User':
+        account.company = account.company.strip()
+        if account.company.startswith('@'):
+            # Some people write @foo to indicate org account "foo" in GitHub.
+            # Grab only the first token after the '@'.
+            log(f'company for {account.login} account starts with @')
+            try:
+                import re
+                candidate = re.search(r'\w+', account.company).group()
+                org_account = github_account(candidate)
+            except GitHubError:
+                # No luck. Take it as-is.
+                log(f'failed to find {account.company[1:]} as a GitHub account')
+                result['affiliations'] = [{'name': account.company}]
+            else:
+                log(f'using org {candidate} as affiliation for {account.name}')
+                result['affiliations'] = [{'name': org_account.name}]
+        else:
+            result['affiliations'] = [{'name': account.company}]
+    if role:
+        result['role'] = {'id': role}
+    return result
+
 # Helper functions
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/iga/githublab.py b/iga/githublab.py
new file mode 100644
index 0000000..64f6087
--- /dev/null
+++ b/iga/githublab.py
@@ -0,0 +1,144 @@
+import os
+
+from iga.github import (
+    github_account_repo_tag,
+    github_release,
+    github_repo,
+    github_release_assets,
+    valid_github_release_url,
+    github_repo_file,
+    github_repo_filenames,
+    github_repo_languages,
+    github_asset_contents,
+    github_account,
+    github_repo_contributors,
+    identity_from_github,
+    github_probable_bot,
+    github_file_url,
+)
+from iga.gitlab import (
+    valid_gitlab_release_url,
+    gitlab_release_assets,
+    gitlab_repo,
+    gitlab_repo_file,
+    gitlab_release,
+    gitlab_account_repo_tag,
+    gitlab_repo_filenames,
+    gitlab_repo_languages,
+    gitlab_asset_contents,
+    gitlab_account,
+    gitlab_repo_contributors,
+    identity_from_gitlab,
+    gitlab_file_url,
+)
+
+
+class LazyEnvBool:
+    def __init__(self, var_name):
+        self.var_name = var_name
+
+    def __bool__(self):
+        return os.getenv(self.var_name, '').lower() == 'true'
+
+    __nonzero__ = __bool__  # For Python 2 compatibility
+
+
+GITLAB = LazyEnvBool('GITLAB')
+
+
+def valid_release_url(release_url):
+    if not GITLAB:
+        return valid_github_release_url(release_url)
+    else:
+        return valid_gitlab_release_url(release_url)
+
+
+def git_account_repo_tag(release_url):
+    """Return tuple (account, repo name, tag) based on the given web URL."""
+    # Example URL: https://code.jlab.org/physdiv/jrdb/inveniordm_jlab/-/releases/0.1.0
+    # Note this is not the same as the "release url" below.
+    if not GITLAB:
+        return github_account_repo_tag(release_url)
+    else:
+        return gitlab_account_repo_tag(release_url)
+
+
+def git_release(repo_name, tag, account_name=None):
+    if not GITLAB:
+        return github_release(account_name, repo_name, tag)
+    else:
+        return gitlab_release(repo_name, tag)
+
+
+def git_repo(repo_name, account_name=None):
+    if not GITLAB:
+        return github_repo(account_name, repo_name)
+    else:
+        return gitlab_repo(repo_name)
+
+
+def git_repo_filenames(repo, tag):
+    if not GITLAB:
+        return github_repo_filenames(repo, tag)
+    else:
+        return gitlab_repo_filenames(repo, tag)
+
+
+def git_repo_file(repo, tag, filename):
+    if not GITLAB:
+        return github_repo_file(repo, tag, filename)
+    else:
+        return gitlab_repo_file(repo, tag, filename)
+
+
+def git_release_assets(repo, tag, account_name=None, all_assets=False):
+    if not GITLAB:
+        return github_release_assets(account_name, repo, tag, all_assets)
+    else:
+        return gitlab_release_assets(repo, tag, all_assets)
+
+
+def git_account(repo):
+    if not GITLAB:
+        return github_account(repo)
+    else:
+        return gitlab_account(repo)
+
+
+def git_repo_languages(repo):
+    if not GITLAB:
+        return github_repo_languages(repo)
+    else:
+        return gitlab_repo_languages(repo)
+
+
+def git_asset_contents(asset):
+    if not GITLAB:
+        return github_asset_contents(asset)
+    else:
+        return gitlab_asset_contents(asset)
+
+
+def git_repo_contributors(repo):
+    if not GITLAB:
+        return github_repo_contributors(repo)
+    else:
+        return gitlab_repo_contributors(repo)
+
+
+def identity_from_git(account, role=None):
+    if GITLAB:
+        return identity_from_gitlab(account, role=None)
+    else:
+        return identity_from_github(account, role=role)
+
+
+def git_probable_bot(account):
+    return github_probable_bot(account)
+
+
+def git_file_url(repo, filename, tag):
+    if not GITLAB:
+        return github_file_url(repo, filename)
+    else:
+        return gitlab_file_url(repo, filename, tag)
diff --git a/iga/gitlab.py b/iga/gitlab.py
new file mode 100644
index 0000000..873c200
--- /dev/null
+++ b/iga/gitlab.py
@@ -0,0 +1,366 @@
+import commonpy.exceptions
+from functools import cache
+import json
+import os
+import re
+import base64
+from sidetrack import log
+from types import SimpleNamespace
+import requests
+from urllib.parse import quote, urlparse, urljoin
+
+from iga.exceptions import GitHubError, InternalError
+from iga.name_utils import split_name
+
+
+class LazyEnvStr:
+    def __init__(self, var_name):
+        self.var_name = var_name
+        self._value = None
+
+    @property
+    def value(self):
+        if self._value is None:
+            val = os.getenv(self.var_name, '')
+            self._value = f'{val}/api/v4'
+        return self._value
+
+    def __str__(self):
+        return self.value
+
+
+API_URL = LazyEnvStr('GITLAB_URL')
+
+
+class GitLabAPIError(Exception):
+    pass
+
+
+def _gitlab_get(endpoint, test_only=False):
+    headers = {'Accept': 'application/json'}
+    using_token = os.environ.get('GITLAB_TOKEN')
+    if using_token:
+        headers['Authorization'] = f'Bearer {using_token}'
+    method = 'head' if test_only else 'get'
+    try:
+        if method == 'HEAD':
+            response = requests.head(endpoint, headers=headers)
+        else:
+            response = requests.get(endpoint, headers=headers)
+
+        if response.status_code == 401:
+            raise GitLabAPIError(
+                f'Unauthorized: Check your GitLab token or permissions. Endpoint: {endpoint}'
+            )
+        elif response.status_code == 429:
+            # Too Many Requests error
+            raise GitLabAPIError(
+                f'Too Many Requests: Rate limit exceeded. Try again later. Endpoint: {endpoint}'
+            )
+        return response
+
+    except requests.exceptions.RequestException as e:
+        # Handle connection errors or timeouts
+        raise GitLabAPIError(f'Request failed: {e}') from e
+
+
+@cache
+def _object_for_gitlab(api_url, cls):
+    """Return object of class cls made from the data obtained from the API url."""
+    try:
+        response = _gitlab_get(api_url)
+        if not response:
+            return None
+        log(f'unpacking JSON into object structure from {api_url}')
+
+        # Create the desired object & add the api url in case it's needed later.
+        obj = cls(response.json())
+        obj.api_url = api_url
+        return obj
+
+    except GitLabAPIError as e:
+        # Handle GitLab API specific errors
+        log(f'GitLab API Error: {e}')
+        raise InternalError('Encountered error trying to unpack GitLab data.') from e
+
+    except Exception as ex:
+        # Handle other unexpected errors
+        log(f'Error: {ex}')
+        raise InternalError(
+            'Encountered unexpected error trying to unpack GitLab data.'
+        ) from ex
+
+
+class GitLabAccount(SimpleNamespace):
+    """Simple data structure corresponding to a GitHub user or org account."""
+
+    def __init__(self, user_dict):
+        super().__init__(**user_dict)
+        if os.environ.get('IGA_RUN_MODE') == 'debug':
+            log('GitHub user data: ' + json.dumps(user_dict, indent=2))
+        # Save the original data for debugging purposes.
+        self._json_dict = user_dict
+
+
+class GitLabAsset(SimpleNamespace):
+    """Simple data structure corresponding to a GitHub file asset JSON object."""
+
+    def __init__(self, asset_dict):
+        super().__init__(**asset_dict)
+
+
+class GitLabRelease(SimpleNamespace):
+    """Simple data structure corresponding to a GitHub release JSON object."""
+
+    def __init__(self, release_dict):
+        super().__init__(**release_dict)
+        if os.environ.get('IGA_RUN_MODE') == 'debug':
+            log('GitHub release data: ' + json.dumps(release_dict, indent=2))
+        if release_dict.get('owner', {}):
+            self.author = GitLabAccount(release_dict['owner'])
+        # Save the original data for debugging purposes.
+        self._json_dict = release_dict
+
+
+class GitLabRepo(SimpleNamespace):
+    """Simple data structure corresponding to a GitHub repository JSON object.
+    This object is enhanced with a "files" property that contains a list of
+    the files in the default branch of the repository."""
+
+    def __init__(self, repo_dict):
+        super().__init__(**repo_dict)
+        if os.environ.get('IGA_RUN_MODE') == 'debug':
+            log('GitHub repo data: ' + json.dumps(repo_dict, indent=2))
+        if repo_dict.get('owner', {}):
+            self.author = GitLabAccount(repo_dict['owner'])
+        # if repo_dict.get('organization'):
+        #    self.organization = GitLabAccount(repo_dict['organization'])
+        if repo_dict.get('license'):
+            self.license = GitLabLicense(repo_dict['license'])
+        # Save the original data for debugging purposes.
+        self._json_dict = repo_dict
+
+
+class GitLabLicense(SimpleNamespace):
+    """Simple data structure corresponding to a license object."""
+
+    def __init__(self, license_dict):
+        super().__init__(**license_dict)
+
+
+class GitLabFile(SimpleNamespace):
+    """Simple data structure corresponding to a file in a repo."""
+
+    def __init__(self, file_dict):
+        super().__init__(**file_dict)
+
+
+def gitlab_release(repo_name, tag, test_only=False):
+    """Return a Release object corresponding to the tagged release in GitHub.
+
+    If test_only is True, only check existence; don't create a Release object.
+    """
+    endpoint = f'{API_URL}/projects/{repo_name}/releases/{tag}'
+    if test_only:
+        log('testing for existence: ' + endpoint)
+        return _gitlab_get(endpoint, test_only)
+
+    log('getting GitLab release data from ' + endpoint)
+    return _object_for_gitlab(endpoint, GitLabRelease)
+
+
+def gitlab_repo(repo_name, test_only=False):
+    """Return a Repo object corresponding to the named repo in GitLab."""
+    endpoint = f'{API_URL}/projects/{repo_name}?license=true'
+    if test_only:
+        log('testing for existence: ' + endpoint)
+        return _gitlab_get(endpoint, test_only)
+
+    log('getting GitLab release data from ' + endpoint)
+    return _object_for_gitlab(endpoint, GitLabRelease)
+
+
+def gitlab_release_assets(repo_name, tag, all_assets):
+    """Return a list of URLs for all the assets associated with the release."""
+
+    release = gitlab_release(repo_name, tag)
+    sources = release.assets['sources']
+    assets = []
+    for source in sources:
+        if not all_assets:
+            if source['format'] in ['zip']:
+                assets.append(source['url'])
+        else:
+            log('option to get all assets is in effect')
+            assets.append(source['url'])
+    return assets
+
+
+def gitlab_repo_filenames(repo, tag_name):
+    """Return a list of filenames in the repo corresponding to the specified tag."""
+    endpoint = f'{API_URL}/projects/{repo.id}/repository/tree'
+    response = _gitlab_get(endpoint)
+    if not response:
+        log('got no tree or it does not exist')
+        return ''
+    files = [res['path'] for res in response.json()]
+    return files
+
+
+def gitlab_repo_file(repo, tag_name, filename):
+    """Return the text contents of the named file in the repo object.
+
+    The tag_name must be a release tag, and is used to find the version of
+    the repository corresponding to that tag.
+    """
+    if filename in getattr(repo, '_files_contents', {}):
+        log(f'{filename} found in the files of {repo}')
+        return repo._files_contents[filename]
+
+    endpoint = (
+        f'{API_URL}/projects/{repo.id}/repository/files/{filename}?ref={tag_name}'
+    )
+    response = _gitlab_get(endpoint)
+    if not response:
+        log(f'got no content for file {filename} or it does not exist')
+        return ''
+    json_dict = response.json()
+    if json_dict['encoding'] != 'base64':
+        log(f'GitHub file encoding for {filename} is ' + json_dict['encoding'])
+        raise InternalError('Unimplemented file encoding ' + json_dict['encoding'])
+
+    contents = base64.b64decode(json_dict['content']).decode()
+    if not getattr(repo, '_file_contents', {}):
+        repo._file_contents = {}
+    # Cache the file contents, so we don't have to get it from GitLab again.
+    repo._file_contents[filename] = contents
+    log(f'got contents for {filename} (length = {len(contents)} chars)')
+    return contents
+
+
+def gitlab_file_url(repo, filename, tag):
+    """Return the URL of the named file in the repo."""
+    endpoint = f'{API_URL}/projects/{repo.id}/repository/blobs/{filename}?ref={tag}'
+    return endpoint
+
+
+def gitlab_repo_languages(repo):
+    log(f'asking GitHub for list of languages for repo {repo.name}')
+    repolink = repo._links['self']
+    endpoint = f'{repolink}/languages'
+    response = _gitlab_get(endpoint)
+    if not response:
+        log(f'got no content for list of languages for repo {repo}')
+        return ''
+    json_dict = response.json()
+    languages = json_dict.keys() if json_dict else []
+    log(f'GitLab lists {len(languages)} languages for the repo')
+    return languages
+
+
+def gitlab_asset_contents(asset_url):
+    """Return the raw contents of a release asset file."""
+    try:
+        response = _gitlab_get(asset_url)
+        return response.content
+    except KeyboardInterrupt:
+        raise
+    except commonpy.exceptions.CommonPyException:
+        raise GitHubError(
+            f'Failed to download GitHub asset at {asset_url}'
+            ' – either it does not exist or it is inaccessible.'
+        )
+    except Exception:
+        raise
+
+
+def valid_gitlab_release_url(url):
+    """Check if the provided URL is a valid GitLab release endpoint."""
+    gitlab_api_pattern = r'^https?://[^/]+/api/v4/projects/[^/]+/releases/[^/]+$'
+    gitlab_web_pattern = r'^https?://[^/]+/[^/]+/[^/]+/-/releases/[^/]+$'
+    if not (re.match(gitlab_api_pattern, url) or re.match(gitlab_web_pattern, url)):
+        log(f"URL does not match GitLab release URL pattern: {url}")
+        return False
+    return True
+
+
+def gitlab_account_repo_tag(release_url):
+    """{gitlab_projectid}/releases/{tag}"""
+    parsed = urlparse(release_url)
+    os.environ['GITLAB_URL'] = f'{parsed.scheme}://{parsed.netloc}'
+    path = parsed.path
+    path = path.rstrip('/')
+    tag = path.split('/')[-1]
+    y = '/'.join(path.split('/')[:-1])
+    project_id = y.rstrip('-/releases').lstrip('/')
+    project_id = quote(project_id, safe='')
+    return (None, project_id, tag)
+
+
+def gitlab_account(account_name):
+    endpoint = f'{API_URL}/users?username={account_name}'  # without_project_bots=true
+    try:
+        response = _gitlab_get(endpoint)
+        if not response:
+            return None
+        log(f'unpacking JSON into object structure from {endpoint}')
+
+        # Create the desired object & add the api url in case it's needed later.
+        jsn_response = response.json()
+        obj = GitLabAccount(jsn_response[0])
+
+        obj.api_url = endpoint
+        return obj
+
+    except GitLabAPIError as e:
+        # Handle GitLab API specific errors
+        log(f'GitLab API Error: {e}')
+        raise InternalError('Encountered error trying to unpack GitLab data.') from e
+
+    except Exception as ex:
+        # Handle other unexpected errors
+        log(f'Error: {ex}')
+        raise InternalError(
+            'Encountered unexpected error trying to unpack GitLab data.'
+        ) from ex
+
+
+def gitlab_repo_contributors(repo):
+    repolink = repo._links['self']
+    endpoint = f'{repolink}/repository/contributors'
+    response = _gitlab_get(endpoint)
+    if not response:
+        log(f'got no content for list of contributors for repo {repo}')
+        return []
+    # The JSON data is a list containing a kind of minimal user info dict.
+    contributors = []
+    seen_names = set()
+    for user_dict in response.json():
+        new_contributor_name = user_dict['name']
+        (given, family) = split_name(new_contributor_name)
+        # this is done so that when a repo is imported from github to gitlab
+        # it creates the same name but different order contributors. 
+        sorted_names = tuple(sorted([family, given]))
+        person_or_org = {'given_name': given, 'family_name': family, 'type': 'personal'}
+        if sorted_names not in seen_names:
+            seen_names.add(sorted_names)
+            contributors.append({'person_or_org': person_or_org, 'role': {'id': 'other'}})
+    log(f'repo has {len(contributors)} contributors')
+    return contributors
+
+
+def identity_from_gitlab(account, role=None):
+    if account.name:
+        (given, family) = split_name(account.name)
+        person_or_org = {'given_name': given, 'family_name': family, 'type': 'personal'}
+    else:
+        # The GitHub account record has no name, and InvenioRDM won't pass
+        # a record without a family name. All we have is the login name.
+        person_or_org = {
+            'given_name': '',
+            'family_name': account.username,
+            'type': 'personal',
+        }
+    result = {'person_or_org': person_or_org}
+    return result
+
diff --git a/iga/invenio.py b/iga/invenio.py
index 1db083f..52d9b2c 100644
--- a/iga/invenio.py
+++ b/iga/invenio.py
@@ -18,6 +18,7 @@
 import socket
 import os
 from   os import path
+import humanize
 
 import iga
 from   iga.exceptions import (
@@ -25,10 +26,11 @@
     InvenioRDMError,
     RecordNotFound,
 )
-from   iga.github import github_asset_contents
+from   iga.githublab import git_asset_contents
 from   iga.id_utils import normalize_invenio_rdm
 
-
+
+
 # Exported data structures.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -86,7 +88,7 @@ def __gt__(self, other):
     def __ge__(self, other):
         return not self.__lt__(self, other)
 
-
+
 # Exported module functions.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -231,12 +233,11 @@ def invenio_upload(record, asset, print_status):
     '''
     # Start by reading the assets to be sure we can actually get them, *before*
     # trying to upload them to InvenioRDM.
-    import humanize
     size = ''
     if asset.startswith('http'):
         filename = _filename_from_asset_url(asset)
         print_status(f' - Downloading [bold]{filename}[/] from GitHub', end='...')
-        content = github_asset_contents(asset)
+        content = git_asset_contents(asset)
         print_status('done')
         size = humanize.naturalsize(len(content))
         log(f'downloaded {size} bytes of {asset}')
@@ -289,7 +290,7 @@ def invenio_community_send(record, community):
     }
     result = _invenio('put', url=record.review_url, data=data,
                       msg='get community submission link from InvenioRDM')
-    submit_url = record.get('review_url', '').replace('/review', '/actions/submit-review')
+    submit_url = record.review_url.replace('/review', '/actions/submit-review')
     data = {
         'payload': {
             'format': 'html',
@@ -363,7 +364,7 @@ def invenio_communities():
     log(f'we got {pluralized("community", communities, True)}')
     return communities
 
-
+
 # Miscellaneous helper functions.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/iga/metadata.py b/iga/metadata.py
index 860590f..3e43ec7 100644
--- a/iga/metadata.py
+++ b/iga/metadata.py
@@ -35,39 +35,47 @@
 file "LICENSE" for more information.
 '''
 
+import os
+import sys
+from   itertools import filterfalse
 import arrow
 from   commonpy.data_structures import CaseFoldSet, CaseFoldDict
 from   commonpy.data_utils import pluralized
 from   commonpy.network_utils import scheme as url_scheme
-from   itertools import filterfalse
 import json5
-import os
 from   sidetrack import log
-import sys
 import validators
-
+import yaml
 from iga.data_utils import deduplicated, listified, normalized_url, similar_urls
 from iga.exceptions import MissingData
-from iga.github import (
-    github_account,
-    github_file_url,
-    github_release,
-    github_repo,
-    github_repo_contributors,
-    github_repo_file,
-    github_repo_filenames,
-    github_repo_languages,
-    GitHubError,
-    probable_bot,
+from iga.githublab import (
+    git_repo,
+    git_repo_file,
+    git_release,
+    git_repo_filenames,
+    git_repo_languages,
+    git_account,
+    git_repo_contributors,
+    identity_from_git,
+    git_probable_bot,
+    git_file_url
 )
+
 from iga.id_utils import detected_id, recognized_scheme
 from iga.name_utils import split_name, flattened_name
 from iga.reference import reference, RECOGNIZED_REFERENCE_SCHEMES
 from iga.text_utils import cleaned_text
 
-
-# Constants.
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class LazyEnvBool:
+    def __init__(self, var_name):
+        self.var_name = var_name
+
+    def __bool__(self):
+        return os.getenv(self.var_name, '').lower() == 'true'
+
+    __nonzero__ = __bool__  # For Python 2 compatibility
+
+GITLAB = LazyEnvBool('GITLAB')
 
 # It's useful to understand the context of what's going on. The record stored
 # in InvenioRDM may have these top-level fields (but might not contain all):
@@ -168,7 +176,7 @@
 # allowed but we don't want to allow some types such as 'data' URLs.
 ALLOWED_URL_SCHEMES = ['http', 'https', 'git', 'ftp', 'gopher', 's3', 'svn']
 
-
+
 # Exported module functions.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -178,16 +186,16 @@ def metadata_for_release(account_name, repo_name, tag, all_metadata):
     Data is gathered from the GitHub release identified by "tag" in the
     repository "repo_name" of the given GitHub "account_name".
     '''
-    repo = github_repo(account_name, repo_name)
-    release = github_release(account_name, repo_name, tag)
+    repo = git_repo(repo_name, account_name)
+    release = git_release(repo_name, tag, account_name)
 
     # We use codemeta.json & CITATION.cff often. Get them now & augment the
     # repo object with them so that field extraction functions can access them.
     repo.codemeta = {}
     repo.cff = {}
-    filenames = github_repo_filenames(repo, tag)
+    filenames = git_repo_filenames(repo, tag)
     if 'codemeta.json' in filenames:
-        codemeta_file = github_repo_file(repo, tag, 'codemeta.json')
+        codemeta_file = git_repo_file(repo, tag, 'codemeta.json')
         try:
             repo.codemeta = json5.loads(codemeta_file)
         except KeyboardInterrupt:
@@ -199,10 +207,10 @@ def metadata_for_release(account_name, repo_name, tag, all_metadata):
         except Exception as ex:         # noqa PIE786
             log('ignoring codemeta.json file because of error: ' + str(ex))
     for name in ['CITATION.cff', 'CITATION.CFF', 'citation.cff']:
+        # https://github.com/citation-file-format/citation-file-format/blob/main/schema.json
         if name in filenames:
-            import yaml
             try:
-                repo.cff = yaml.safe_load(github_repo_file(repo, tag, name))
+                repo.cff = yaml.safe_load(git_repo_file(repo, tag, name))
             except KeyboardInterrupt:
                 raise
             except Exception as ex:     # noqa PIE786
@@ -240,11 +248,11 @@ def metadata_from_file(file):
         log(f'reading metadata provided in file {str(file)}')
         content = file.read().strip()
         metadata = json5.loads(content)
-    except KeyboardInterrupt:
-        raise
     except Exception as ex:             # noqa PIE786
         log(f'problem trying to read metadata from {str(file)}: ' + str(ex))
         return False
+    except KeyboardInterrupt:
+        raise
 
     if 'metadata' not in metadata:
         log('record lacks a "metadata" field')
@@ -258,7 +266,7 @@ def metadata_from_file(file):
         log(f'metadata in {file} validated to have minimum fields')
         return metadata
 
-
+
 # Field value functions.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # Summary of the approach: the functions for extracting values from GitHub
@@ -347,8 +355,9 @@ def additional_titles(repo, release, include_all):
                        'lang': {'id': 'eng'},
                        })
     if add_repo_name:
+        title = repo.name if GITLAB else repo.full_name
         log('adding GitHub repo "full_name" as additional title')
-        titles.append({'title': cleaned_text(repo.full_name),
+        titles.append({'title': cleaned_text(title),
                        'type': {'id': 'alternative-title'},
                        'lang': {'id': 'eng'},
                        })
@@ -425,16 +434,27 @@ def contributors(repo, release, include_all):
                 contributors.append(entity)
             else:
                 log(f'skipping CodeMeta "contributor" {entity} who is in "authors"')
-    elif include_all and (repo_contributors := github_repo_contributors(repo)):
-        # If CodeMeta doesn't contain contributors, use the repo's, if any.
-        # Skip bot accounts.
-        for account in filterfalse(probable_bot, repo_contributors):
-            entity = _identity_from_github(account, 'other')
-            if not any(_entity_match(entity, author) for author in authors):
-                log(f'adding GitHub repo contributor {entity} as contributor(s)')
-                contributors.append(entity)
-            else:
-                log(f'skipping GitHub repo contributor {entity} who is in "authors"')
+    elif include_all:
+        if not GITLAB:
+            if (repo_contributors := git_repo_contributors(repo)):
+                # If CodeMeta doesn't contain contributors, use the repo's, if any.
+                # Skip bot accounts.
+                for account in filterfalse(git_probable_bot, repo_contributors):
+                    entity = identity_from_git(account, 'other')
+                    if not any(_entity_match(entity, author) for author in authors):
+                        log(f'adding GitHub repo contributor {entity} as contributor(s)')
+                        contributors.append(entity)
+                    else:
+                        log(f'skipping GitHub repo contributor {entity} who is in "authors"')
+        else:
+            if (repo_contributors := git_repo_contributors(repo)):
+                for entity in repo_contributors:
+                    if not any(_entity_match(entity, author) for author in authors):
+                        log(f'adding GITLAB repo contributor {entity} as contributor(s)')
+                        contributors.append(entity)
+                    else:
+                        log(f'skipping GITLAB repo contributor {entity} who is in "authors"')
+
 
     # We're getting data from multiple sources & we might have duplicates.
     # Deduplicate based on names & roles only.
@@ -465,7 +485,7 @@ def log_decision(text):
     # release data, so try them 1st.
     if authors := listified(repo.codemeta.get('author', [])):
         log_decision('CodeMeta "author" name(s)')
-    elif authors := repo.cff.get('author', []):
+    elif authors := repo.cff.get('authors', []):
         log_decision('CFF "author" name(s)')
     if authors:
         return deduplicated(_entity(x) for x in authors)
@@ -474,8 +494,10 @@ def log_decision(text):
     # author first, followed by the repo owner.
     if identity := _release_author(release):
         log_decision('GitHub release author')
-    elif identity := _repo_owner(repo):
+    elif (GITLAB and  hasattr(repo, 'owner')) and (identity := _repo_owner(repo)):
         log_decision('GitHub repo owner name')
+    elif not GITLAB and (identity := _repo_owner(repo)):
+        log_decision('GitHub repo owner name')  
     if identity:
         return [identity]
 
@@ -492,7 +514,7 @@ def dates(repo, release, include_all):
     # If we used a different date for the publication_date value than the
     # release date in GitHub, we add release date as another type of date.
     pub_date = publication_date(repo, release, include_all)
-    github_date = arrow.get(release.published_at).format('YYYY-MM-DD')
+    github_date = arrow.get(release.released_at if GITLAB else release.published_at).format('YYYY-MM-DD')
     if pub_date != github_date:
         log('adding the GitHub release "published_at" date as the "available" date')
         dates.append({'date': github_date,
@@ -538,12 +560,15 @@ def description(repo, release, include_all, internal_call=False):
     # commit messages. In those cases, the value of release.body that we get
     # through the API is empty. There doesn't seem to be a way to get the text
     # shown by GitHub in those cases, so we try other alternatives after this.
-    if release.body:
-        if internal_call:
-            return release.body.strip()
-        else:
-            log('adding GitHub release body text as "description"')
-            return html_from_md(release.body.strip())
+
+    # AP: gitlab release body no.
+    if not GITLAB:
+        if release.body:
+            if internal_call:
+                return release.body.strip()
+            else:
+                log('adding GitHub release body text as "description"')
+                return html_from_md(release.body.strip())
 
     # CodeMeta releaseNotes can be either text or a URL. If it's a URL, it
     # often points to a NEWS or ChangeLog or similar file in their repo.
@@ -583,7 +608,7 @@ def description(repo, release, include_all, internal_call=False):
     return '(No description provided.)'
 
 
-def formats(repo, release, include_all):
+def formats(release):
     '''Return InvenioRDM "formats".
     https://inveniordm.docs.cern.ch/reference/metadata/#formats-0-n
     '''
@@ -773,7 +798,7 @@ def publication_date(repo, release, include_all):
     elif date := repo.cff.get('date-released', ''):
         log('adding CFF "date-released" as "publication_date"')
     else:
-        date = release.published_at
+        date = release.released_at if GITLAB else release.published_at
         log('adding GitHub repo "published_at" as "publication_date"')
     return arrow.get(date).format('YYYY-MM-DD')
 
@@ -839,19 +864,20 @@ def id_dict(url, rel_type, res_type):
                 'resource_type': {'id': res_type},
                 'scheme': 'url'}
 
-    log('adding GitHub release "html_url" to "related_identifiers"')
-    identifiers = [id_dict(release.html_url, 'isidenticalto', 'software')]
+    log('adding GitHub/GitLab release "html_url" to "related_identifiers"')
+    identifiers = [id_dict(release._links["self"] if GITLAB else release.html_url, 'isidenticalto', 'software')]
 
     # The GitHub repo is what this release is derived from. Note: you would
     # expect the GitHub repo html_url, the codemeta.json codeRepository, and
     # the CFF repository-code all to be the same value, but we can't be sure,
     # so we have to look at them, and use them in the order of priority.
+    repo_html=repo.web_url if GITLAB else release.html_url
     if repo_url := repo.codemeta.get('codeRepository', ''):
         log('adding CodeMeta "codeRepository" to "related_identifiers"')
     elif repo_url := repo.cff.get('repository-code', ''):
         log('adding CFF "repository-code" to "related_identifiers"')
-    elif include_all and (repo_url := repo.html_url):
-        log('adding GitHub repo "html_url" to "related_identifiers"')
+    elif include_all and (repo_url := repo_html):
+        log('adding GitHub/GitLab repo "html_url" to "related_identifiers"')
     if repo_url:
         identifiers.append(id_dict(repo_url, 'isderivedfrom', 'software'))
 
@@ -871,8 +897,8 @@ def id_dict(url, rel_type, res_type):
         log('adding CodeMeta "url" to "related_identifiers"')
     elif homepage_url := repo.cff.get('url', ''):
         log('adding CFF "url" to "related_identifiers"')
-    elif include_all and (homepage_url := repo.homepage):
-        log('adding GitHub repo "homepage" to "related_identifiers"')
+    elif include_all and (homepage_url := repo.web_url if GITLAB else repo.homepage):
+        log('adding GitHub/GitLab repo "homepage" to "related_identifiers"')
     if homepage_url:
         identifiers.append(id_dict(homepage_url, 'isdescribedby', 'other'))
 
@@ -915,21 +941,25 @@ def id_dict(url, rel_type, res_type):
             identifiers.append(id_dict(url, 'isdocumentedby',
                                        'publication-softwaredocumentation'))
 
-    # The GitHub Pages URL for a repo usually points to documentation or info
-    # about the softare, though we can't tell if it's for THIS release.
-    if include_all and repo.has_pages:
-        url = f'https://{repo.owner.login}.github.io/{repo.name}'
-        if not any(url == item['identifier'] for item in identifiers):
-            log('adding the repo\'s GitHub Pages URL to "related_identifiers"')
-            identifiers.append(id_dict(url, 'isdocumentedby',
-                                       'publication-softwaredocumentation'))
+    if not GITLAB:
+        # The GitHub Pages URL for a repo usually points to documentation or info
+        # about the softare, though we can't tell if it's for THIS release.
+        if include_all and repo.has_pages:
+            url = f'https://{repo.owner.login}.github.io/{repo.name}'
+            if not any(url == item['identifier'] for item in identifiers):
+                log('adding the repo\'s GitHub Pages URL to "related_identifiers"')
+                identifiers.append(id_dict(url, 'isdocumentedby',
+                                           'publication-softwaredocumentation'))
+    
+    # todo: check gitlab pages
 
     # The issues URL is kind of a supplemental resource.
+    repo_issues = repo._links["issues"]  if GITLAB else repo.issues_url
     if issues_url := repo.codemeta.get('issueTracker', ''):
         log('adding CodeMeta "issueTracker" to "related_identifiers"')
-    elif include_all and repo.issues_url:
-        log('adding GitHub repo "issues_url" to "related_identifiers"')
-        issues_url = f'https://github.com/{repo.full_name}/issues'
+    elif include_all and (repo_issues):
+        log('adding GitHub/GitLab repo "issues_url" to "related_identifiers"')
+        issues_url = repo_issues
     if issues_url:
         identifiers.append(id_dict(issues_url, 'issupplementedby', 'other'))
 
@@ -1043,25 +1073,43 @@ def rights(repo, release, include_all):
 
     # We didn't recognize license info in the CodeMeta or cff files.
     # Look into the GitHub repo data to see if GitHub identified a license.
-    if repo.license and repo.license.name != 'Other':
-        from iga.licenses import LICENSES
-        log('GitHub has provided license info for the repo – using those values')
-        spdx_id = repo.license.spdx_id
-        if spdx_id in INVENIO_LICENSES:
-            rights = {'id': spdx_id.lower()}
+    if not GITLAB:
+        if repo.license and repo.license.name != 'Other':
+            from iga.licenses import LICENSES
+            log('GitHub has provided license info for the repo – using those values')
+            spdx_id = repo.license.spdx_id
+            if spdx_id in INVENIO_LICENSES:
+                rights = {'id': spdx_id.lower()}
+            else:
+                rights = {'link': repo.license.url,
+                        'title': {'en': repo.license.name}}
+                if spdx_id in LICENSES and LICENSES[spdx_id].description:
+                    log(f'adding our own description for license type {spdx_id}')
+                    rights['description'] = {'en': LICENSES[spdx_id].description}
+            return [rights]
         else:
-            rights = {'link': repo.license.url,
-                      'title': {'en': repo.license.name}}
-            if spdx_id in LICENSES and LICENSES[spdx_id].description:
-                log(f'adding our own description for license type {spdx_id}')
-                rights['description'] = {'en': LICENSES[spdx_id].description}
-        return [rights]
+            log('GitHub did not provide license info for this repo')
     else:
-        log('GitHub did not provide license info for this repo')
+        if repo.license and repo.license["name"] != 'Other':
+            log('GitLab has provided license info for the repo – using those values')
+            key = repo.license['key']
+            if key.upper() in INVENIO_LICENSES:
+                rights = {'id': key.lower()}
+            else:
+                rights = {'link': repo.license.html_url,
+                        'title': {'en': repo.license["name"]}}
+                if key in LICENSES and LICENSES[key].description:
+                    log(f'adding our own description for license type {key}')
+                    rights['description'] = {'en': LICENSES[key].description}
+            return [rights]
+        else:
+            log('GitLab did not provide license info for this repo')
+
+
 
     # GitHub didn't fill in the license info -- maybe it didn't recognize
     # the license or its format. Try to look for a license file ourselves.
-    filenames = github_repo_filenames(repo, release.tag_name)
+    filenames = git_repo_filenames(repo, release.tag_name)
     for basename in ['LICENSE', 'License', 'license',
                      'LICENCE', 'Licence', 'licence',
                      'COPYING', 'COPYRIGHT', 'Copyright', 'copyright']:
@@ -1071,7 +1119,7 @@ def rights(repo, release, include_all):
                 # There's no safe way to summarize arbitrary license text,
                 # so we can't provide a 'description' field value.
                 rights = [{'title': {'en': 'License'},
-                           'link': github_file_url(repo, basename + ext)}]
+                           'link': git_file_url(repo, basename + ext, release.tag_name)}]
                 break
         else:
             continue
@@ -1079,7 +1127,7 @@ def rights(repo, release, include_all):
     return rights
 
 
-def sizes(repo, release, include_all):
+def sizes():
     '''Return InvenioRDM "sizes".
     https://inveniordm.docs.cern.ch/reference/metadata/#sizes-0-n
     '''
@@ -1141,7 +1189,7 @@ def subjects(repo, release, include_all):
         subjects.update(repo.topics)
 
         # Add repo languages as topics too.
-        if languages := github_repo_languages(repo):
+        if languages := git_repo_languages(repo):
             log('adding GitHub repo languages to "subjects"')
         for lang in languages:
             subjects.add(lang)
@@ -1168,7 +1216,7 @@ def title(repo, release, include_all):
         title += text
         field = 'CFF "title"'
     else:
-        title += repo.full_name
+        title += repo.name if GITLAB else repo.full_name
         field = 'GitHub repo "full_name"'
 
     # Note: better not to use a colon here. A lot of CodeMeta files use a name
@@ -1198,7 +1246,6 @@ def version(repo, release, include_all):
         tag = re.sub(r'v(er|version)?[ .]? ?', '', tag)
     return tag.strip()
 
-
 # Miscellaneous helper functions.
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -1270,7 +1317,7 @@ def _entity_from_string(data, role):
                                         'type': 'organizational'}}
     elif account := _parsed_github_account(data):
         # It's the name of an account in GitHub.
-        result = _identity_from_github(account)
+        result = identity_from_git(account)
     else:
         # We have to parse a single string to guess whether it's the name of
         # a person or org, and if a person, to split the string into family
@@ -1298,14 +1345,17 @@ def _entity_from_dict(data, role):
     # subset anyway because there's no place in Invenio records to put the rest.
     person = {}
     org = {}
-
     type_ = data.get('@type', '') or data.get('type', '')
+    if not type_:
+        type_ = 'person'
     if type_.lower().strip() == 'person':
         # Deal with field name differences between CodeMeta & CFF.
         family = data.get('family-names', '') or data.get('familyName', '')
         given  = data.get('given-names', '') or data.get('givenName', '')
 
         id = detected_id(data.get('@id', ''))            # noqa A001
+        if not id:
+            id = data.get("orcid",'')
         id_type = recognized_scheme(id)
 
         if not (family or given) and id_type == 'orcid':
@@ -1403,70 +1453,29 @@ def _entity_match(first, second):
                 and p1.get('given_name', '') == p2.get('given_name', ''))
     return False
 
-
 def _release_author(release):
     # We can call GitHub's user data API, but it returns very little info
     # about a user (e.g.,, it gives a name but that name is not broken out
     # into family & given name), plus sometimes fields are empty.
-    account = github_account(release.author.login)
-    return _identity_from_github(account) if account.name else None
-
+    account_name = release.author["username"] if GITLAB else release.author.login
+    account = git_account(account_name)
+    return identity_from_git(account) if account.name else None
 
 def _repo_owner(repo):
-    account = github_account(repo.owner.login)
-    return _identity_from_github(account)
-
-
-def _identity_from_github(account, role=None):
-    if account.type == 'User':
-        if account.name:
-            (given, family) = split_name(account.name)
-            person_or_org = {'given_name': given,
-                             'family_name': family,
-                             'type': 'personal'}
-        else:
-            # The GitHub account record has no name, and InvenioRDM won't pass
-            # a record without a family name. All we have is the login name.
-            person_or_org = {'given_name': '',
-                             'family_name': account.login,
-                             'type': 'personal'}
-
+    if GITLAB:
+        account_name =  repo.owner["username"]
     else:
-        name = account.name.strip() if account.name else ''
-        person_or_org = {'name': name,
-                         'type': 'organizational'}
-    result = {'person_or_org': person_or_org}
-    if account.company and account.type == 'User':
-        account.company = account.company.strip()
-        if account.company.startswith('@'):
-            # Some people write @foo to indicate org account "foo" in GitHub.
-            # Grab only the first token after the '@'.
-            log(f'company for {account.login} account starts with @')
-            try:
-                import re
-                candidate = re.search(r'\w+', account.company).group()
-                org_account = github_account(candidate)
-            except GitHubError:
-                # No luck. Take it as-is.
-                log(f'failed to find {account.company[1:]} as a GitHub account')
-                result['affiliations'] = [{'name': account.company}]
-            else:
-                log(f'using org {candidate} as affiliation for {account.name}')
-                result['affiliations'] = [{'name': org_account.name}]
-        else:
-            result['affiliations'] = [{'name': account.company}]
-    if role:
-        result['role'] = {'id': role}
-    return result
-
+        account_name = repo.owner.login
+    account = git_account(account_name) 
+    return identity_from_git(account)
 
 def _parsed_github_account(data):
     if data.startswith('https://github.com'):
         # Might be the URL to an account page on GitHub.
         tail = data.replace('https://github.com/', '')
-        if '/' not in tail and (account := github_account(tail)):
+        if '/' not in tail and (account := git_account(tail)):
             return account
-    elif len(data.split()) == 1 and (account := github_account(data)):
+    elif len(data.split()) == 1 and (account := git_account(data)):
         return account
     return None
 
@@ -1558,6 +1567,7 @@ def _cff_reference_ids(repo):
 
 
 def _load_vocabularies():
+    # https://inveniordm.jlab.org/api/vocabularies/licenses
     from caltechdata_api.customize_schema import get_vocabularies
     from iga.invenio import invenio_vocabulary
     log('loading controlled vocabularies using caltechdata_api module')
diff --git a/tests/data/gitlab-examples/CITATION.cff b/tests/data/gitlab-examples/CITATION.cff
new file mode 100644
index 0000000..7023a2d
--- /dev/null
+++ b/tests/data/gitlab-examples/CITATION.cff
@@ -0,0 +1,10 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+  - family-names: Panta
+    given-names: Anil
+    orcid: https://orcid.org/0000-0001-6385-7712
+title: "Container Docs"
+version: 0.0.2
+date-released: 2021-08-11
+abstract: "This is hcana container description"
\ No newline at end of file
diff --git a/tests/data/gitlab-examples/account.json b/tests/data/gitlab-examples/account.json
new file mode 100644
index 0000000..dcc8c98
--- /dev/null
+++ b/tests/data/gitlab-examples/account.json
@@ -0,0 +1,11 @@
+[
+    {
+      "id": 14699208,
+      "username": "panta-123",
+      "name": "anil panta",
+      "state": "active",
+      "locked": false,
+      "avatar_url": "https://secure.gravatar.com/avatar/f7ecdfd6bf7abb12bcc280c2d7fb532fc190ac87ffd087147eb101bb93c73498?s=80&d=identicon",
+      "web_url": "https://gitlab.com/panta-123"
+    }
+  ]
\ No newline at end of file
diff --git a/tests/data/gitlab-examples/release.json b/tests/data/gitlab-examples/release.json
new file mode 100644
index 0000000..0aedbb5
--- /dev/null
+++ b/tests/data/gitlab-examples/release.json
@@ -0,0 +1,80 @@
+{
+    "name": "This is the test release",
+    "tag_name": "v0.0.1",
+    "description": "Added citation and lisence",
+    "created_at": "2024-08-26T15:40:54.099Z",
+    "released_at": "2024-08-26T15:40:54.099Z",
+    "upcoming_release": false,
+    "author": {
+      "id": 14699208,
+      "username": "panta-123",
+      "name": "anil panta",
+      "state": "active",
+      "locked": false,
+      "avatar_url": "https://secure.gravatar.com/avatar/f7ecdfd6bf7abb12bcc280c2d7fb532fc190ac87ffd087147eb101bb93c73498?s=80&d=identicon",
+      "web_url": "https://gitlab.com/panta-123"
+    },
+    "commit": {
+      "id": "dcf073309667090b871ab6a667818a3bfde8d924",
+      "short_id": "dcf07330",
+      "created_at": "2024-08-26T15:35:41.000+00:00",
+      "parent_ids": [
+        "26c092cfc7fbb92b88ffa5bdb3c714b1241a45a7"
+      ],
+      "title": "Update 3 files",
+      "message": "Update 3 files\n\n- /CITATION.cff\n- /LICENSE\n- /README.md",
+      "author_name": "anil panta",
+      "author_email": "anilpanta2@gmail.com",
+      "authored_date": "2024-08-26T15:35:41.000+00:00",
+      "committer_name": "anil panta",
+      "committer_email": "anilpanta2@gmail.com",
+      "committed_date": "2024-08-26T15:35:41.000+00:00",
+      "trailers": {
+  
+      },
+      "extended_trailers": {
+  
+      },
+      "web_url": "https://gitlab.com/panta-123/test/-/commit/dcf073309667090b871ab6a667818a3bfde8d924"
+    },
+    "commit_path": "/panta-123/test/-/commit/dcf073309667090b871ab6a667818a3bfde8d924",
+    "tag_path": "/panta-123/test/-/tags/v0.0.1",
+    "assets": {
+      "count": 4,
+      "sources": [
+        {
+          "format": "zip",
+          "url": "https://gitlab.com/panta-123/test/-/archive/v0.0.1/test-v0.0.1.zip"
+        },
+        {
+          "format": "tar.gz",
+          "url": "https://gitlab.com/panta-123/test/-/archive/v0.0.1/test-v0.0.1.tar.gz"
+        },
+        {
+          "format": "tar.bz2",
+          "url": "https://gitlab.com/panta-123/test/-/archive/v0.0.1/test-v0.0.1.tar.bz2"
+        },
+        {
+          "format": "tar",
+          "url": "https://gitlab.com/panta-123/test/-/archive/v0.0.1/test-v0.0.1.tar"
+        }
+      ],
+      "links": []
+    },
+    "evidences": [
+      {
+        "sha": "f7f2232b33bad046a4fcf9717bbfbae5eb00f331e04d",
+        "filepath": "https://gitlab.com/panta-123/test/-/releases/v0.0.1/evidences/9539534.json",
+        "collected_at": "2024-08-26T15:40:54.281Z"
+      }
+    ],
+    "_links": {
+      "closed_issues_url": "https://gitlab.com/panta-123/test/-/issues?release_tag=v0.0.1&scope=all&state=closed",
+      "closed_merge_requests_url": "https://gitlab.com/panta-123/test/-/merge_requests?release_tag=v0.0.1&scope=all&state=closed",
+      "edit_url": "https://gitlab.com/panta-123/test/-/releases/v0.0.1/edit",
+      "merged_merge_requests_url": "https://gitlab.com/panta-123/test/-/merge_requests?release_tag=v0.0.1&scope=all&state=merged",
+      "opened_issues_url": "https://gitlab.com/panta-123/test/-/issues?release_tag=v0.0.1&scope=all&state=opened",
+      "opened_merge_requests_url": "https://gitlab.com/panta-123/test/-/merge_requests?release_tag=v0.0.1&scope=all&state=opened",
+      "self": "https://gitlab.com/panta-123/test/-/releases/v0.0.1"
+    }
+  }
\ No newline at end of file
diff --git a/tests/data/gitlab-examples/repo.json b/tests/data/gitlab-examples/repo.json
new file mode 100644
index 0000000..1727467
--- /dev/null
+++ b/tests/data/gitlab-examples/repo.json
@@ -0,0 +1,174 @@
+{
+    "id": 61070808,
+    "description": "",
+    "name": "test",
+    "name_with_namespace": "anil panta / test",
+    "path": "test",
+    "path_with_namespace": "panta-123/test",
+    "created_at": "2024-08-22T17:25:13.426Z",
+    "default_branch": "main",
+    "tag_list": [
+      "api",
+      "documentation",
+      "python"
+    ],
+    "topics": [
+      "api",
+      "documentation",
+      "python"
+    ],
+    "ssh_url_to_repo": "git@gitlab.com:panta-123/test.git",
+    "http_url_to_repo": "https://gitlab.com/panta-123/test.git",
+    "web_url": "https://gitlab.com/panta-123/test",
+    "readme_url": "https://gitlab.com/panta-123/test/-/blob/main/README.md",
+    "forks_count": 0,
+    "license_url": "https://gitlab.com/panta-123/test/-/blob/main/LICENSE",
+    "license": {
+      "key": "apache-2.0",
+      "name": "Apache License 2.0",
+      "nickname": null,
+      "html_url": "https://www.apache.org/licenses/LICENSE-2.0",
+      "source_url": null
+    },
+    "avatar_url": null,
+    "star_count": 0,
+    "last_activity_at": "2024-08-27T18:06:48.776Z",
+    "namespace": {
+      "id": 68177703,
+      "name": "anil panta",
+      "path": "panta-123",
+      "kind": "user",
+      "full_path": "panta-123",
+      "parent_id": null,
+      "avatar_url": "https://secure.gravatar.com/avatar/f7ecdfd6bf7abb12bcc280c2d7fb532fc190ac87ffd087147eb101bb93c73498?s=80&d=identicon",
+      "web_url": "https://gitlab.com/panta-123"
+    },
+    "container_registry_image_prefix": "registry.gitlab.com/panta-123/test",
+    "_links": {
+      "self": "https://gitlab.com/api/v4/projects/61070808",
+      "issues": "https://gitlab.com/api/v4/projects/61070808/issues",
+      "merge_requests": "https://gitlab.com/api/v4/projects/61070808/merge_requests",
+      "repo_branches": "https://gitlab.com/api/v4/projects/61070808/repository/branches",
+      "labels": "https://gitlab.com/api/v4/projects/61070808/labels",
+      "events": "https://gitlab.com/api/v4/projects/61070808/events",
+      "members": "https://gitlab.com/api/v4/projects/61070808/members",
+      "cluster_agents": "https://gitlab.com/api/v4/projects/61070808/cluster_agents"
+    },
+    "packages_enabled": true,
+    "empty_repo": false,
+    "archived": false,
+    "visibility": "public",
+    "owner": {
+      "id": 14699208,
+      "username": "panta-123",
+      "name": "anil panta",
+      "state": "active",
+      "locked": false,
+      "avatar_url": "https://secure.gravatar.com/avatar/f7ecdfd6bf7abb12bcc280c2d7fb532fc190ac87ffd087147eb101bb93c73498?s=80&d=identicon",
+      "web_url": "https://gitlab.com/panta-123"
+    },
+    "resolve_outdated_diff_discussions": false,
+    "container_expiration_policy": {
+      "cadence": "1d",
+      "enabled": false,
+      "keep_n": 10,
+      "older_than": "90d",
+      "name_regex": ".*",
+      "name_regex_keep": null,
+      "next_run_at": "2024-08-23T17:25:13.452Z"
+    },
+    "repository_object_format": "sha1",
+    "issues_enabled": true,
+    "merge_requests_enabled": true,
+    "wiki_enabled": true,
+    "jobs_enabled": true,
+    "snippets_enabled": true,
+    "container_registry_enabled": true,
+    "service_desk_enabled": true,
+    "service_desk_address": "contact-project+panta-123-test-61070808-issue-@incoming.gitlab.com",
+    "can_create_merge_request_in": true,
+    "issues_access_level": "enabled",
+    "repository_access_level": "enabled",
+    "merge_requests_access_level": "enabled",
+    "forking_access_level": "enabled",
+    "wiki_access_level": "enabled",
+    "builds_access_level": "enabled",
+    "snippets_access_level": "enabled",
+    "pages_access_level": "enabled",
+    "analytics_access_level": "enabled",
+    "container_registry_access_level": "enabled",
+    "security_and_compliance_access_level": "private",
+    "releases_access_level": "enabled",
+    "environments_access_level": "enabled",
+    "feature_flags_access_level": "enabled",
+    "infrastructure_access_level": "enabled",
+    "monitor_access_level": "enabled",
+    "model_experiments_access_level": "enabled",
+    "model_registry_access_level": "enabled",
+    "emails_disabled": false,
+    "emails_enabled": true,
+    "shared_runners_enabled": true,
+    "lfs_enabled": true,
+    "creator_id": 14699208,
+    "import_url": null,
+    "import_type": null,
+    "import_status": "none",
+    "import_error": null,
+    "open_issues_count": 0,
+    "description_html": "",
+    "updated_at": "2024-08-27T18:06:48.808Z",
+    "ci_default_git_depth": 20,
+    "ci_forward_deployment_enabled": true,
+    "ci_forward_deployment_rollback_allowed": true,
+    "ci_job_token_scope_enabled": false,
+    "ci_separated_caches": true,
+    "ci_allow_fork_pipelines_to_run_in_parent_project": true,
+    "ci_id_token_sub_claim_components": [
+      "project_path",
+      "ref_type",
+      "ref"
+    ],
+    "build_git_strategy": "fetch",
+    "keep_latest_artifact": true,
+    "restrict_user_defined_variables": false,
+    "ci_pipeline_variables_minimum_override_role": "maintainer",
+    "runners_token": "GR1348941wr5ASHJzjU_Q_JF_3zGT",
+    "runner_token_expiration_interval": null,
+    "group_runners_enabled": true,
+    "auto_cancel_pending_pipelines": "enabled",
+    "build_timeout": 3600,
+    "auto_devops_enabled": false,
+    "auto_devops_deploy_strategy": "continuous",
+    "ci_push_repository_for_job_token_allowed": false,
+    "ci_config_path": "",
+    "public_jobs": true,
+    "shared_with_groups": [],
+    "only_allow_merge_if_pipeline_succeeds": false,
+    "allow_merge_on_skipped_pipeline": null,
+    "request_access_enabled": true,
+    "only_allow_merge_if_all_discussions_are_resolved": false,
+    "remove_source_branch_after_merge": true,
+    "printing_merge_request_link_enabled": true,
+    "merge_method": "merge",
+    "squash_option": "default_off",
+    "enforce_auth_checks_on_uploads": true,
+    "suggestion_commit_message": null,
+    "merge_commit_template": null,
+    "squash_commit_template": null,
+    "issue_branch_template": null,
+    "warn_about_potentially_unwanted_characters": true,
+    "autoclose_referenced_issues": true,
+    "external_authorization_classification_label": "",
+    "requirements_enabled": false,
+    "requirements_access_level": "enabled",
+    "security_and_compliance_enabled": true,
+    "pre_receive_secret_detection_enabled": false,
+    "compliance_frameworks": [],
+    "permissions": {
+      "project_access": {
+        "access_level": 50,
+        "notification_level": 3
+      },
+      "group_access": null
+    }
+  }
\ No newline at end of file
diff --git a/tests/test_cli.py b/tests/test_cli.py
index e76d301..9c0de50 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -4,24 +4,26 @@
 # @created 2022-12-08
 # @license Please see the file named LICENSE in the project directory
 # @website https://github.com/caltechlibrary/iga
+# pylint: disable=redefined-outer-name
 # =============================================================================
 
+import os
+from os import path
+from unittest.mock import patch
 import click
 import click.testing
 import json5
-import os
-from   os import path
+import pytest
 from   sidetrack import log
-from   unittest.mock import patch
 
-from   iga.exit_codes import ExitCode
+from iga.cli import cli
+from iga.exit_codes import ExitCode
 from iga.github import (
     GitHubAccount,
     GitHubRelease,
     GitHubRepo,
 )
 
-
 # Mocks
 # .............................................................................
 
@@ -90,7 +92,10 @@ def mocked_orcid_data(orcid):
     with open(path.join(orcid_dir, orcid_filename), 'r') as f:
         return json5.load(f)
 
-
+@pytest.fixture
+def cli_runner():
+    return click.testing.CliRunner()
+
 # Tests
 # .............................................................................
 
@@ -123,30 +128,21 @@ def test_environment_vars_from_options(capsys):
     assert 'GITHUB_TOKEN' in os.environ
     assert os.environ['GITHUB_TOKEN'] == 'gtoken'
 
-
-def test_no_args(capsys):
-    from iga.cli import cli
-    runner = click.testing.CliRunner()
-    result = runner.invoke(cli)
+def test_no_args(cli_runner):
+    result = cli_runner.invoke(cli)
     assert 'Usage' in result.output
     assert result.exit_code == int(ExitCode.success)
 
-
-def test_unknown_arg(capsys):
-    from iga.cli import cli
-    runner = click.testing.CliRunner()
-    result = runner.invoke(cli, ['--foo'])
+@pytest.mark.parametrize("flag", ["--foo"])
+def test_unknown_arg(cli_runner, flag):
+    result = cli_runner.invoke(cli, [flag])
     assert 'No such option' in result.output
     assert result.exit_code == int(ExitCode.bad_arg)
 
 
-def test_help_flag(capsys):
-    from iga.cli import cli
-    runner = click.testing.CliRunner()
-    result = runner.invoke(cli, ['--help'])
-    assert 'Usage' in result.output
-    assert result.exit_code == int(ExitCode.success)
-    result = runner.invoke(cli, ['-h'])
+@pytest.mark.parametrize("flag", ["--help", "-h"])
+def test_help_flags(cli_runner, flag):
+    result = cli_runner.invoke(cli, [flag])
     assert 'Usage' in result.output
     assert result.exit_code == int(ExitCode.success)
 
@@ -158,26 +154,42 @@ def test_help_flag(capsys):
 #     result = runner.invoke(cli, ['help'])
 #     assert result.exit_code == int(ExitCode.success)
 
-
-def test_mode(capsys):
-    from iga.cli import cli
-    runner = click.testing.CliRunner()
-    result = runner.invoke(cli, ['--mode'])
+@pytest.mark.parametrize("flag", ["--mode"])
+def test_mode(cli_runner, flag):
+    result = cli_runner.invoke(cli, [flag])
     assert 'requires an argument' in result.output
     assert result.exit_code == int(ExitCode.bad_arg)
 
-
-def test_version(capsys):
-    from iga.cli import cli
-    runner = click.testing.CliRunner()
-    result = runner.invoke(cli, ['--version'])
+@pytest.mark.parametrize("flag", ["--version"])
+def test_version(cli_runner, flag):
+    result = cli_runner.invoke(cli, [flag])
     assert 'version' in result.output
     assert result.exit_code == int(ExitCode.success)
 
 
-def test_incomplete_file_arg(capsys):
-    from iga.cli import cli
-    runner = click.testing.CliRunner()
-    result = runner.invoke(cli, ['-f'])
+@pytest.mark.parametrize("flag", ["-f"])
+def test_incomplete_file_arg(cli_runner, flag):
+    result = cli_runner.invoke(cli, [flag])
     assert 'requires an argument' in result.output
     assert result.exit_code == int(ExitCode.bad_arg)
+
+@pytest.mark.parametrize("flag", ['--gitlab', '--gitlab-url', 'https://gitlab.com', '--gitlab-projectid', '', 'v1.0.0'])
+def test_gitlab_projectid_validation(cli_runner, flag):
+    result = cli_runner.invoke(cli, [flag])
+    assert result.exit_code == int(ExitCode.bad_arg)
+
+@pytest.mark.parametrize("flag", ['--gitlab', '--gitlab-url', 'https://gitlab.com', 'v1.0.0'])
+def test_gitlab_missing_required_options(cli_runner, flag):
+    result = cli_runner.invoke(cli, [flag])
+    assert result.exit_code == int(ExitCode.bad_arg)
+    assert 'When using GitLab, all of the following must be provided' in result.output
+
+@pytest.mark.parametrize("flag", ['--gitlab', '--gitlab-url', 'https://gitlab.com', '--gitlab-projectid', 'group/project', '--github-account', 'user', 'v1.0.0'])
+def test_gitlab_invalid_combination_projectid_account(cli_runner, flag):
+    result = cli_runner.invoke(cli, [flag])
+    assert result.exit_code == int(ExitCode.bad_arg)
+
+@pytest.mark.parametrize("flag", ['--gitlab', '--gitlab-url', 'https://gitlab.com', '--gitlab-projectid', 'group/project', '--github-repo', 'myrepo', 'v1.0.0'])
+def test_gitlab_invalid_combination_projectid_repo(cli_runner, flag):
+    result = cli_runner.invoke(cli, [flag])
+    assert result.exit_code == int(ExitCode.bad_arg)
diff --git a/tests/test_gitlab.py b/tests/test_gitlab.py
new file mode 100644
index 0000000..52ddfbb
--- /dev/null
+++ b/tests/test_gitlab.py
@@ -0,0 +1,30 @@
+from os import path
+import pytest
+from iga.gitlab  import (
+    gitlab_account_repo_tag,
+    valid_gitlab_release_url,
+
+)
+
+HERE = path.dirname(path.abspath(__file__))
+
+
+def test_gitlab_account_repo_tag():
+    url = 'https://gitlab.com/panta-123/test/-/releases/v0.0.1'
+    assert gitlab_account_repo_tag(url) == (None, 'panta-123%2Ftest', 'v0.0.1')
+
+
+@pytest.mark.parametrize("url, expected", [
+    ("https://gitlab.com/panta-123/test/-/releases/v0.0.1", True),
+    ("https://gitlab.com/username/repo/-/releases/v1.0.0", True),
+    ("https://gitlab.com/api/v4/projects/username/repo/releases/", False),
+    ("https://gitlab.com/username/repo/-/releases/", False),
+    ("https://github.com/username/repo/releases/tag/v1.0.0", False),
+    ("https://gitlab.com/username/repo/tree/master", False),
+    ("https://gitlab.com/api/v4/projects/username/repo/issues", False),
+    ("https://gitlab.com/username/repo/-/raw/master/README.md", False),
+    ("https://gitlab.com", False),
+    ("not_a_url", False),
+])
+def test_valid_gitlab_release_url(url, expected):
+    assert valid_gitlab_release_url(url) == expected
diff --git a/tests/test_gitlab_mocks.py b/tests/test_gitlab_mocks.py
new file mode 100644
index 0000000..328cca7
--- /dev/null
+++ b/tests/test_gitlab_mocks.py
@@ -0,0 +1,160 @@
+from os import path
+import json5
+from unittest.mock import patch, Mock
+from pathlib import Path
+import base64
+import pytest
+
+import iga.github
+from iga.gitlab  import (
+    GitLabAPIError,
+    _gitlab_get,
+    gitlab_release,
+    gitlab_repo,
+    gitlab_release_assets,
+    gitlab_account_repo_tag,
+    gitlab_repo_file,
+    gitlab_account,
+    GitLabRelease,
+    GitLabRepo,
+    GitLabAccount,
+    GitLabAsset,
+    GitLabLicense
+)
+
+import pytest
+from pathlib import Path
+import json5
+from unittest.mock import Mock
+from iga.gitlab import gitlab_release, gitlab_repo, gitlab_account, GitLabRelease, GitLabRepo, GitLabAccount
+
+# Fixture for loading JSON data
+@pytest.fixture
+def load_json_data():
+    def _load_json(file_name):
+        file_path = Path(__file__).parent / 'data' / 'gitlab-examples' / file_name
+        with file_path.open('r', encoding='utf-8') as f:
+            return json5.load(f)
+    return _load_json
+
+# Fixture for mocking GitLab API responses
+@pytest.fixture
+def mock_gitlab_api(mocker):
+    def _mock_api(json_data):
+        mock_response = Mock()
+        mock_response.json.return_value = json_data
+        mocker.patch("iga.gitlab._gitlab_get", return_value=mock_response)
+    return _mock_api
+
+# Parameterized test for releases
+@pytest.mark.parametrize("field", ["name", "description", "created_at", "tag_name", "released_at", "_links", "assets", "author"])
+def test_gitlab_release(load_json_data, mock_gitlab_api, field):
+    releases_json = load_json_data('release.json')
+    mock_gitlab_api(releases_json)
+    
+    release = gitlab_release('61070808', "v0.0.1")
+    assert getattr(release, field) == releases_json[field]
+
+# Test for GitLab account
+def test_gitlab_account(load_json_data, mock_gitlab_api):
+    acc_json = load_json_data('account.json')[0]
+    mock_gitlab_api([acc_json])
+    
+    acc = gitlab_account(acc_json['username'])
+    assert acc.username == acc_json['username']
+    assert acc.id == acc_json['id']
+
+# Test for GitLab repo
+@pytest.mark.parametrize("field", ["name", "id", "description", "created_at", "web_url", "updated_at", "license", "_links", "owner", "topics"])
+def test_gitlab_repo(load_json_data, mock_gitlab_api, mocker, field):
+    repo_json = load_json_data('repo.json')
+    mock_gitlab_api(repo_json)
+    repo = gitlab_repo('test')
+
+    # Mock _object_for_gitlab to return a GitLabRepo instance
+    mocked_function = mocker.patch("iga.gitlab._object_for_gitlab")
+    mocked_function.return_value = GitLabRepo(repo_json)
+    value = mocked_function()
+
+    # Assert that both repo and value are instances of GitLabRepo
+    assert isinstance(value, GitLabRepo)
+    if field == "_links":
+        assert repo._links["issues"] == repo_json['_links']["issues"]
+        assert value._links["issues"] == repo_json['_links']["issues"]
+    elif field == "license":
+        assert repo.license == repo_json["license"]
+        assert isinstance(value.license, GitLabLicense)
+        assert value.license.name == repo_json["license"]["name"]
+    else:
+        assert getattr(repo, field) == repo_json[field]
+        assert getattr(value, field) == repo_json[field]
+
+@pytest.fixture
+def mock_repo():
+    repo = Mock(spec=GitLabRepo)
+    repo.id = 12345
+    repo._file_contents = {}
+    return repo
+
+def test_gitlab_repo_file(mock_repo, mocker):
+    # Prepare the mock API response
+    file_path = Path(__file__).parent / 'data' / 'gitlab-examples' / 'CITATION.cff'
+    with file_path.open('r', encoding='utf-8') as f:
+        mock_file_content = f.read()
+    base64_content = base64.b64encode(mock_file_content.encode()).decode()
+    
+    mock_response = mocker.Mock()
+    mock_response.json.return_value = {
+        'content': base64_content,
+        'encoding': 'base64',
+    }
+
+    # Patch the _gitlab_get function to return the mock response
+    mock_gitlab_get = mocker.patch("iga.gitlab._gitlab_get", return_value=mock_response)
+
+    # Call the function with the mock data
+    filename = 'CITATION.cff'
+    tag_name = 'v1.0'  # Example tag name
+    content = gitlab_repo_file(mock_repo, tag_name, filename)
+
+    # Assert the content matches what was read from the file
+    assert content == mock_file_content
+
+    # Assert the content is cached in the repo object
+    assert mock_repo._file_contents[filename] == mock_file_content
+
+    # Verify GitLab API interaction
+    assert mock_repo.id == 12345  # Verify the mock repo ID
+    mock_gitlab_get.assert_called_once()  # Verify API call
+
+def test_gitlab_release_assets(load_json_data, mock_gitlab_api):
+    # Setup
+    releases_json = load_json_data('release.json')
+    mock_gitlab_api(releases_json)
+
+    # Exercise and Verify
+    # Test with all_assets=False
+    assets = gitlab_release_assets('61070808', "v0.0.1", all_assets=False)
+    expected_assets = [
+        source["url"] for source in releases_json['assets']['sources']
+        if source["format"] == 'zip'
+    ]
+    assert assets == expected_assets
+
+    # Test with all_assets=True
+    assets = gitlab_release_assets('61070808', "v0.0.1", all_assets=True)
+    expected_all_assets = [
+        source["url"] for source in releases_json['assets']['sources']
+    ]
+    assert assets == expected_all_assets
+
+    # Verify GitLabAsset instances
+    for source in releases_json['assets']['sources']:
+        asset = GitLabAsset(source)
+        assert isinstance(asset, GitLabAsset)
+        assert asset.url.startswith("https://gitlab.com/panta-123/test/-/archive/")
+
+@pytest.mark.parametrize("mock_return", ['bar'])
+def test_patch_gitlab_repo(mocker, mock_return):
+    mocker.patch('iga.gitlab.gitlab_repo', return_value=mock_return)
+    assert iga.gitlab.gitlab_repo('a', 'b') == mock_return