Authorization

This document contains details for the /api/login endpoint, including the request body, response token, and status codes.

Endpoint

Method	Endpoint
POST	/api/login

Headers

Header	Required	Description
Content-Type	Yes	application/json
Client-Device-Id	No	Client device identifier. When provided, the response includes deviceId.

Content-Type: application/json

Request body

Field	Type	Required	Description
login	string	Yes	User login or email
password	string	Yes	User password

Request example

Node.js

const response = await fetch(
  "https://api.docstudio.com/api/login",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      login: "[e-mail]",
      password: "password"
    })
  }
);

const body = await response.text();

if (!response.ok) {
  throw new Error(
    `Request failed: ${response.status}\n${body}`
  );
}

console.log(body);

PHP

<?php

$payload = json_encode([
    "login" => "[e-mail]",
    "password" => "password"
], JSON_THROW_ON_ERROR);

$curl = curl_init(
    "https://api.docstudio.com/api/login"
);

curl_setopt_array($curl, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Content-Type: application/json"
    ],
    CURLOPT_POSTFIELDS => $payload,
    CURLOPT_RETURNTRANSFER => true
]);

$body = curl_exec($curl);

if ($body === false) {
    throw new RuntimeException(curl_error($curl));
}

$status = curl_getinfo($curl, CURLINFO_RESPONSE_CODE);
curl_close($curl);

if ($status < 200 || $status >= 300) {
    throw new RuntimeException(
        "Request failed: {$status}\n{$body}"
    );
}

echo $body;

Python

import requests

response = requests.post(
    "https://api.docstudio.com/api/login",
    json={
        "login": "[e-mail]",
        "password": "password",
    },
    timeout=30,
)

response.raise_for_status()
print(response.text)

Ruby

require "json"
require "net/http"
require "uri"

uri = URI(
  "https://api.docstudio.com/api/login"
)

request = Net::HTTP::Post.new(uri)
request["Content-Type"] = "application/json"
request.body = JSON.generate(
  login: "[e-mail]",
  password: "password"
)

response = Net::HTTP.start(
  uri.hostname,
  uri.port,
  use_ssl: uri.scheme == "https"
) do |http|
  http.request(request)
end

unless response.is_a?(Net::HTTPSuccess)
  raise "Request failed: #{response.code}\n#{response.body}"
end

puts response.body

Go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	payload := map[string]string{
		"login":    "[e-mail]",
		"password": "password",
	}

	requestBody, err := json.Marshal(payload)
	if err != nil {
		panic(err)
	}

	request, err := http.NewRequest(
		http.MethodPost,
		"https://api.docstudio.com/api/login",
		bytes.NewReader(requestBody),
	)
	if err != nil {
		panic(err)
	}

	request.Header.Set(
		"Content-Type",
		"application/json",
	)

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	body, err := io.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}

	if response.StatusCode < 200 ||
		response.StatusCode >= 300 {
		panic(fmt.Sprintf(
			"Request failed: %s\n%s",
			response.Status,
			body,
		))
	}

	fmt.Println(string(body))
}

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws Exception {
    String payload = """
        {
          "login": "[e-mail]",
          "password": "password"
        }
        """;

    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
            "https://api.docstudio.com/api/login"
        ))
        .header(
            "Content-Type",
            "application/json"
        )
        .POST(
            HttpRequest.BodyPublishers.ofString(payload)
        )
        .build();

    HttpResponse<String> response =
        HttpClient.newHttpClient().send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

    if (response.statusCode() < 200 ||
        response.statusCode() >= 300) {
      throw new RuntimeException(
          "Request failed: " + response.statusCode()
          + "\n" + response.body()
      );
    }

    System.out.println(response.body());
  }
}

.NET

using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;

var payload = JsonSerializer.Serialize(new
{
    login = "[e-mail]",
    password = "password"
});

using var client = new HttpClient();

using var request = new HttpRequestMessage(
    HttpMethod.Post,
    "https://api.docstudio.com/api/login"
);

request.Content = new StringContent(
    payload,
    Encoding.UTF8,
    "application/json"
);

using var response = await client.SendAsync(request);
var body = await response.Content.ReadAsStringAsync();

if (!response.IsSuccessStatusCode)
{
    throw new HttpRequestException(
        $"Request failed: {(int)response.StatusCode}\n{body}"
    );
}

Console.WriteLine(body);

cURL

curl --request POST \
  --url 'https://api.docstudio.com/api/login' \
  --header 'Content-Type: application/json' \
  --data '{
    "login": "[e-mail]",
    "password": "password"
  }'

Response

The response always contains a temporary authorization token. The deviceId field is returned only when the request includes the client device ID header; otherwise, this field is omitted.

Field	Type	Description
token	string	Temporary authorization token. Expires after 3 hours
deviceId	string	Device ID returned only when the request includes the client device identifier header

Response example

When the request does not include the Client-Device-Id header, the response contains only the temporary authorization token. When the header is provided, the response also contains the generated deviceId.

Response without Client-Device-Id

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
}

Response with Client-Device-Id

{
  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "deviceId": "{deviceId}"
}

Status codes

Code	Description
200	Success. The response contains a temporary authorization token and, when requested, a device ID
401	Invalid login or password
403	Authenticated user lacks required access

Related topics

• Authentication and application tokens

• API token security

• Error Codes