# Generate magic link for manager login

POST https://api.letsdeel.com/rest/v2/managers/magic-links
Content-Type: application/json

Generate a one-time magic link that allows a manager to log in to Deel without entering credentials. The target manager must belong to the requesting organization and cannot be an organization admin. Only available for White Label enabled organizations or Partners or Child organizations. The magic link expires after 5 minutes and can only be used once. After clicking the link, the manager will be automatically authenticated and redirected to Deel.
 **Token scopes**: `auth:write`

Reference: https://developer.deel.com/api/reference/endpoints/managers/generate-magic-link-for-manager-login

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: Deel HRIS SCIM API
  version: 1.0.0
paths:
  /managers/magic-links:
    post:
      operationId: generate-magic-link-for-manager-login
      summary: Generate magic link for manager login
      description: >-
        Generate a one-time magic link that allows a manager to log in to Deel
        without entering credentials. The target manager must belong to the
        requesting organization and cannot be an organization admin. Only
        available for White Label enabled organizations or Partners or Child
        organizations. The magic link expires after 5 minutes and can only be
        used once. After clicking the link, the manager will be automatically
        authenticated and redirected to Deel.
         **Token scopes**: `auth:write`
      tags:
        - subpackage_managers
      parameters:
        - 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:
        '201':
          description: Magic link generated successfully
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Managers_generateMagicLinkForManagerLogin_Response_201
        '400':
          description: Operation failed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ApiErrorContainer'
        '401':
          description: Unauthorized - Invalid or missing authentication token
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/GenerateMagicLinkForManagerLoginRequestUnauthorizedError
        '403':
          description: Forbidden - Not allowed to generate magic link for this manager
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/GenerateMagicLinkForManagerLoginRequestForbiddenError
        '404':
          description: Not Found - Manager does not exist or is not in organization
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/GenerateMagicLinkForManagerLoginRequestNotFoundError
        '500':
          description: Internal Server Error
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/GenerateMagicLinkForManagerLoginRequestInternalServerError
      requestBody:
        description: Details for magic link for managers generation.
        content:
          application/json:
            schema:
              type: object
              properties:
                data:
                  $ref: >-
                    #/components/schemas/ManagersMagicLinksPostRequestBodyContentApplicationJsonSchemaData
servers:
  - url: https://api.letsdeel.com/rest/v2
  - url: https://api-staging.letsdeel.com/rest/v2
components:
  schemas:
    ManagersMagicLinksPostRequestBodyContentApplicationJsonSchemaData:
      type: object
      properties:
        manager_id:
          type: string
          description: Manager id.
      title: ManagersMagicLinksPostRequestBodyContentApplicationJsonSchemaData
    ManagersMagicLinksPostResponsesContentApplicationJsonSchemaData:
      type: object
      properties:
        created_at:
          type: string
          format: date-time
          description: When the magic link was created (ISO 8601 format)
        expires_at:
          type: string
          format: date-time
          description: When the magic link expires (ISO 8601 format)
        magic_link:
          type: string
          description: >-
            The magic link URL that users can click and log in to Deel
            automatically
      required:
        - created_at
        - expires_at
        - magic_link
      title: ManagersMagicLinksPostResponsesContentApplicationJsonSchemaData
    Managers_generateMagicLinkForManagerLogin_Response_201:
      type: object
      properties:
        data:
          $ref: >-
            #/components/schemas/ManagersMagicLinksPostResponsesContentApplicationJsonSchemaData
      required:
        - data
      title: Managers_generateMagicLinkForManagerLogin_Response_201
    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
    ManagersMagicLinksPostResponsesContentApplicationJsonSchemaErrorsItems:
      type: object
      properties:
        code:
          type: string
          description: Machine-readable error code
        field:
          type: string
          description: The field that caused the error
        message:
          type: string
          description: Human-readable error message
      required:
        - code
        - field
        - message
      title: ManagersMagicLinksPostResponsesContentApplicationJsonSchemaErrorsItems
    GenerateMagicLinkForManagerLoginRequestUnauthorizedError:
      type: object
      properties:
        errors:
          type: array
          items:
            $ref: >-
              #/components/schemas/ManagersMagicLinksPostResponsesContentApplicationJsonSchemaErrorsItems
      title: GenerateMagicLinkForManagerLoginRequestUnauthorizedError
    GenerateMagicLinkForManagerLoginRequestForbiddenError:
      type: object
      properties:
        errors:
          type: array
          items:
            $ref: >-
              #/components/schemas/ManagersMagicLinksPostResponsesContentApplicationJsonSchemaErrorsItems
      title: GenerateMagicLinkForManagerLoginRequestForbiddenError
    GenerateMagicLinkForManagerLoginRequestNotFoundError:
      type: object
      properties:
        errors:
          type: array
          items:
            $ref: >-
              #/components/schemas/ManagersMagicLinksPostResponsesContentApplicationJsonSchemaErrorsItems
      title: GenerateMagicLinkForManagerLoginRequestNotFoundError
    GenerateMagicLinkForManagerLoginRequestInternalServerError:
      type: object
      properties:
        errors:
          type: array
          items:
            $ref: >-
              #/components/schemas/ManagersMagicLinksPostResponsesContentApplicationJsonSchemaErrorsItems
      title: GenerateMagicLinkForManagerLoginRequestInternalServerError
  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/managers/magic-links"

payload = {}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://api.letsdeel.com/rest/v2/managers/magic-links';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{}'
};

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.letsdeel.com/rest/v2/managers/magic-links"

	payload := strings.NewReader("{}")

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

	req.Header.Add("Authorization", "Bearer <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.letsdeel.com/rest/v2/managers/magic-links")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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.letsdeel.com/rest/v2/managers/magic-links")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.letsdeel.com/rest/v2/managers/magic-links', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.letsdeel.com/rest/v2/managers/magic-links");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.letsdeel.com/rest/v2/managers/magic-links")! 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()
```