# Retrieve ATS hiring members

GET https://api.letsdeel.com/rest/v2/ats/hiring-members

This endpoint retrieves a list of ATS hiring members. It provides detailed information about each hiring member, including their unique identifier, name, job title, email, profile picture URL, etc. The response also includes pagination details to help navigate through large sets of hiring members.
 **Token scopes**: `ats:read`

Reference: https://developer.deel.com/api/reference/endpoints/ats/retrieve-ats-hiring-members

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: Deel HRIS SCIM API
  version: 1.0.0
paths:
  /ats/hiring-members:
    get:
      operationId: retrieve-ats-hiring-members
      summary: Retrieve ATS hiring members
      description: >-
        This endpoint retrieves a list of ATS hiring members. It provides
        detailed information about each hiring member, including their unique
        identifier, name, job title, email, profile picture URL, etc. The
        response also includes pagination details to help navigate through large
        sets of hiring members.
         **Token scopes**: `ats:read`
      tags:
        - subpackage_ats
      parameters:
        - name: cursor
          in: query
          description: The cursor for pagination
          required: false
          schema:
            type: string
        - name: limit
          in: query
          description: Maximum number of records returned in one response
          required: false
          schema:
            type: integer
            default: 20
        - name: Authorization
          in: header
          description: >
            ## Authentication

            The Deel API uses bearer tokens to authenticate requests. All API
            calls must be made over HTTPS — calls over plain HTTP or without
            authentication will fail.


            ```curl

            curl -X GET 'https://api.letsdeel.com/rest/v2/contracts' \
              -H 'Authorization: Bearer YOUR-TOKEN-HERE'
            ```


            [Learn more about authentication](/api/authentication)
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Successful operation.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ATS_retrieveAtsHiringMembers_Response_200'
        '400':
          description: Operation failed.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/RetrieveAtsHiringMembersRequestBadRequestError
        '401':
          description: Operation failed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiErrorContainer'
        '403':
          description: Operation failed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiErrorContainer'
        '404':
          description: Operation failed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiErrorContainer'
        '500':
          description: Operation failed.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/RetrieveAtsHiringMembersRequestInternalServerError
servers:
  - url: https://api.letsdeel.com/rest/v2
  - url: https://api-staging.letsdeel.com/rest/v2
components:
  schemas:
    AtsHiringMembersGetResponsesContentApplicationJsonSchemaDataItems:
      type: object
      properties:
        id:
          type: string
          format: uuid
          description: Unique identifier
        pic_url:
          type:
            - string
            - 'null'
          format: uri
          description: URL to the user's profile picture
        job_title:
          type:
            - string
            - 'null'
          description: User's job title
        last_name:
          type: string
          description: User's last name
        created_at:
          type: string
          format: date-time
          description: Creation timestamp
        first_name:
          type: string
          description: User's first name
        updated_at:
          type:
            - string
            - 'null'
          format: date-time
          description: Last update timestamp
        work_email:
          type: string
          format: email
          description: User's work email address
        hris_organization_user_id:
          type: string
          description: Unique identifier for the HRIS organization user
      title: AtsHiringMembersGetResponsesContentApplicationJsonSchemaDataItems
    ATS_retrieveAtsHiringMembers_Response_200:
      type: object
      properties:
        data:
          type: array
          items:
            $ref: >-
              #/components/schemas/AtsHiringMembersGetResponsesContentApplicationJsonSchemaDataItems
        has_more:
          type: boolean
          description: Indicates if there are more items to fetch.
        next_cursor:
          type:
            - string
            - 'null'
          description: Cursor for the next page of results
        total_count:
          type: integer
          description: Total number of users
      title: ATS_retrieveAtsHiringMembers_Response_200
    AtsHiringMembersGetResponsesContentApplicationJsonSchemaErrorsItems:
      type: object
      properties:
        code:
          type: string
          description: Machine-readable error code
        message:
          type: string
          description: Human-readable explanation of the error
      title: AtsHiringMembersGetResponsesContentApplicationJsonSchemaErrorsItems
    RetrieveAtsHiringMembersRequestBadRequestError:
      type: object
      properties:
        errors:
          type: array
          items:
            $ref: >-
              #/components/schemas/AtsHiringMembersGetResponsesContentApplicationJsonSchemaErrorsItems
      title: RetrieveAtsHiringMembersRequestBadRequestError
    ApiErrorRequest:
      type: object
      properties:
        method:
          type: string
          description: The HTTP method of the failed request
        url:
          type: string
          description: The relative URL of the failed request
        status:
          type: number
          format: double
          description: The status code of the response
        api_req_id:
          type: string
          description: The request ID of the failed request
        docs:
          type: string
          description: >-
            A link to the official documentation for the requested endpoint
            resource
        source:
          type: string
          description: The source handler which produced the returned error
        code:
          type: number
          format: double
          description: The code of the source handler which produced the returned error
      title: ApiErrorRequest
    ApiError:
      type: object
      properties:
        message:
          type: string
          description: A description of the returned error
        path:
          type: string
          description: The JSON path where input validation failed
      title: ApiError
    ApiErrorContainer:
      type: object
      properties:
        request:
          $ref: '#/components/schemas/ApiErrorRequest'
        errors:
          type: array
          items:
            $ref: '#/components/schemas/ApiError'
      title: ApiErrorContainer
    RetrieveAtsHiringMembersRequestInternalServerError:
      type: object
      properties:
        errors:
          type: array
          items:
            $ref: >-
              #/components/schemas/AtsHiringMembersGetResponsesContentApplicationJsonSchemaErrorsItems
      title: RetrieveAtsHiringMembersRequestInternalServerError
  securitySchemes:
    deelToken:
      type: http
      scheme: bearer
      description: >
        ## Authentication

        The Deel API uses bearer tokens to authenticate requests. All API calls
        must be made over HTTPS — calls over plain HTTP or without
        authentication will fail.


        ```curl

        curl -X GET 'https://api.letsdeel.com/rest/v2/contracts' \
          -H 'Authorization: Bearer YOUR-TOKEN-HERE'
        ```


        [Learn more about authentication](/api/authentication)
    oauth2:
      type: http
      scheme: bearer
      description: >-
        Standard OAuth2 security scheme based on
        https://swagger.io/docs/specification/authentication/

```

## SDK Code Examples

```python
import requests

url = "https://api.letsdeel.com/rest/v2/ats/hiring-members"

querystring = {"cursor":"cursorValue","limit":"50"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript
const url = 'https://api.letsdeel.com/rest/v2/ats/hiring-members?cursor=cursorValue&limit=50';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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"
	"net/http"
	"io"
)

func main() {

	url := "https://api.letsdeel.com/rest/v2/ats/hiring-members?cursor=cursorValue&limit=50"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	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.letsdeel.com/rest/v2/ats/hiring-members?cursor=cursorValue&limit=50")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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.get("https://api.letsdeel.com/rest/v2/ats/hiring-members?cursor=cursorValue&limit=50")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.letsdeel.com/rest/v2/ats/hiring-members?cursor=cursorValue&limit=50', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.letsdeel.com/rest/v2/ats/hiring-members?cursor=cursorValue&limit=50");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.letsdeel.com/rest/v2/ats/hiring-members?cursor=cursorValue&limit=50")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```