> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.prolific.com/llms.txt.
> For full documentation content, see https://docs.prolific.com/llms-full.txt.

# Create a test participant for a researcher

POST https://api.prolific.com/api/v1/researchers/participants/
Content-Type: application/json

### Overview
Creates a test participant with the same details as the researcher and the supplied email. This participant will
bypass any fraud checks and on-boarding steps.

### Enabling the feature
This endpoint is only enabled for select workspaces and will need enabling before the endpoint can be used.

### Participant Limitations
- The participant will be limited to take studies only in the workspaces associated to the researcher and where
the feature is enabled.
- The participant will not be able to cashout any balance earned from completing studies.

### Usage
- The API response contains the participant ID. This can be used in a custom allowlist or participant group to
target the participant on studies. This enables the researcher to test the study set up end-to-end.
- A randomly generated password is assigned to the participant account. We recommend that you request to reset
the password, and use this new password to login to the participant account.


Reference: https://docs.prolific.com/api-reference/users/create-test-participant-for-researcher

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: Prolific API for Data Collectors
  version: 1.0.0
paths:
  /api/v1/researchers/participants/:
    post:
      operationId: create-test-participant-for-researcher
      summary: Create a test participant for a researcher
      description: >
        ### Overview

        Creates a test participant with the same details as the researcher and
        the supplied email. This participant will

        bypass any fraud checks and on-boarding steps.


        ### Enabling the feature

        This endpoint is only enabled for select workspaces and will need
        enabling before the endpoint can be used.


        ### Participant Limitations

        - The participant will be limited to take studies only in the workspaces
        associated to the researcher and where

        the feature is enabled.

        - The participant will not be able to cashout any balance earned from
        completing studies.


        ### Usage

        - The API response contains the participant ID. This can be used in a
        custom allowlist or participant group to

        target the participant on studies. This enables the researcher to test
        the study set up end-to-end.

        - A randomly generated password is assigned to the participant account.
        We recommend that you request to reset

        the password, and use this new password to login to the participant
        account.
      tags:
        - subpackage_users
      parameters:
        - name: Authorization
          in: header
          description: >-
            The Prolific API uses API token to authenticate requests. You can
            create an API token directly from your settings.


            Your API token does not have an expiry date and carries full
            permission, so be sure to keep them secure.


            If your token is leaked, delete it and create a new one directly in
            the app.


            In your requests add `Authorization` header with the value `Token
            <your token>`.
          required: true
          schema:
            type: string
      responses:
        '201':
          description: Created
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/CreateTestParticipantForResearcherResponse
        '400':
          description: Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateTestParticipantForResearcher'
servers:
  - url: https://api.prolific.com
components:
  schemas:
    CreateTestParticipantForResearcher:
      type: object
      properties:
        email:
          type: string
          format: email
          description: >
            - The email of the test participant.

            - This cannot be an email that has been registered with Prolific
            already.
      required:
        - email
      title: CreateTestParticipantForResearcher
    CreateTestParticipantForResearcherResponse:
      type: object
      properties:
        participant_id:
          type: string
          format: objectId
          description: The ID of the test participant
      title: CreateTestParticipantForResearcherResponse
    ErrorDetailDetail2:
      type: object
      properties:
        any_field:
          type: array
          items:
            type: string
          description: >-
            Name of the field with a validation error and as a value an array
            with the error descriptions
      description: All fields with validation errors
      title: ErrorDetailDetail2
    ErrorDetailDetail:
      oneOf:
        - type: string
        - type: array
          items:
            type: string
        - $ref: '#/components/schemas/ErrorDetailDetail2'
      description: Error detail
      title: ErrorDetailDetail
    ErrorDetail:
      type: object
      properties:
        status:
          type: integer
          description: Status code as in the http standards
        error_code:
          type: integer
          description: Internal error code
        title:
          type: string
          description: Error title
        detail:
          $ref: '#/components/schemas/ErrorDetailDetail'
          description: Error detail
        additional_information:
          type: string
          description: Optional extra information
        traceback:
          type: string
          description: Optional debug information
        interactive:
          type: boolean
      required:
        - status
        - error_code
        - title
        - detail
      title: ErrorDetail
    Error:
      type: object
      properties:
        error:
          $ref: '#/components/schemas/ErrorDetail'
      required:
        - error
      title: Error
  securitySchemes:
    token:
      type: apiKey
      in: header
      name: Authorization
      description: >-
        The Prolific API uses API token to authenticate requests. You can create
        an API token directly from your settings.


        Your API token does not have an expiry date and carries full permission,
        so be sure to keep them secure.


        If your token is leaked, delete it and create a new one directly in the
        app.


        In your requests add `Authorization` header with the value `Token <your
        token>`.

```

## SDK Code Examples

```python
import requests

url = "https://api.prolific.com/api/v1/researchers/participants/"

payload = { "email": "test.participant2024@prolific.co" }
headers = {
    "Authorization": "Token <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.prolific.com/api/v1/researchers/participants/';
const options = {
  method: 'POST',
  headers: {Authorization: 'Token <token>', 'Content-Type': 'application/json'},
  body: '{"email":"test.participant2024@prolific.co"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.prolific.com/api/v1/researchers/participants/"

	payload := strings.NewReader("{\n  \"email\": \"test.participant2024@prolific.co\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Token <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.prolific.com/api/v1/researchers/participants/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Token <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"email\": \"test.participant2024@prolific.co\"\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.prolific.com/api/v1/researchers/participants/")
  .header("Authorization", "Token <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"email\": \"test.participant2024@prolific.co\"\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.prolific.com/api/v1/researchers/participants/', [
  'body' => '{
  "email": "test.participant2024@prolific.co"
}',
  'headers' => [
    'Authorization' => 'Token <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.prolific.com/api/v1/researchers/participants/");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Token <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"test.participant2024@prolific.co\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Token <token>",
  "Content-Type": "application/json"
]
let parameters = ["email": "test.participant2024@prolific.co"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.prolific.com/api/v1/researchers/participants/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```