diff --git a/swh/web/assets/src/bundles/browse/origin-save.js b/swh/web/assets/src/bundles/browse/origin-save.js
index eeb2525b..19133cf4 100644
--- a/swh/web/assets/src/bundles/browse/origin-save.js
+++ b/swh/web/assets/src/bundles/browse/origin-save.js
@@ -1,161 +1,178 @@
 /**
  * Copyright (C) 2018  The Software Heritage developers
  * See the AUTHORS file at the top-level directory of this distribution
  * License: GNU Affero General Public License version 3, or any later version
  * See top-level LICENSE file for more information
  */
 
-import {handleFetchError, csrfPost} from 'utils/functions';
+import {handleFetchError, csrfPost, isGitRepoUrl} from 'utils/functions';
 import {validate} from 'validate.js';
 
 let saveRequestsTable;
 
 export function initOriginSave() {
 
   $(document).ready(() => {
 
     fetch(Urls.browse_origin_save_types_list())
       .then(response => response.json())
       .then(data => {
         for (let originType of data) {
           $('#swh-input-origin-type').append(`<option value="${originType}">${originType}</option>`);
         }
       });
 
     saveRequestsTable = $('#swh-origin-save-requests').DataTable({
       serverSide: true,
       ajax: Urls.browse_origin_save_requests_list('all'),
       columns: [
         {
           data: 'save_request_date',
           name: 'request_date',
           render: (data, type, row) => {
             if (type === 'display') {
               let date = new Date(data);
               return date.toLocaleString();
             }
             return data;
           }
         },
         {
           data: 'origin_type',
           name: 'origin_type'
 
         },
         {
           data: 'origin_url',
           name: 'origin_url',
           render: (data, type, row) => {
             if (type === 'display') {
               return `<a href="${data}">${data}</a>`;
             }
             return data;
           }
         },
         {
           data: 'save_request_status',
           name: 'status'
         },
         {
           data: 'save_task_status',
           name: 'save_task_status',
           render: (data, type, row) => {
             if (data === 'succeed') {
               let browseOriginUrl = Urls.browse_origin(row.origin_url);
               if (row.visit_date) {
                 browseOriginUrl += `visit/${row.visit_date}/`;
               }
               return `<a href="${browseOriginUrl}">${data}</a>`;
             }
             return data;
           }
         }
       ],
       scrollY: '50vh',
       scrollCollapse: true,
       order: [[0, 'desc']]
     });
 
     setInterval(() => {
       saveRequestsTable.ajax.reload(null, false);
     }, 5000);
 
     $('#swh-origin-save-requests-list-tab').on('shown.bs.tab', () => {
       saveRequestsTable.draw();
     });
 
     $('#swh-save-origin-form').submit(event => {
       event.preventDefault();
       event.stopPropagation();
       if (event.target.checkValidity()) {
         $(event.target).removeClass('was-validated');
         let originType = $('#swh-input-origin-type').val();
         let originUrl = $('#swh-input-origin-url').val();
         let addSaveOriginRequestUrl = Urls.browse_origin_save_request(originType, originUrl);
         let grecaptchaData = {'g-recaptcha-response': grecaptcha.getResponse()};
         let headers = {
           'Accept': 'application/json',
           'Content-Type': 'application/json'
         };
         let body = JSON.stringify(grecaptchaData);
         csrfPost(addSaveOriginRequestUrl, headers, body)
           .then(handleFetchError)
           .then(response => response.json())
           .then(data => {
             if (data.save_request_status === 'accepted') {
               $('#swh-origin-save-request-status').css('color', 'green');
               $('#swh-origin-save-request-status').text(
-                'The origin save request has been accepted and will be processed as soon as possible.');
+                'The "save code now" request has been accepted and will be processed as soon as possible.');
             } else {
               $('#swh-origin-save-request-status').css('color', '#fecd1b');
               $('#swh-origin-save-request-status').text(
-                'The origin save request has been put in pending state and may be accepted for processing after manual review.');
+                'The "save code now" request has been put in pending state and may be accepted for processing after manual review.');
             }
             grecaptcha.reset();
           })
           .catch(response => {
             if (response.status === 403) {
               $('#swh-origin-save-request-status').css('color', 'red');
               $('#swh-origin-save-request-status').text(
-                'The origin save request has been rejected because the reCAPTCHA could not be validated or the provided origin url is blacklisted.');
+                'The "save code now" request has been rejected because the reCAPTCHA could not be validated or the provided origin url is blacklisted.');
             }
             grecaptcha.reset();
           });
       } else {
         $(event.target).addClass('was-validated');
       }
     });
 
     $('#swh-show-origin-save-requests-list').on('click', (event) => {
       event.preventDefault();
       $('.nav-tabs a[href="#swh-origin-save-requests-list"]').tab('show');
     });
 
     $('#swh-input-origin-url').on('input', function(event) {
       let originUrl = $(this).val();
       $('#swh-input-origin-type option').each(function() {
         let val = $(this).val();
         if (val && originUrl.includes(val)) {
           $(this).prop('selected', true);
         }
       });
     });
 
   });
 
 }
 
 export function validateSaveOriginUrl(input) {
   let validUrl = validate({website: input.value}, {
     website: {
       url: {
-        schemes: ['http', 'https', 'svn']
+        schemes: ['http', 'https', 'svn', 'git']
       }
     }
-  });
-  if (validUrl === undefined) {
+  }) === undefined;
+  let originType = $('#swh-input-origin-type').val();
+  if (originType === 'git' && validUrl) {
+    // additional checks for well known code hosting providers
+    let githubIdx = input.value.indexOf('://github.com');
+    let gitlabIdx = input.value.indexOf('://gitlab.com');
+    let gitSfIdx = input.value.indexOf('://git.code.sf.net');
+    let bitbucketIdx = input.value.indexOf('://bitbucket.org');
+    if (githubIdx !== -1 && githubIdx <= 5) {
+      validUrl = isGitRepoUrl(input.value, 'github.com');
+    } else if (gitlabIdx !== -1 && gitlabIdx <= 5) {
+      validUrl = isGitRepoUrl(input.value, 'gitlab.com');
+    } else if (gitSfIdx !== -1 && gitSfIdx <= 5) {
+      validUrl = isGitRepoUrl(input.value, 'git.code.sf.net/p');
+    } else if (bitbucketIdx !== -1 && bitbucketIdx <= 5) {
+      validUrl = isGitRepoUrl(input.value, 'bitbucket.org');
+    }
+  }
+  if (validUrl) {
     input.setCustomValidity('');
   } else {
-    input.setCustomValidity('The origin url is not valid');
+    input.setCustomValidity('The origin url is not valid or does not reference a code repository');
   }
 }
diff --git a/swh/web/assets/src/utils/functions.js b/swh/web/assets/src/utils/functions.js
index c72ecff2..945b1734 100644
--- a/swh/web/assets/src/utils/functions.js
+++ b/swh/web/assets/src/utils/functions.js
@@ -1,38 +1,45 @@
 /**
  * Copyright (C) 2018  The Software Heritage developers
  * See the AUTHORS file at the top-level directory of this distribution
  * License: GNU Affero General Public License version 3, or any later version
  * See top-level LICENSE file for more information
  */
 
 // utility functions
 
 export function handleFetchError(response) {
   if (!response.ok) {
     throw response;
   }
   return response;
 }
 
 export function handleFetchErrors(responses) {
   for (let i = 0; i < responses.length; ++i) {
     if (!responses[i].ok) {
       throw responses[i];
     }
   }
   return responses;
 }
 
 export function staticAsset(asset) {
   return `${__STATIC__}${asset}`;
 }
 
 export function csrfPost(url, headers = {}, body = null) {
   headers['X-CSRFToken'] = Cookies.get('csrftoken');
   return fetch(url, {
     credentials: 'include',
     headers: headers,
     method: 'POST',
     body: body
   });
 }
+
+export function isGitRepoUrl(url, domain) {
+  let endOfPattern = '\\/[\\w\\.-]+\\/?(?!=.git)(?:\\.git(?:\\/?|\\#[\\w\\.\\-_]+)?)?$';
+  let pattern = `(?:git|https?|git@)(?:\\:\\/\\/)?${domain}[/|:][A-Za-z0-9-]+?` + endOfPattern;
+  let re = new RegExp(pattern);
+  return re.test(url);
+};
diff --git a/swh/web/common/origin_save.py b/swh/web/common/origin_save.py
index 260d8b7f..2b229856 100644
--- a/swh/web/common/origin_save.py
+++ b/swh/web/common/origin_save.py
@@ -1,351 +1,351 @@
 # Copyright (C) 2018  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from bisect import bisect_right
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.exceptions import ValidationError
 from django.core.validators import URLValidator
 
 from swh.web import config
 from swh.web.common import service
 from swh.web.common.exc import BadInputExc, ForbiddenExc
 from swh.web.common.models import (
     SaveUnauthorizedOrigin, SaveAuthorizedOrigin, SaveOriginRequest,
     SAVE_REQUEST_ACCEPTED, SAVE_REQUEST_REJECTED, SAVE_REQUEST_PENDING
 )
 from swh.web.common.utils import get_origin_visits, parse_timestamp
 
 from swh.scheduler.utils import create_oneshot_task_dict
 
 scheduler = config.scheduler()
 
 
 def get_origin_save_authorized_urls():
     """
     Get the list of origin url prefixes authorized to be
     immediately loaded into the archive (whitelist).
 
     Returns:
         list: The list of authorized origin url prefix
     """
     return [origin.url
             for origin in SaveAuthorizedOrigin.objects.all()]
 
 
 def get_origin_save_unauthorized_urls():
     """
     Get the list of origin url prefixes forbidden to be
     loaded into the archive (blacklist).
 
     Returns:
         list: the list of unauthorized origin url prefix
     """
     return [origin.url
             for origin in SaveUnauthorizedOrigin.objects.all()]
 
 
 def can_save_origin(origin_url):
     """
     Check if a software origin can be saved into the archive.
 
     Based on the origin url, the save request will be either:
 
       * immediately accepted if the url is whitelisted
       * rejected if the url is blacklisted
       * put in pending state for manual review otherwise
 
     Args:
         origin_url (str): the software origin url to check
 
     Returns:
         str: the origin save request status, either *accepted*,
         *rejected* or *pending*
     """
     # origin url may be blacklisted
     for url_prefix in get_origin_save_unauthorized_urls():
         if origin_url.startswith(url_prefix):
             return SAVE_REQUEST_REJECTED
 
     # if the origin url is in the white list, it can be immediately saved
     for url_prefix in get_origin_save_authorized_urls():
         if origin_url.startswith(url_prefix):
             return SAVE_REQUEST_ACCEPTED
 
     # otherwise, the origin url needs to be manually verified
     return SAVE_REQUEST_PENDING
 
 
 # map origin type to scheduler task
 # TODO: do not hardcode the task name here
 # TODO: unlock hg and svn loading once the scheduler
 #       loading tasks are available in production
 _origin_type_task = {
     'git': 'origin-update-git',
     # 'hg': 'origin-load-hg',
     # 'svn': 'origin-load-svn'
 }
 
 SAVE_TASK_NOT_CREATED = 'not created'
 SAVE_TASK_NOT_YET_SCHEDULED = 'not yet scheduled'
 SAVE_TASK_SCHEDULED = 'scheduled'
 SAVE_TASK_SUCCEED = 'succeed'
 SAVE_TASK_FAILED = 'failed'
 
 # map scheduler task status to origin save status
 _save_task_status = {
     'next_run_not_scheduled': SAVE_TASK_NOT_YET_SCHEDULED,
     'next_run_scheduled': SAVE_TASK_SCHEDULED,
     'completed': SAVE_TASK_SUCCEED,
     'disabled': SAVE_TASK_FAILED
 }
 
 
 def get_savable_origin_types():
     return sorted(list(_origin_type_task.keys()))
 
 
 def _check_origin_type_savable(origin_type):
     """
     Get the list of software origin types that can be loaded
     through a save request.
 
     Returns:
         list: the list of savable origin types
     """
     allowed_origin_types = ', '.join(get_savable_origin_types())
     if origin_type not in _origin_type_task:
         raise BadInputExc('Origin of type %s can not be saved! '
                           'Allowed types are the following: %s' %
                           (origin_type, allowed_origin_types))
 
 
-_validate_url = URLValidator(schemes=['http', 'https', 'svn'])
+_validate_url = URLValidator(schemes=['http', 'https', 'svn', 'git'])
 
 
 def _check_origin_url_valid(origin_url):
     try:
         _validate_url(origin_url)
     except ValidationError:
         raise BadInputExc('The provided origin url (%s) is not valid!' %
                           origin_url)
 
 
 def _get_visit_date_for_save_request(save_request):
     visit_date = None
     try:
         origin = {'type': save_request.origin_type,
                   'url': save_request.origin_url}
         origin_info = service.lookup_origin(origin)
         origin_visits = get_origin_visits(origin_info)
         visit_dates = [parse_timestamp(v['date'])
                        for v in origin_visits]
         i = bisect_right(visit_dates, save_request.request_date)
         if i != len(visit_dates):
             save_request.visit_date = visit_dates[i]
             save_request.save()
             visit_date = visit_dates[i]
     except Exception:
         pass
     return visit_date
 
 
 def _save_request_dict(save_request, task=None):
     save_task_status = SAVE_TASK_NOT_CREATED
     visit_date = save_request.visit_date
     if task:
         save_task_status = _save_task_status[task['status']]
         if save_task_status in (SAVE_TASK_FAILED, SAVE_TASK_SUCCEED) \
            and not visit_date:
             visit_date = _get_visit_date_for_save_request(save_request)
         # Ensure last origin visit is available in database
         # before reporting the task execution as successful
         if save_task_status == SAVE_TASK_SUCCEED and not visit_date:
             save_task_status = SAVE_TASK_SCHEDULED
 
     return {'origin_type': save_request.origin_type,
             'origin_url': save_request.origin_url,
             'save_request_date': save_request.request_date.isoformat(),
             'save_request_status': save_request.status,
             'save_task_status': save_task_status,
             'visit_date': visit_date.isoformat() if visit_date else None}
 
 
 def create_save_origin_request(origin_type, origin_url):
     """
     Create a loading task to save a software origin into the archive.
 
     This function aims to create a software origin loading task
     trough the use of the swh-scheduler component.
 
     First, some checks are performed to see if the origin type and
     url are valid but also if the the save request can be accepted.
     If those checks passed, the loading task is then created.
     Otherwise, the save request is put in pending or rejected state.
 
     All the submitted save requests are logged into the swh-web
     database to keep track of them.
 
     Args:
         origin_type (str): the type of origin to save (*git*, *hg*, *svn*, ...)
         origin_url (str): the url of the origin to save
 
     Raises:
         BadInputExc: the origin type or url is invalid
         ForbiddenExc: the provided origin url is blacklisted
 
     Returns:
         dict: A dict describing the save request with the following keys:
 
             * **origin_type**: the type of the origin to save
             * **origin_url**: the url of the origin
             * **save_request_date**: the date the request was submitted
             * **save_request_status**: the request status, either *accepted*,
               *rejected* or *pending*
             * **save_task_status**: the origin loading task status, either
               *not created*, *not yet scheduled*, *scheduled*, *succeed* or
               *failed*
 
 
     """
     _check_origin_type_savable(origin_type)
     _check_origin_url_valid(origin_url)
     save_request_status = can_save_origin(origin_url)
     task = None
 
     # if the origin save request is accepted, create a scheduler
     # task to load it into the archive
     if save_request_status == SAVE_REQUEST_ACCEPTED:
         # create a task with high priority
         kwargs = {'priority': 'high'}
         # set task parameters according to the origin type
         if origin_type == 'git':
             kwargs['repo_url'] = origin_url
         elif origin_type == 'hg':
             kwargs['origin_url'] = origin_url
         elif origin_type == 'svn':
             kwargs['origin_url'] = origin_url
             kwargs['svn_url'] = origin_url
 
         sor = None
         # get list of previously sumitted save requests
         current_sors = \
             list(SaveOriginRequest.objects.filter(origin_type=origin_type,
                                                   origin_url=origin_url))
 
         can_create_task = False
         # if no save requests previously submitted, create the scheduler task
         if not current_sors:
             can_create_task = True
         else:
             # get the latest submitted save request
             sor = current_sors[0]
             # if it was in pending state, we need to create the scheduler task
             # and update the save request info in the database
             if sor.status == SAVE_REQUEST_PENDING:
                 can_create_task = True
             # a task has already been created to load the origin
             elif sor.loading_task_id != -1:
                 # get the scheduler task and its status
                 task = scheduler.get_tasks([sor.loading_task_id])[0]
                 save_task_status = _save_task_status[task['status']]
                 # create a new scheduler task only if the previous one has been
                 # already executed
                 if save_task_status == SAVE_TASK_FAILED or \
                    save_task_status == SAVE_TASK_SUCCEED:
                     can_create_task = True
                     sor = None
                 else:
                     can_create_task = False
 
         if can_create_task:
             # effectively create the scheduler task
             task_dict = create_oneshot_task_dict(
                 _origin_type_task[origin_type], **kwargs)
             task = scheduler.create_tasks([task_dict])[0]
 
             # pending save request has been accepted
             if sor:
                 sor.status = SAVE_REQUEST_ACCEPTED
                 sor.loading_task_id = task['id']
                 sor.save()
             else:
                 sor = SaveOriginRequest.objects.create(origin_type=origin_type,
                                                        origin_url=origin_url,
                                                        status=save_request_status, # noqa
                                                        loading_task_id=task['id']) # noqa
     # save request must be manually reviewed for acceptation
     elif save_request_status == SAVE_REQUEST_PENDING:
         # check if there is already such a save request already submitted,
         # no need to add it to the database in that case
         try:
             sor = SaveOriginRequest.objects.get(origin_type=origin_type,
                                                 origin_url=origin_url,
                                                 status=save_request_status)
         # if not add it to the database
         except ObjectDoesNotExist:
             sor = SaveOriginRequest.objects.create(origin_type=origin_type,
                                                    origin_url=origin_url,
                                                    status=save_request_status)
     # origin can not be saved as its url is blacklisted,
     # log the request to the database anyway
     else:
         sor = SaveOriginRequest.objects.create(origin_type=origin_type,
                                                origin_url=origin_url,
                                                status=save_request_status)
 
     if save_request_status == SAVE_REQUEST_REJECTED:
         raise ForbiddenExc('The origin url is blacklisted and will not be '
                            'loaded into the archive.')
 
     return _save_request_dict(sor, task)
 
 
 def get_save_origin_requests_from_queryset(requests_queryset):
     """
     Get all save requests from a SaveOriginRequest queryset.
 
     Args:
         requests_queryset (django.db.models.QuerySet): input
             SaveOriginRequest queryset
 
     Returns:
         list: A list of save origin requests dict as described in
         :func:`swh.web.common.origin_save.create_save_origin_request`
     """
     requests = []
     for sor in requests_queryset:
         # rejected saving task or pending for acceptation
         if sor.loading_task_id == -1:
             requests.append(_save_request_dict(sor))
             continue
         task = scheduler.get_tasks([sor.loading_task_id])
         # loading task may have been archived, do not return
         # save request info in that case
         if task:
             requests.append(_save_request_dict(sor, task[0]))
     return requests
 
 
 def get_save_origin_requests(origin_type, origin_url):
     """
     Get all save requests for a given software origin.
 
     Args:
         origin_type (str): the type of the origin
         origin_url (str): the url of the origin
 
     Raises:
         BadInputExc: the origin type or url is invalid
 
     Returns:
         list: A list of save origin requests dict as described in
         :func:`swh.web.common.origin_save.create_save_origin_request`
     """
     _check_origin_type_savable(origin_type)
     _check_origin_url_valid(origin_url)
     sors = SaveOriginRequest.objects.filter(origin_type=origin_type,
                                             origin_url=origin_url)
     return get_save_origin_requests_from_queryset(sors)
diff --git a/swh/web/templates/browse/origin-save.html b/swh/web/templates/browse/origin-save.html
index 9290c348..37065320 100644
--- a/swh/web/templates/browse/origin-save.html
+++ b/swh/web/templates/browse/origin-save.html
@@ -1,109 +1,109 @@
 {% extends "./layout.html" %}
 
 {% comment %}
 Copyright (C) 2018  The Software Heritage developers
 See the AUTHORS file at the top-level directory of this distribution
 License: GNU Affero General Public License version 3, or any later version
 See top-level LICENSE file for more information
 {% endcomment %}
 
 {% block header %}
 {{ block.super }}
 <script src='https://www.google.com/recaptcha/api.js'></script>
 {% endblock %}
 
 {% block navbar-content %}
 <h4>Save code now</h4>
 {% endblock %}
 
 {% block browse-content %}
 
 <ul class="nav nav-tabs" style="padding-left: 5px;">
   <li class="nav-item"><a class="nav-link active" data-toggle="tab" id="swh-origin-save-request-create-tab" href="#swh-origin-save-requests-create">Create save request</a></li>
   <li class="nav-item"><a class="nav-link" data-toggle="tab" id="swh-origin-save-requests-list-tab" href="#swh-origin-save-requests-list">Browse save requests</a></li>
 </ul>
 
 <div class="tab-content">
   <div id="swh-origin-save-requests-create" class="tab-pane active">
     <p class="mt-3">
       You can contribute to extend the content of the Software Heritage archive by submitting an origin
       save request. To do so, fill the required info in the form below:
     </p>
     <ul>
       <li><b>Origin type:</b> the type of version control system the software origin is using.<br/>
         Currently, the only supported type is <code>git</code>, for origins using <a href="https://git-scm.com/">Git</a>.<br/>
         Soon, the following origin types will also be available to save into the archive:
         <ul>
           <li><code>hg</code>, for origins using <a href="https://www.mercurial-scm.org/">Mercurial</a></li>
           <li><code>svn</code>, for origins using <a href="https://subversion.apache.org/">Subversion</a></li>
         </ul>
       </li>
       <li><b>Origin url:</b> the url of the remote repository for the software origin.</li>
     </ul>
     <p>
       Once submitted, your save request can either be:
     </p>
     <ul>
       <li><b>accepted:</b> a visit to the provided origin will then be scheduled by Software Heritage in order to
         load its content into the archive as soon as possible</li>
       <li><b>rejected:</b> the provided origin url is blacklisted and no visit will be scheduled</li>
       <li>put in <b>pending</b> state: a manual review will then be performed in order to determine if the
         origin can be safely loaded or not into the archive</li>
     </ul>
     <p>
       Once a save request has been accepted, you can follow its current status in the
       <a id="swh-show-origin-save-requests-list" href="#swh-origin-save-requests-list">submitted save requests list</a>.
     </p>
     <form id="swh-save-origin-form" class="needs-validation" novalidate>
       {% csrf_token %}
       <div class="form-row">
         <div class="col-md-1"></div>
         <div class="form-group col-md-2">
           <label for="swh-input-origin-type">Origin type</label>
           <select id="swh-input-origin-type" class="form-control" required>
             {% comment %} <option selected value="">Choose...</option> {% endcomment %}
           </select>
           <div class="invalid-feedback">The origin type must be specified</div>
         </div>
         <div class="form-group col-md-6">
           <label for="swh-input-origin-url">Origin url</label>
           <input type="text" class="form-control" id="swh-input-origin-url" oninput="swh.browse.validateSaveOriginUrl(this)" required>
-          <div class="invalid-feedback">The origin url is not valid</div>
+          <div class="invalid-feedback">The origin url is not valid or does not reference a code repository</div>
         </div>
         <div class="col-md-2"></div>
       </div>
       <div class="form-row">
         <div class="col-md-2"></div>
         <div class="form-group col-md-4">
           <div class="g-recaptcha" id="save-origin-recaptcha" data-sitekey="{{ grecaptcha_site_key }}"></div>
         </div>
         <div class="form-group col-md-1">
           <label for="swh-input-origin-save-submit">&#8203;</label>
           <button type="submit" id="swh-input-origin-save-submit" class="btn btn-default btn-block">Submit</button>
         </div>
       </div>
     </form>
     <p id="swh-origin-save-request-status">
     </p>
   </div>
 
   <div id="swh-origin-save-requests-list" class="tab-pane mt-3">
     <table id="swh-origin-save-requests" class="table table-striped swh-table" width="100%">
       <thead>
         <tr>
           <th>Request date</th>
           <th>Origin type</th>
           <th>Origin url</th>
           <th>Request status</th>
           <th>Save task status</th>
         </tr>
       </thead>
     </table>
   </div>
 </div>
 
 <script>
   swh.browse.initOriginSave();
 </script>
 
 {% endblock %}
\ No newline at end of file