` and config your local network. This will restrict the access to JATOS' GUI (every URL starting with `/jatos`) to the local network.
+
+~~~ shell
+
+ ServerName www.example.com
+
+ # Redirect all unencrypted traffic to the respective HTTPS page
+ Redirect "/" "https://www.example.com/"
+
+
+
+ ServerName www.example.com
+
+ # Restrict access to JATOS GUI to local network
+ #
+ # Order deny,allow
+ # Deny from all
+ # Allow from 127.0.0.1 ::1
+ # Allow from localhost
+ # Allow from 192.168
+ #
+
+ # Needed for JATOS to get the correct host and protocol
+ ProxyPreserveHost On
+ RequestHeader set X-Forwarded-Proto "https"
+ RequestHeader set X-Forwarded-Ssl "on"
+
+ # Your certificate for encryption
+ SSLEngine On
+ SSLCertificateFile /etc/ssl/certs/localhost.crt
+ SSLCertificateKeyFile /etc/ssl/private/localhost.key
+
+ # JATOS uses WebSockets for its batch and group channels
+ RewriteEngine On
+ RewriteCond %{HTTP:Upgrade} =websocket [NC]
+ RewriteRule /(.*) ws://localhost:9000/$1 [P,L]
+ RewriteCond %{HTTP:Upgrade} !=websocket [NC]
+ RewriteRule /(.*) http://localhost:9000/$1 [P,L]
+
+ # Proxy everything to the JATOS running on localhost on port 9000
+ ProxyPass / http://localhost:9000/
+ ProxyPassReverse / http://localhost:9000/
+
+~~~
diff --git a/versioned_docs/version-3.7.1/Serving_the_Internet/JATOS-with-MySQL.md b/versioned_docs/version-3.7.1/Serving_the_Internet/JATOS-with-MySQL.md
new file mode 100644
index 0000000000..b856dc4f30
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Serving_the_Internet/JATOS-with-MySQL.md
@@ -0,0 +1,160 @@
+---
+title: JATOS with MySQL
+slug: /JATOS-with-MySQL.html
+sidebar_position: 7
+---
+
+By default JATOS uses an embedded H2 database and no further setup is necessary but it can be easily configured to work with a MySQL database.
+
+Possible scenarios why one would use an external database are
+* your JATOS will be used by more than a few users (e.g. several research groups or an institute-wide installation)
+* your JATOS will run studies with many participants
+* the expected traffic is rather high (the studies produce a lot of result data)
+* you want to be able to do a regular database backup (with the embedded H2 database this would involve stopping JATOS)
+* higher trust in the reliability of MySQL (although we had no problems with H2 so far)
+
+## Installation
+
+One could install the external database on the same server as JATOS is running or on an extra server depending on ones need.
+
+There are many manuals out there, e.g. [this one](https://www.digitalocean.com/community/tutorials/how-to-install-mysql-on-ubuntu-20-04). One way to set up MySQL:
+
+ 1. Install MySQL, e.g. on Ubuntu
+
+ **JATOS requires MySQL >= 5.7 (8.x is fine)**
+
+ ```bash
+ sudo apt install mysql-server
+ ```
+
+ 1. Log in to MySQL's command line terminal:
+
+ ```bash
+ mysql -u root -p
+ ```
+
+ 1. Create a database for JATOS:
+
+ **Character set and collation are important - otherwise you won't have full UTF-8 support**
+
+ ```bash
+ CREATE DATABASE jatos CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+ ```
+
+ 1. Create a user for JATOS:
+
+ ```bash
+ CREATE USER 'jatosuser'@'localhost' IDENTIFIED BY 'myPassword';
+ ```
+
+ Remember your username and password. You need them when configuring JATOS later on.
+
+ 1. Grant privileges to the new user:
+
+ ```bash
+ GRANT ALL PRIVILEGES ON jatos.* TO 'jatosuser'@'localhost';
+ ```
+
+ 1. You can test the new user: log out of MySQL with `exit` and back in with the newly created user:
+
+ ```bash
+ mysql -u jatosuser -p
+ ```
+
+**Appart from giving JATOS access to the database it is not necessary to create any tables - JATOS is doing this automatically.**
+
+Now you have to configure JATOS to use your MySQL.
+
+
+## Configure JATOS
+
+There are three ways to set up JATOS to work with a MySQL database. If you are in doubt use 'production.conf'.
+
+1. Via JATOS config file which is in your JATOS folder in the `conf` folder: `conf/production.conf`
+
+ Change IP, port, username and password to your needs.
+
+ ~~~ bash
+ db.default.url="jdbc:mysql://127.0.0.1:3306/jatos?characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC"
+ db.default.user="jatosuser"
+ db.default.password="mypassword"
+ db.default.driver=com.mysql.cj.jdbc.Driver
+ ~~~
+
+ **Always restart JATOS after making any changes to the configuration (e.g. with `./loader.sh restart`)**
+
+1. Via command-line arguments:
+ * `-DJATOS_DB_URL` - specifies the URL to the database
+ * `-DJATOS_DB_USERNAME` - set your username
+ * `-DJATOS_DB_PASSWORD` - set your password
+ * `-DJATOS_DB_DRIVER` - always `com.mysql.cj.jdbc.Driver` for MySQL
+
+ E.g. to connect to a MySQL running on 127.0.0.1 and port 3306 use (but change username and password):
+
+ ~~~ bash
+ ./loader.sh start -DJATOS_DB_URL='jdbc:mysql://127.0.0.1:3306/jatos?characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC' -DJATOS_DB_USERNAME=sa -DJATOS_DB_PASSWORD=sa -DJATOS_DB_DRIVER=com.mysql.cj.jdbc.Driver
+ ~~~
+
+1. Via environment variables (change IP, port, username and password)
+
+ ~~~ bash
+ export JATOS_DB_URL="jdbc:mysql://127.0.0.1:3306/jatos?characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC"
+ export JATOS_DB_USERNAME=jatosuser
+ export JATOS_DB_PASSWORD='mypassword'
+ export JATOS_DB_DRIVER=com.mysql.cj.jdbc.Driver
+ ~~~
+
+You can confirm that JATOS is accessing the correct database by opening JATOS' _Administration_ page in a browser and then click on _System Info_: The field _DB URL_ should resemble the one from your config. Another way is by looking in the logs: you should see a line after JATOS started similar to this (with your database URI):
+
+~~~ bash
+14:06:01.760 [info] - p.a.d.DefaultDBApi - Database [default] initialized at jdbc:mysql://localhost/jatos?characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
+~~~
+
+Done. Your JATOS uses your MySQL now.
+
+
+## [Optional] Deactivate MySQL's binary log
+
+MySQL's binary logs (also called binlogs) serve two purposes: replication and data recovery. More can be found in [MySQLs documentation](https://dev.mysql.com/doc/internals/en/binary-log-overview.html#:~:text=The%20binary%20log%20is%20a,14.).
+
+The problem with binary logs is that they can take up quite some disk space depending on the experiments you run on your JATOS. The location of those log files is specified in MySQL's config but on many systems they are under `/var/lib/mysql`. If you have a single MySQL instance (and therefore do not use replication) and you do not need MySQL's data recovery (e.g. have a different backup mechanism) than it is safe to deactivate the binary logs.
+
+Add `skip-log-bin` to the end of your MySQL config ([details](https://dev.mysql.com/doc/refman/8.0/en/replication-options-binary-log.html#option_mysqld_log-bin)). On many Linux systems the config is in `/etc/mysql/mysql.conf.d/mysqld.cnf`.
+
+The part of your 'mysqld.cnf' that configures the binary logs could then look similar to this:
+
+```bash
+# The following can be used as easy to replay backup logs or for replication.
+# note: if you are setting up a replication slave, see README.Debian about
+# other settings you may need to change.
+# server-id = 1
+# log_bin = /var/log/mysql/mysql-bin.log
+# binlog_expire_logs_seconds = 2592000
+# max_binlog_size = 100M
+# binlog_do_db = include_database_name
+# binlog_ignore_db = include_database_name
+skip-log-bin
+```
+
+You have to restart MySQL for the changes to take effect.
+
+
+## [Optional] Increase 'max_allowed_packet' size in older MySQLs
+
+If you have an older MySQL (< 8.x.x) and your experiments will have large resut data you might want to increase the '[max_allowed_packet](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_max_allowed_packet)' size. If your result data is larger than the 'max_allowed_packet' JATOS will just return an 'internal server error'. In JATOS' log in will look similar to this:
+
+```
+[ERROR] - g.ErrorHandler - Internal JATOS error
+[ERROR] - o.h.e.j.s.SqlExceptionHelper - Packet for query is too large (5,920,824 > 4,194,304). You can change this value on the server by setting the 'max_allowed_packet' variable.
+[WARN] - o.h.e.j.s.SqlExceptionHelper - SQL Error: 0, SQLState: S1000
+```
+
+From 8.x.x the 'max_allowed_packet' is by default 64MB and this is usually more than enough. But in version smaller than 8.x.x it is just 4MB by default and before 5.6.6 it's just 1MB.
+
+To increase the 'max_allowed_packet' size just add it to the end of your MySQL config. On many Linux systems the config is in `/etc/mysql/mysql.conf.d/mysqld.cnf`. E.g. to set it to 64MB:
+
+```bash
+max_allowed_packet=64M
+```
+
+You have to restart MySQL for the changes to take effect.
diff --git a/versioned_docs/version-3.7.1/Serving_the_Internet/JATOS-with-Nginx.md b/versioned_docs/version-3.7.1/Serving_the_Internet/JATOS-with-Nginx.md
new file mode 100644
index 0000000000..0343e1b5fa
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Serving_the_Internet/JATOS-with-Nginx.md
@@ -0,0 +1,213 @@
+---
+title: JATOS with Nginx
+slug: /JATOS-with-Nginx.html
+sidebar_position: 9
+---
+
+These are examples for configurations of [Nginx](https://www.nginx.com/) as a proxy in front of JATOS. It is not necessary to run JATOS with a proxy but it's common. They support WebSockets for JATOS' group studies.
+
+The following two configs are the content of `/etc/nginx/nginx.conf`. Change them to your needs. You probably want to change your servers address (`www.example.com` in the example) and the path to the SSL certificate and its key. This `proxy_set_header X-Forwarded-*` is necessary to tell JATOS the original requester's IP address - please leave it unchanged.
+
+As an additional security measurement you can uncomment the `location /jatos` and config your local network. This will restrict the access to JATOS' GUI (every URL starting with `/jatos`) to the local network.
+
+A JATOS server that handles sensitive or private data should always use encryption (HTTPS).
+
+## With HTTPS
+
+~~~ shell
+user www-data;
+worker_processes auto;
+pid /run/nginx.pid;
+include /etc/nginx/modules-enabled/*.conf;
+
+events {
+ worker_connections 768;
+ # multi_accept on;
+}
+
+http {
+ sendfile on;
+ tcp_nopush on;
+ tcp_nodelay on;
+ keepalive_timeout 65;
+ client_max_body_size 500M;
+
+ include /etc/nginx/mime.types;
+ default_type application/octet-stream;
+
+ proxy_buffering off;
+ proxy_set_header X-Forwarded-Proto https;
+ proxy_set_header X-Forwarded-Ssl on;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ proxy_set_header Host $http_host;
+ proxy_http_version 1.1;
+
+ upstream jatos-backend {
+ server 127.0.0.1:9000;
+ }
+
+ # needed for websockets
+ map $http_upgrade $connection_upgrade {
+ default upgrade;
+ '' close;
+ }
+
+ # redirect http to https
+ server {
+ listen 80;
+ server_name www.example.com;
+ rewrite ^ https://www.example.com$request_uri? permanent;
+ }
+
+ server {
+ listen 443 ssl;
+ server_name www.example.com;
+
+ keepalive_timeout 70;
+
+ ssl_certificate /etc/ssl/certs/localhost.crt;
+ ssl_certificate_key /etc/ssl/private/localhost.key;
+
+ ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
+ ssl_prefer_server_ciphers on;
+
+ # websocket location (JATOS' group and batch channel and the test page)
+ location ~ "/(jatos/testWebSocket|publix/[\d]+/(group/join|batch/open))" {
+ proxy_pass http://jatos-backend;
+ proxy_http_version 1.1;
+ proxy_set_header Upgrade $http_upgrade;
+ proxy_set_header Connection $connection_upgrade;
+ proxy_connect_timeout 7d; # keep open for 7 days even without any transmission
+ proxy_send_timeout 7d;
+ proxy_read_timeout 7d;
+ }
+
+ # restrict access to JATOS' GUI to local network
+ #location /jatos {
+ # allow 192.168.1.0/24;
+ # deny all;
+ # proxy_pass http://jatos-backend;
+ #}
+
+ # all other traffic
+ location / {
+ proxy_pass http://jatos-backend;
+ }
+
+ # restrict access to JATOS' GUI to local network 192.168.1.*
+ #location /jatos {
+ # allow 192.168.1.0/24;
+ # deny all;
+ # proxy_pass http://jatos-backend;
+ # proxy_connect_timeout 300;
+ # proxy_send_timeout 300;
+ # proxy_read_timeout 300;
+ # send_timeout 300;
+ #}
+
+ # all other traffic
+ location / {
+ proxy_pass http://jatos-backend;
+ proxy_connect_timeout 300;
+ proxy_send_timeout 300;
+ proxy_read_timeout 300;
+ send_timeout 300;
+ }
+ }
+
+ access_log /var/log/nginx/access.log;
+ error_log /var/log/nginx/error.log;
+
+ include /etc/nginx/conf.d/*.conf;
+ #include /etc/nginx/sites-enabled/*;
+}
+~~~
+
+
+## With HTTPS and Docker
+
+Have a look at [github.com/robinsonkwame/jatos-https-docker-compose](https://github.com/robinsonkwame/jatos-https-docker-compose) for a good example in how to do this (Thanks to Kwame Porter Robinson)
+
+
+## Simple without encryption
+
+~~~ shell
+user www-data;
+worker_processes auto;
+pid /run/nginx.pid;
+
+events {
+ worker_connections 768;
+ # multi_accept on;
+}
+
+http {
+ sendfile on;
+ keepalive_timeout 65;
+ client_max_body_size 500M;
+
+ include /etc/nginx/mime.types;
+ default_type application/octet-stream;
+
+ proxy_buffering off;
+ proxy_set_header X-Forwarded-Proto http;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ proxy_set_header Host $http_host;
+ proxy_http_version 1.1;
+
+ upstream jatos-backend {
+ server 127.0.0.1:9000;
+ }
+
+ # needed for websockets
+ map $http_upgrade $connection_upgrade {
+ default upgrade;
+ '' close;
+ }
+
+ server {
+ listen 80;
+
+ keepalive_timeout 70;
+ server_name www.example.com;
+
+ # websocket location (JATOS' group and batch channel and the test page)
+ location ~ "^/(jatos/testWebSocket|publix/[\d]+/(group/join|batch/open))" {
+ proxy_pass http://jatos-backend;
+ proxy_http_version 1.1;
+ proxy_set_header Upgrade $http_upgrade;
+ proxy_set_header Connection $connection_upgrade;
+ proxy_connect_timeout 7d; # keep open for 7 days even without any transmission
+ proxy_send_timeout 7d;
+ proxy_read_timeout 7d;
+ }
+
+ # restrict access to JATOS' GUI to local network
+ #location /jatos {
+ # allow 192.168.1.0/24;
+ # deny all;
+ # proxy_pass http://jatos-backend;
+ # proxy_connect_timeout 300;
+ # proxy_send_timeout 300;
+ # proxy_read_timeout 300;
+ # send_timeout 300;
+ #}
+
+ # all other traffic
+ location / {
+ proxy_pass http://jatos-backend;
+ proxy_connect_timeout 300;
+ proxy_send_timeout 300;
+ proxy_read_timeout 300;
+ send_timeout 300;
+
+ }
+ }
+
+ access_log /var/log/nginx/access.log;
+ error_log /var/log/nginx/error.log;
+
+ include /etc/nginx/conf.d/*.conf;
+ #include /etc/nginx/sites-enabled/*;
+}
+~~~
diff --git a/versioned_docs/version-3.7.1/Serving_the_Internet/Updating-a-JATOS-server-installation.md b/versioned_docs/version-3.7.1/Serving_the_Internet/Updating-a-JATOS-server-installation.md
new file mode 100644
index 0000000000..17553e8109
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Serving_the_Internet/Updating-a-JATOS-server-installation.md
@@ -0,0 +1,49 @@
+---
+title: Updating a JATOS server installation
+slug: /Updating-a-JATOS-server-installation.html
+sidebar_position: 11
+---
+
+Updating the server instance is equivalent to doing it [locally](Update-JATOS.html), but make sure that you know what you're doing; especially if you have paired JATOS with a MySQL database.
+
+**Backup your JATOS**
+
+The easiest way to backup is to do a snapshot of the whole server. If you use an external MySQL database with your JATOS, make a backup e.g. using `mysqldump -u yourUserName -p yourDatabaseName > yourDatabaseName.out` - or a snapshot of the whole database server.
+
+As with [updating of a local JATOS installation](Update-JATOS.html) you can do it automatically or manually.
+
+After updating you can check the new JATOS installation with the test page: go to _Administration_ ⇒ _Tests_ and check that all tests are 'OK'.
+
+
+## Automatic Update (recommended)
+
+This is the easiest way. Then it's [the same as in a local installation](Update-JATOS.html#automatic-updates).
+
+If you did a manual backup before you don't need to do the backup offered during the update process.
+
+## Manual Update (if automatic doesn't work for you)
+
+You have two ways to update manually: 1) Keep your studies but discard all your result data and batches. 2) Keep everything, including your studies and result data (might not always be possible).
+
+### First option: quick and dirty (discarding result data)
+
+You can just follow the [update instructions for the local installation](Update-JATOS.html#first-easy-way-discarding-your-result-data). If you use a MySQL database don't forget to [configure it with a clean and new one](Configure-JATOS-on-a-Server.html) (not the one from your old JATOS). Do not use the new JATOS with the old MySQL database unless you choose to keep your data, as described below.
+
+### Second option: keeping everything
+
+This means that we have to configure the MySQL database or copy the embedded H2 database files.
+
+1. Stop the old JATOS using `./loader.sh stop`
+1. Copy the new JATOS version to your server, e.g. copy it into the same folder where your old JATOS is located. Don't yet remove the old JATOS instance.
+1. Unzip the new JATOS (`unzip jatos.zip`)
+1. From the old JATOS installation copy some folders to the new one
+ 1. Your assets root folder to the new JATOS installation (Note: By default your assets root folder is called `study_assets_root` and lays in the JATOS folder but you might have [changed this](Configure-JATOS-on-a-Server.html).
+ 1. If exists, your folder for uploaded result files (Note: By default this folder is called `result_uploads` and lays in the JATOS folder but you might have [changed this](Configure-JATOS-on-a-Server.html).
+ 1. If exists, `study_logs`
+1. Database
+ * H2 - If you are using the default H2 database: From your the folder of your old JATOS installation copy the folder `database` to the new JATOS installation. [Remember to stop JATOS before copying the folder](Troubleshooting.html#database-is-corrupted).
+ * MySQL - For MySQL you don't have to change anything on the database side.
+1. [Configure the new JATOS like the old one](Configure-JATOS-on-a-Server.html) - usually it's enough to copy the `production.conf` from the old `conf` folder into the new one
+1. Start the new JATOS using `./loader.sh start`
+1. Open JATOS' test page (_Administration_ ⇒ _Tests_) and check that everything is 'OK'
+
diff --git a/versioned_docs/version-3.7.1/Serving_the_Internet/_category_.json b/versioned_docs/version-3.7.1/Serving_the_Internet/_category_.json
new file mode 100644
index 0000000000..ac8dc8b2db
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Serving_the_Internet/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Serving the Internet",
+ "position": 6
+}
diff --git a/versioned_docs/version-3.7.1/Write_your_study/Adapt-pre-written-code-to-run-it-in-JATOS.md b/versioned_docs/version-3.7.1/Write_your_study/Adapt-pre-written-code-to-run-it-in-JATOS.md
new file mode 100644
index 0000000000..7c6236bb7b
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/Adapt-pre-written-code-to-run-it-in-JATOS.md
@@ -0,0 +1,111 @@
+---
+title: Adapt pre written code to run it in JATOS
+slug: /Adapt-pre-written-code-to-run-it-in-JATOS.html
+sidebar_position: 3
+---
+
+**Make Your Existing Code Run in JATOS - or How To Jatosify a Study**
+
+You might have a task, experiment, survey, or study running in a browser. You might have all its files like HTML, JavaScripts, images, etc. And now you want to run it with JATOS? Then follow this page.
+
+**Developement of a JATOS study usually happens on your local JATOS: [Run an experiment with JATOS - Workflow](Run-an-experiment-with-JATOS-Workflow.html)**
+
+### Create the study in your local JATOS
+
+1. Create a new study with the '**New Study**' button in JATOS' header. Choose a study title and a folder name. Leave the other fields empty for now and click 'Create'. JATOS will have created a new folder within your assets root folder (default is `/path_to_your_JATOS/study_assets_root/`).
+1. Copy all your files (HTML, JavaScripts, images, audio, ...) into your new study folder.
+1. Back in the JATOS GUI, and within the newly created study, create a **new component** by clicking 'Components' and then 'New'. Choose a component title and set the HTML file name, to the name of the HTML file you just copied into the study folder.
+1. In your HTML, CSS and JavaScripts, for your paths you can choose between 1) relative paths or 2) absolute paths. **Relative paths are recommended** since they are shorter and do not change after an export-import of a study.
+
+ 1. **Relative paths)** Just use the relative path within your study's folder.
+
+ E.g. if a file named 'survey.js' is in the root of the study's assets folder
+
+ ```html
+
+ ```
+
+ E.g. or if the file is in a subfolder 'lib'
+
+ ```html
+
+ ```
+
+ 1. **Absolute paths (deprecated))** Always use the prefix `/study_assets/` and then the study assets name you specified in your study's properties when you created it.
+
+ E.g. if you want to load the file 'survey.js' and the study's assets folder is 'my-exp'
+
+ ```html
+
+ ```
+
+ ✰ For absolute paths make sure you understand the difference between the `study_assets_root` folder and the placeholder `study_assets` in your path names. `study_assets_root` is the folder in your system (or in the server) where the assets (HTML, JS, CSS, images, etc) of **all** your JATOS studies will be stored. You can [configure](Configure-JATOS-on-a-Server.html#study-assets-root-path) the location of this folder. `study_assets`, on the other hand, is just a placeholder that will go in your HTML files. JATOS will interpret this and replace the placeholder with the path, (specific to the study) that you entered in the field 'Study assets directory name' in your Study's Properties. The advantage of this is that you can change the location or name of the assets for any study, or export-import a study into a different computer, and the study will still run without having to make any changes in the HTML code.
+
+
+1. Now it's time for a first glimpse: Click the '**Run**' button in either the study's or the component's toolbar. Your experiment should run like it did before without JATOS. Use the browser's developer tools to check for eventually missing files and other occurring errors.
+
+### Edit your HTML and JavaScript
+
+Up to this point JATOS served as a mere provider of your files. Now we want to use a feature of JATOS: We want to store your result data in JATOS' safe database.
+
+1. Include the **_jatos.js_** library in your HTML. In your `` add the line
+
+ ```html
+ `
+ ```
+
+1. Add **`jatos.onLoad`**
+
+ Most studies with JATOS start with this call. So whatever you want to do in your study it should start there.
+
+ ~~~javascript
+ jatos.onLoad(function() {
+ // start your code here
+ });
+ ~~~
+
+1. Now to actually **send your result data** to JATOS we use _jatos.js_' function `jatos.submitResultData`. We can pass this function any data in text format including JSON, CSV or XML. If you pass a JavaScript object it will be turned into JSON (stringified).
+
+ E.g. if we want to send a JavaScript object as JSON
+
+ ~~~javascript
+ jatos.submitResultData(myResultDataObject);
+ ~~~
+
+ `jatos.submitResultData` puts the data into JATOS database - old data that were submitted before will be overwritten. If you don't want to overwrite data you should rather use `jatos.appendResultData`.
+
+1. Instead of submitting text you can also upload files with [jatos.uploadResultFile](jatos.js-Reference.html#jatosuploadresultfile).
+
+1. At the end of your component you will want to jump to another component or end the study.
+
+ To jump to the next component:
+
+ ~~~javascript
+ jatos.startNextComponent();
+ ~~~
+
+ Or to just finish the study:
+
+ ~~~javascript
+ jatos.endStudy();
+ ~~~
+
+ You can combine this with sending result data:
+
+ ~~~javascript
+ jatos.startNextComponent(myResultDataObject);
+ ~~~
+
+ or
+
+ ~~~javascript
+ jatos.endStudy(myResultDataObject);
+ ~~~
+
+That's about it. Infos about other _jatos.js_ functions and variables you can find in the [reference](jatos.js-Reference.html).
+
+### Beyond the basics
+
+* Think about dividing your study into **several components**. You could have separate components e.g. for introduction, training, experiment and feedback. You could even consider splitting the experiment into several parts. One advantage is that if your participant stops in the middle of your study you still have the result data of the first components. Also, you can re-use components in different studies.
+* Use the study's and component's '**JSON input data**'. With them you can change variables of your code directly through JATOS' GUI, which might come handy if someone isn't good in JavaScript.
+* You can add a **quit button** to your study to allow the participant to [abort at any time](Data-Privacy-and-Ethics.html#things-you-should-consider-in-your-studies).
diff --git a/versioned_docs/version-3.7.1/Write_your_study/Change-studys-members.md b/versioned_docs/version-3.7.1/Write_your_study/Change-studys-members.md
new file mode 100644
index 0000000000..f22ce8d886
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/Change-studys-members.md
@@ -0,0 +1,22 @@
+---
+title: Change study's members
+slug: /Change-studys-members.html
+sidebar_position: 7
+---
+
+Each experimenter with access to the JATOS server (though the GUI) is a JATOS User. Users can create, modify and delete the studies they are members of. They can also export and delete results.
+
+A study in JATOS is allowed to have more than one users, also called members. Each member has the same rights, e.g. can run the study, create new Workers, add/change/delete components, export/delete results. Especially each member can add new members or remove existing members.
+
+Each study has a **Change Users** button in its study toolbar.
+
+
+
+In this menu you can add single users by their username. Of course this works only if this is already a JATOS user. For privacy reasons JATOS never shows the username (which is often an email address) in the member list.
+
+A single user is removed by unchecking the checkbox in front of its name.
+
+Additionally it is possible, if your admins allow it, to add all JATOS users at once or remove all members at once. Then you will see the _Add All_ and _Remove All_ buttons.
+
+
+
diff --git a/versioned_docs/version-3.7.1/Write_your_study/Create-a-new-study.md b/versioned_docs/version-3.7.1/Write_your_study/Create-a-new-study.md
new file mode 100644
index 0000000000..098e9f841c
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/Create-a-new-study.md
@@ -0,0 +1,33 @@
+---
+title: Create a new study
+slug: /Create-a-new-study.html
+sidebar_position: 1
+---
+
+There are different ways to create a new study for JATOS: use a builder, with jsPsych, from scratch or by modifying an existing study. Then afterwards continue with [Write your own Study - Basics and Beyond](Write-your-own-Study-Basics-and-Beyond.html) or [Adapt Pre written Code to run it in JATOS](Adapt-pre-written-code-to-run-it-in-JATOS.html).
+
+**Developement of a JATOS study usually happens on your local JATOS: [Run an experiment with JATOS - Workflow](Run-an-experiment-with-JATOS-Workflow.html)**
+
+
+### Use a builder - OpenSesame/OSWeb and lab.js
+
+Experiment builders like [OpenSesame/OSWeb](OSWeb-and-JATOS.html) and [lab.js](labjs-and-JATOS.html) have a point-and-click UI. They are easy to use and you don't have to care for the programming part. But they come with the limitation that they only allow you to do what is possible in the UI. If you want more freedom consider jsPsych or write your own study.
+
+
+### Use jsPsych
+
+[jsPsych](http://www.jspsych.org/) is a popular library for running behavioral experiments in a web browser. We have an own web page describing using [jsPsych with JATOS](jsPsych-and-JATOS.html).
+
+
+### Write your own study from scratch
+
+Writing your own study gives your the most freedom since it allows you to do whatever is possible in a modern browser. But you will have to program your own code in JavaScript, HTML and CSS.
+
+Press the **New Study** button in the header of your local JATOS. Then edit the study properties and add new components manually. All source code for your study has to got into the study assets folder you defined in the the study properties. The study assets folder is usually located in your JATOS installation folder.
+
+
+### Modify an existing study
+
+Take an existing study (e.g. from [Example Studies](/Example-Studies)) as a prototype and modify it bit by bit. Press on the **Import** button in the header and select the file of the study. Then see the source code in your study assets folder, which is usually in your JATOS installation folder.
+
+
diff --git a/versioned_docs/version-3.7.1/Write_your_study/OSWeb-and-JATOS.md b/versioned_docs/version-3.7.1/Write_your_study/OSWeb-and-JATOS.md
new file mode 100644
index 0000000000..d025198205
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/OSWeb-and-JATOS.md
@@ -0,0 +1,22 @@
+---
+title: OSWeb/OpenSesame and JATOS
+slug: /OSWeb-and-JATOS.html
+hide_table_of_contents: true
+sidebar_position: 6
+---
+
+
+
+
+
+
+
+OSWeb lets you run an [OpenSesame](https://osdoc.cogsci.nl) experiment on a browser. OpenSesame is a pretty neat program to create experiments for psychology, neuroscience, and experimental economics. You can get very far with drag-and-drop, and there's the chance to add code snippets if you need more flexibility.
+
+[OSWeb's documentation](https://osdoc.cogsci.nl/manual/osweb/workflow/) is far better than ours could ever be. So, here, we just point out that combining OSWeb with JATOS is pretty easy and straightforward: just export the experiment in OSWeb and import it in JATOS.
+
+If you want to use [Prolific](https://www.prolific.co/) to recruit participants for your OSWeb experiment running in JATOS then you can put the return link in the 'End Redirect URL' field of your Study Properties (in JATOS GUI).
+
+If you'd like to know more
+* Sebastiaan Mathot's [tutorial](https://www.youtube.com/watch?v=0448NeoUaqU)
+* [Workshop about OpenSesame, Python, and JATOS](https://www.youtube.com/playlist?list=PLSadj_kFpja_IOBQZrKf56RpjzUl3W6SP) (12 lessons)
diff --git a/versioned_docs/version-3.7.1/Write_your_study/Session-Data-Three-Types.md b/versioned_docs/version-3.7.1/Write_your_study/Session-Data-Three-Types.md
new file mode 100644
index 0000000000..4879bcd7c1
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/Session-Data-Three-Types.md
@@ -0,0 +1,56 @@
+---
+title: Session Data - Three Types
+slug: /Session-Data-Three-Types.html
+sidebar_position: 9
+---
+
+### When to use the sessions?
+
+
+
+
+
+
+
+Often you want to store information during a study run and share it with other components of the same study, or between workers of a group or batch. The three different session types let you transfer data in this way (shown by the curved arrows in the picture on the right). Workers can write into the sessions through _jatos.js_.
+
+The data stored in the sessions are **volatile** - do not use the sessions to store data permanently. Instead, store any information that might be useful for data analysis in the **Result Data**. Unlike the data stored in the sessions, the Result Data are stored permanently in the JATOS server, and will never be deleted automatically.
+
+The data stored in the sessions are not exported or imported together with a study. If you want data to be exported with a study, use the **JSON Input Data** instead.
+
+
+
+### Comparative Overview
+
+| | Batch Session | Group Session | Study Session |
+|-|-------------------|-------------------|-------------------|
+| **Scope (accesible by)** | All workers in a batch | All workers in a group | All components in a study |
+| **Usage** | Exchange and store data relevant for all members of a batch | Exchange and temporarily store data relevant for all members of a group | Exchange and temporarily store data between components of a single study run |
+| **Example use** | (Pseudo-)randomly assign conditions to different workers; Combine results from different groups working in the same batch | Store choices of the two members of a Prisoner's Dilemma game | Pass on correct answers between components; Keep track of the number of iterations of a given component that is repeated |
+| **Lifetime** | Survives after all workers finished their studies | Automatically deleted once the group is finished | Deleted once the worker finished the study - Hence temporary|
+| **Updated when and via** | Any time you call one of the [`jatos.batchSession` functions](jatos.js-Reference.html#functions-to-access-the-batch-session) | Any time you call one of the [`jatos.groupSession` functions](jatos.js-Reference.html#functions-to-access-the-group-session) | At the end of each component or if you call [`jatos.setStudySessionData`](jatos.js-Reference.html#jatossetstudysessiondata) |
+| **Visible and editable from JATOS' GUI** |  |  |  |
+| **Requires WebSockets** |  |  |  |
+| **Included in exported studies** |  |  |  |
+
+### Example Study
+
+We have an [example study](/Example-Studies), where we show the three different session types in action. Try it yourself:
+
+1. Download and import the study. You'll find that the study contains two components: "First" and "Second".
+
+1. Run the study once: easiest is as a JATOS worker (just click 'Run' on the study bar, not on any of the component bars).
+
+1. The first component will prompt you for a name. It will then write the name you enter here into the **Study Session**. Because all components have access to the Study Session, the second component can read it and use your name in a chat window.
+
+ 
+
+1. When you click on 'Next', the second component will load. Here you will see two chat windows: The left one is called the group chat because it uses the Group Session; the right one is called batch chat because it uses the Batch Session. For now you're alone in these chat rooms. So, without closing this run and from new browser tabs, **run the study 2 more times (at least)**. You can choose any study link type you want.
+
+ 
+
+1. Now you have 3 simultaneous study runs. You will notice while writing into the group chat that two of your workers are in the same group - the third one has their own group. Why 2 per group? Because we [set the groups to a maximum of 2 members each](Write-Group-Studies-I-Setup.html#group-settings-in-each-batchs-properties). The group chat will use the **Group Session** to allow the 2 members of each group to communicate with each other. Members of other groups will not have access to the chats of this group. However, anything written into the **Batch Session** will be accesssible by all workers that are members of this batch, regardless of the group they're in.
+
+ 
+ 
+
diff --git a/versioned_docs/version-3.7.1/Write_your_study/Submit-and-upload-data-to-the-server.md b/versioned_docs/version-3.7.1/Write_your_study/Submit-and-upload-data-to-the-server.md
new file mode 100644
index 0000000000..3e803790c0
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/Submit-and-upload-data-to-the-server.md
@@ -0,0 +1,26 @@
+---
+title: Submit and upload data to the server
+slug: /Submit-and-upload-data-to-the-server.html
+sidebar_position: 8
+---
+
+If you wrote your study with HTML/JavaScript/CSS, you'll need to know how to send to the JATOS server for safe storage and easy later retrieval. Here we describe how to submit data. See [Manage Results](Manage-Results.html) to know how to retrieve it.
+
+
+### Submit result data
+
+There are a couple of _jatos.js_ functions that allow you to send data to the JATOS server. The result data can be anything that can be put into text, which includes formats like JSON or CSV. Images, audio or video data can only be sent via Upload (explained below).
+
+The two functions [`jatos.submitResultData`](jatos.js-Reference.html#jatossubmitresultdata) and [`jatos.appendResultData`](jatos.js-Reference.html#jatosappendresultdata) let you submit text data to the server. They are similar to each other. The only difference is that the first overwrites the data and therefore deletes previously sent data, while the latter appends new data to old data.
+
+Then there are a couple of functions that do something else (primarily) but allow you to send result data out of convenience, since they usually go together anyway. These are all functions that start a new component (e.g. [`jatos.startNextComponent`](jatos.js-Reference.html#jatosstartnextcomponent), [`jatos.startComponentByPos`](jatos.js-Reference.html#jatosstartcomponentbypos)) and all functions that end a study ([`jatos.endStudy`](jatos.js-Reference.html#jatosendstudy) and [`jatos.endStudyAndRedirect`](jatos.js-Reference.html#jatosendstudyandredirect)).
+
+Sending data to a server can take some time, depending on the internet connection and the size of the result data. The convenience functions have the advantage that they will execute their primary function (e.g. start next component) only *after* the result data have been submitted. Therefore these are generally safer ways to submit your result data.
+
+### Upload and download result files
+
+If you want to upload audio, video, images or any other data that is not in text format, then uploading a result file is what you need: [`jatos.uploadResultFile`](jatos.js-Reference.html#jatosuploadresultfile).
+
+And if you want to, in a later component, access the uploaded files again you can download them with [`jatos.downloadResultFile`](jatos.js-Reference.html#jatosdownloadresultfile).
+
+For more real-world examples have a look at the ['Drawing' and the 'Video Recording' examples](/Example-Studies).
diff --git a/versioned_docs/version-3.7.1/Write_your_study/Write-your-own-Study-Basics-and-Beyond.md b/versioned_docs/version-3.7.1/Write_your_study/Write-your-own-Study-Basics-and-Beyond.md
new file mode 100644
index 0000000000..823572bd0e
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/Write-your-own-Study-Basics-and-Beyond.md
@@ -0,0 +1,103 @@
+---
+title: Write your own Study - Basics and Beyond
+slug: /Write-your-own-Study-Basics-and-Beyond.html
+sidebar_position: 2
+---
+
+After you [created a new study](Create-a-new-study.html) ... what comes next?
+
+**Developement of a JATOS study usually happens on your local JATOS: [Run an experiment with JATOS - Workflow](Run-an-experiment-with-JATOS-Workflow.html)**
+
+
+## Add a component
+
+If you have an empty study you want to add a component. A component corresponds to a webpage defined by an HTML file. A study can have more than one component - this is actually a strength of JATOS: e.g. one can combine different experiments into one, or easily add an survey to an existing experiment.
+
+To add a component go to your study and click on Components -> New.
+
+
+
+Then in the following form you define the component's properties: enter the component's title and most importantly its 'HTML file path'. This is the path to the HTML file that starts this component.
+
+
+
+Click on 'Create' and you are done. If you add more than one component you can change the order in which they run by drag-and-drop on the position button.
+
+
+## Mandatory lines in your components' HTML
+
+A study can have one or multiple components and each component has an HTML file associated that is defined in the component's properties.
+
+Here is the absolute minimum that any component HTML file must have to run with JATOS:
+
+1. A link to the _jatos.js_ library in the head section
+
+ ~~~ html
+
+
+
+
+
+ ~~~
+
+1. The second bit is not really necessary but without defining the `jatos.onLoad` callback function you won't be able to use most of _jatos.js_' features. Of course you could start right away with any JavaScript but if you want to use _jatos.js_' variables and functions you have to wait untill _jatos.js_ is finished initializing.
+
+ ~~~ html
+
+ ~~~
+
+
+## Save your result data
+
+You probably want to save the data that is collected during your experiments. There are generally two ways to do this: 1) result data or 2) result files - and there is a [documentation page about it](Submit-and-upload-data-to-the-server.html).
+
+
+## _jatos.js_ Reference
+
+In your JavaScript you will use _jatos.js_ to handle everything JATOS related and in its [reference](jatos.js-Reference.html) every function and field is described in detail.
+
+
+## Study JSON Input and Component JSON Input
+
+Your experiment is defined by its source code, its HTML, JavaScript and CSS. There you specify all text or parameters. But sometimes you want to be able to quickly change your experiment without touching the source code.
+
+E.g. you want to be able to quickly change
+* an introductory text
+* the number of trials
+* some parameter needed in the experiment
+
+This you can achieve with the Study JSON Input or Component JSON Input because both can be easily edited in the Study Properties or Component Properties.
+
+
+
+Both input fields take [JSON](https://www.w3schools.com/whatis/whatis_json.asp) and the data you put in there is then available in your study's JavaScript via `jatos.studyJsonInput` and `jatos.componentJsonInput`.
+
+The difference between the Study JSON Input and Component JSON Input is that the first one is available during the whole study run, in all components, and the latter one only in the component for which it is specified.
+
+**Example:**
+
+If you put the following in the Study JSON Input
+
+```javascript
+{
+ "introduction": "this is a text",
+ "order": [3, 1, 2]
+}
+```
+
+you can access those fields in your JavaScript with `jatos.studyJsonInput.introduction` and `jatos.studyJsonInput.order`.
+
+
+## Study / Batch / Group Session
+
+The sessions are there to help you exchange data within a study, batch or group. The Study Session allows to pass on data within the same study run, from one component to the next. With the Batch Session one can transfer data between study runs that belong to the same batch. There is a whole page dedicated to those sessions: [Session Data - Three Types](/Session-Data-Three-Types.html).
+
+
+## Group Studies
+
+JATOS allows group studies in which several participants can work together on the same experiment and exchange data in real-time.
+To get an idea it's best to start with [examples](Example-Group-Studies.html), then one can go on to write them: [Write Group Studies I - Setup](Write-Group-Studies-I-Setup.html) and [Write Group Studies II - JavaScript and Messaging](Write-Group-Studies-II-JavaScript-and-Messaging.html).
diff --git a/versioned_docs/version-3.7.1/Write_your_study/_category_.json b/versioned_docs/version-3.7.1/Write_your_study/_category_.json
new file mode 100644
index 0000000000..78484f0cb4
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Write your study",
+ "position": 2
+}
diff --git a/versioned_docs/version-3.7.1/Write_your_study/jsPsych-and-JATOS.md b/versioned_docs/version-3.7.1/Write_your_study/jsPsych-and-JATOS.md
new file mode 100644
index 0000000000..3cb2a27557
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/jsPsych-and-JATOS.md
@@ -0,0 +1,47 @@
+---
+title: jsPsych and JATOS
+slug: /jsPsych-and-JATOS.html
+hide_table_of_contents: true
+sidebar_position: 4
+---
+
+
+
+
+
+
+
+JATOS basically cares for the server side: it stores result data, does worker management etc. JATOS doesn't care so much for what happens in the browser itself - your HTML, JavaScript and CSS. Of course you can write this all yourself, but you could also use a framework for this. A very good one is [jsPsych](http://www.jspsych.org/).
+
+In [our example studies](/Example-Studies) are a couple of jsPsych ones.
+
+Here are the necessary changes if you want to adapt your jsPsych experiment so that it runs within (and sends the result data to) JATOS. Additionally you can have a look at [Adapt Pre written Code to run it in JATOS](Adapt-pre-written-code-to-run-it-in-JATOS.html).
+
+Every jsPsych version works slightly different. Here we explain the steps for jsPsych 7 (for older versions have a look [here](/3.6.1/jsPsych-and-JATOS.html)).
+
+### How to turn your jsPsych 7 experiment into a JATOS study
+
+1. Include the _jatos.js_ library in the `` of your HTML
+
+ ~~~ html
+
+ ~~~
+
+1. Tell jsPsych to send your result data to JATOS
+
+ ~~~ javascript
+ var jsPsych = initJsPsych({
+ on_finish: () => jatos.endStudy(jsPsych.data.get().json())
+ });
+ ~~~
+
+1. Wrap jsPsych's run in `jatos.onLoad` and if you want add a 'Cancel' button with `jatos.addAbortButton`.
+
+ ~~~ javascript
+ jatos.onLoad(() => {
+ jatos.addAbortButton();
+ jsPsych.run(timeline);
+ });
+ ~~~
+
+That's all. Have a look at the 'Simple Reaction Time Task' in our [example studies](/Example-Studies) to see a full example with jsPsych 7.
\ No newline at end of file
diff --git a/versioned_docs/version-3.7.1/Write_your_study/labjs-and-JATOS.md b/versioned_docs/version-3.7.1/Write_your_study/labjs-and-JATOS.md
new file mode 100644
index 0000000000..ca2ee9397f
--- /dev/null
+++ b/versioned_docs/version-3.7.1/Write_your_study/labjs-and-JATOS.md
@@ -0,0 +1,20 @@
+---
+title: lab.js and JATOS
+slug: /labjs-and-JATOS.html
+hide_table_of_contents: true
+sidebar_position: 5
+---
+
+
+
+
+
+
+
+[lab.js](https://lab.js.org/) is an easy to use tool to create online experiments. Their [Builder](https://labjs.felixhenninger.com/) makes creating an online experiment a piece of cake - although you can also write code yourself: lab.js supports this too.
+
+lab.js and JATOS fit perfectly together: **lab.js directly exports JATOS studies**. So you don't need to write or modify any bits of code. You can create your experiment with lab.js. Then just import your studies into JATOS and let particpants run it.
+
+lab.js already has a [great documentation](https://labjs.readthedocs.io/en/latest/index.html) and one page there is solely dedicated to JATOS: [Collecting data with JATOS](https://labjs.readthedocs.io/en/latest/learn/deploy/3c-jatos.html).
+
+That's all there is to say.
diff --git a/versioned_sidebars/version-3.7.1-sidebars.json b/versioned_sidebars/version-3.7.1-sidebars.json
new file mode 100644
index 0000000000..caea0c03ba
--- /dev/null
+++ b/versioned_sidebars/version-3.7.1-sidebars.json
@@ -0,0 +1,8 @@
+{
+ "tutorialSidebar": [
+ {
+ "type": "autogenerated",
+ "dirName": "."
+ }
+ ]
+}
diff --git a/versions.json b/versions.json
index a09d4f10f2..e60a51ec32 100644
--- a/versions.json
+++ b/versions.json
@@ -1,3 +1,4 @@
[
+ "3.7.1",
"3.6.1"
]